diff --git a/.github/workflows/build-upgrades.yml b/.github/workflows/build-upgrades.yml
index db7a5e426f..50ab26fa58 100644
--- a/.github/workflows/build-upgrades.yml
+++ b/.github/workflows/build-upgrades.yml
@@ -40,4 +40,4 @@ jobs:
           df -h
 
       - name: Run Makefile build
-        run: make build-for-upgrade
\ No newline at end of file
+        run: make build-for-upgrade
diff --git a/.github/workflows/publish_upgrade_binaries.yml b/.github/workflows/publish_upgrade_binaries.yml
index 8491cf6d1b..5e82d2cbd0 100644
--- a/.github/workflows/publish_upgrade_binaries.yml
+++ b/.github/workflows/publish_upgrade_binaries.yml
@@ -62,4 +62,4 @@ jobs:
         uses: actions/upload-artifact@v4 # Using v4, v3 also works
         with:
           name: release-tag-artifact # This name will be used to download it later
-          path: release_tag.txt
\ No newline at end of file
+          path: release_tag.txt
diff --git a/.github/workflows/test-workflow.yml b/.github/workflows/test-workflow.yml
index b33a990ab7..5d0ca97010 100644
--- a/.github/workflows/test-workflow.yml
+++ b/.github/workflows/test-workflow.yml
@@ -164,6 +164,7 @@ jobs:
         env:
           GENESIS_OVERRIDES_FILE: "inference-chain/test_genesis_overrides.json"
           USE_REGISTRY_CACHE: "1"
+          GHCR_CACHE_NAMESPACE: ${{ github.repository }}
         run: |
           make build-docker
           # devshardd self-checks build_version == the version versiond forces (dev via build/devshard-version).
diff --git a/.github/workflows/testermint-upgrade-rehearsal.yml b/.github/workflows/testermint-upgrade-rehearsal.yml
new file mode 100644
index 0000000000..078711a0cd
--- /dev/null
+++ b/.github/workflows/testermint-upgrade-rehearsal.yml
@@ -0,0 +1,279 @@
+name: Testermint Upgrade Rehearsal
+
+on:
+  workflow_dispatch:
+    inputs:
+      candidate_ref:
+        description: 'Candidate ref to test. Defaults to the dispatch ref.'
+        required: false
+        type: string
+        default: ''
+      target_upgrade:
+        description: 'Target upgrade name, e.g. v0.2.14. Defaults to newest semantic UpgradeName.'
+        required: false
+        type: string
+        default: ''
+      previous_release:
+        description: 'Previous canonical release, e.g. release/v0.2.13. Defaults to highest release below target.'
+        required: false
+        type: string
+        default: ''
+
+  push:
+    branches:
+      - upgrade-v*
+
+concurrency:
+  group: testermint-upgrade-rehearsal-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  packages: read
+  checks: write
+  actions: read
+
+jobs:
+  upgrade-rehearsal:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 240
+
+    env:
+      NEW_DIR: ${{ github.workspace }}/new
+      OLD_DIR: ${{ github.workspace }}/old
+      PREP_MANIFEST: ${{ github.workspace }}/upgrade-rehearsal-manifest.json
+      COMPLETE_MANIFEST: ${{ github.workspace }}/upgrade-rehearsal-completion-manifest.json
+
+    steps:
+      - name: Check initial disk space
+        run: df -h
+
+      - name: Free up runner disk space
+        timeout-minutes: 8
+        run: |
+          set -euo pipefail
+          for path in /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL; do
+            if [[ -e "$path" ]]; then
+              echo "Removing $path"
+              timeout 150s sudo rm -rf "$path" || echo "Timed out removing $path; continuing"
+              df -h
+            fi
+          done
+          timeout 120s sudo docker system prune -af --volumes || echo "Docker prune timed out; continuing"
+          sudo apt-get clean
+          df -h
+
+      - name: Checkout candidate
+        uses: actions/checkout@v4
+        with:
+          path: new
+          fetch-depth: 0
+          ref: ${{ inputs.candidate_ref || github.ref }}
+
+      - name: Fetch candidate tags
+        working-directory: new
+        run: git fetch --tags --force
+
+      - name: Resolve rehearsal versions
+        id: versions
+        working-directory: new
+        run: |
+          python3 scripts/upgrade-rehearsal/resolve_versions.py \
+            --repo . \
+            --target-upgrade '${{ inputs.target_upgrade }}' \
+            --previous-release '${{ inputs.previous_release }}'
+
+      - name: Checkout previous release
+        uses: actions/checkout@v4
+        with:
+          path: old
+          fetch-depth: 0
+          ref: ${{ steps.versions.outputs.previous_release }}
+
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v4
+        with:
+          version: '28.5.2'
+
+      - name: Verify Docker
+        run: |
+          docker --version
+          docker compose version
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install system packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y make zip unzip jq
+
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '21'
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: false
+
+      - name: Resolve previous production images
+        id: images
+        working-directory: old
+        run: python3 ../new/scripts/upgrade-rehearsal/resolve_previous_images.py --compose deploy/join/docker-compose.yml
+
+      - name: Pull and retag previous images for local Testermint
+        working-directory: ${{ github.workspace }}
+        env:
+          PREVIOUS_NODE_IMAGE: ${{ steps.images.outputs.node_image }}
+          PREVIOUS_API_IMAGE: ${{ steps.images.outputs.api_image }}
+          PREVIOUS_PROXY_IMAGE: ${{ steps.images.outputs.proxy_image }}
+          PREVIOUS_VERSIOND_IMAGE: ${{ steps.images.outputs.versiond_image }}
+          TARGET_NODE_IMAGE: ${{ steps.images.outputs.node_target_image }}
+          TARGET_API_IMAGE: ${{ steps.images.outputs.api_target_image }}
+          TARGET_PROXY_IMAGE: ${{ steps.images.outputs.proxy_target_image }}
+          TARGET_VERSIOND_IMAGE: ${{ steps.images.outputs.versiond_target_image }}
+        run: ./new/scripts/upgrade-rehearsal/prepare_previous_images.sh
+
+      - name: Build previous mock-server image
+        working-directory: old
+        run: make mock-server-build-docker
+
+      - name: Apply old-checkout prep test patch
+        working-directory: old
+        run: git apply ../new/testermint/upgrade-rehearsal/previous-release-prep.patch
+
+      - name: Run old-checkout prep test
+        timeout-minutes: 75
+        working-directory: old/testermint
+        env:
+          GONKA_REPO_ROOT: ${{ env.OLD_DIR }}
+          PREVIOUS_RELEASE: ${{ steps.versions.outputs.previous_release }}
+          UPGRADE_REHEARSAL_MANIFEST: ${{ env.PREP_MANIFEST }}
+        run: |
+          sudo -E ./gradlew test \
+            --tests "UpgradeRehearsalPrepTests.prepare upgrade rehearsal state" \
+            -x mock_server:test \
+            --stacktrace
+
+      - name: Build candidate upgrade archives
+        timeout-minutes: 90
+        working-directory: new
+        env:
+          # The default GitHub runner Docker driver cannot export registry
+          # caches. Keep this deterministic over fast; the rehearsal is already
+          # expensive and cache writes are not part of what it proves.
+          USE_REGISTRY_CACHE: '0'
+          VERSION: ${{ steps.versions.outputs.target_upgrade }}
+        run: |
+          make build-for-upgrade
+          sudo chown -R "$USER:$USER" public-html || true
+          find public-html -maxdepth 4 -type f -print
+
+      - name: Serve candidate upgrade archives on chain-public
+        working-directory: ${{ github.workspace }}
+        run: |
+          docker rm -f upgrade-binary-server || true
+          docker run -d \
+            --name upgrade-binary-server \
+            --network chain-public \
+            -v "${NEW_DIR}/public-html:/usr/local/apache2/htdocs:ro" \
+            httpd:2.4
+          docker run --rm --network chain-public curlimages/curl:8.11.1 \
+            -fsS http://upgrade-binary-server/v2/inferenced/inferenced-amd64.zip >/dev/null
+          docker run --rm --network chain-public curlimages/curl:8.11.1 \
+            -fsS http://upgrade-binary-server/v2/dapi/decentralized-api-amd64.zip >/dev/null
+
+      - name: Run current-checkout upgrade completion test
+        working-directory: new/testermint
+        env:
+          GONKA_REPO_ROOT: ${{ env.NEW_DIR }}
+          UPGRADE_REHEARSAL_TARGET: ${{ steps.versions.outputs.target_upgrade }}
+          UPGRADE_REHEARSAL_MANIFEST: ${{ env.PREP_MANIFEST }}
+          UPGRADE_REHEARSAL_COMPLETE_MANIFEST: ${{ env.COMPLETE_MANIFEST }}
+          UPGRADE_BINARY_BASE_URL: http://upgrade-binary-server
+        run: |
+          sudo -E ./gradlew test \
+            --tests "UpgradeRehearsalTests.complete upgrade rehearsal" \
+            -x mock_server:test \
+            --stacktrace
+
+      - name: Capture Docker state
+        if: always()
+        working-directory: ${{ github.workspace }}
+        run: |
+          mkdir -p upgrade-rehearsal-diagnostics
+          docker ps -a > upgrade-rehearsal-diagnostics/docker-ps.txt
+          docker images > upgrade-rehearsal-diagnostics/docker-images.txt
+          for container in genesis-node genesis-api join1-node join1-api join2-node join2-api upgrade-binary-server; do
+            docker logs "$container" --tail 300 > "upgrade-rehearsal-diagnostics/${container}.log" 2>&1 || true
+          done
+
+      - name: Upload rehearsal artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: testermint-upgrade-rehearsal-artifacts
+          if-no-files-found: ignore
+          retention-days: 14
+          path: |
+            upgrade-rehearsal-manifest.json
+            upgrade-rehearsal-completion-manifest.json
+            upgrade-rehearsal-diagnostics/
+            old/testermint/logs/
+            old/testermint/build/test-results/**/*.xml
+            new/testermint/logs/
+            new/testermint/build/test-results/**/*.xml
+
+      - name: Publish old prep test results
+        if: always()
+        uses: dorny/test-reporter@v1
+        continue-on-error: true
+        with:
+          name: Upgrade Rehearsal Prep
+          path: old/testermint/build/test-results/**/*.xml
+          reporter: java-junit
+          fail-on-error: false
+
+      - name: Publish completion test results
+        if: always()
+        uses: dorny/test-reporter@v1
+        continue-on-error: true
+        with:
+          name: Upgrade Rehearsal Completion
+          path: new/testermint/build/test-results/**/*.xml
+          reporter: java-junit
+          fail-on-error: false
+
+      - name: Write workflow summary
+        if: always()
+        run: |
+          {
+            echo "# Testermint Upgrade Rehearsal"
+            echo
+            echo "- Target upgrade: ${{ steps.versions.outputs.target_upgrade }}"
+            echo "- Previous release: ${{ steps.versions.outputs.previous_release }}"
+            echo "- Previous node image: ${{ steps.images.outputs.node_image }}"
+            echo "- Previous API image: ${{ steps.images.outputs.api_image }}"
+            echo
+            if [[ -f "${PREP_MANIFEST}" ]]; then
+              echo "## Prep Manifest"
+              echo '```json'
+              cat "${PREP_MANIFEST}"
+              echo
+              echo '```'
+            fi
+            if [[ -f "${COMPLETE_MANIFEST}" ]]; then
+              echo "## Completion Manifest"
+              echo '```json'
+              cat "${COMPLETE_MANIFEST}"
+              echo
+              echo '```'
+            fi
+          } >> "$GITHUB_STEP_SUMMARY"
diff --git a/.gitignore b/.gitignore
index 390f675e41..f23925c779 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,4 +55,4 @@ actionlint
 inference-chain/proto/github.com/
 inference-chain/proto/api/
 inference-chain/proto/**/module/*.pb.go
-inference-chain/.docker-context
+/inference-chain/.docker-context/
diff --git a/Makefile b/Makefile
index 3fc53b4833..df32995e29 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,9 @@
-.PHONY: release decentralized-api-release inference-chain-release tmkms-release proxy-release proxy-ssl-release bridge-release versiond-release check-docker build-testermint run-blockchain-tests test-blockchain local-build api-local-build node-local-build api-test node-test mock-server-build-docker proxy-build-docker proxy-ssl-build-docker bridge-build-docker run-bls-tests devshardctl-build devshardd-build print-devshard-version print-devshard-protocol-version versiond-build-docker testapp-server-build-docker
+.PHONY: release decentralized-api-release inference-chain-release tmkms-release proxy-release proxy-ssl-release bridge-release versiond-release check-docker build-testermint run-blockchain-tests test-blockchain local-build api-local-build node-local-build api-test node-test mock-server-build-docker proxy-build-docker proxy-ssl-build-docker bridge-build-docker run-bls-tests devshardctl-build devshardd-build devshardd-release print-devshard-version print-devshard-protocol-version versiond-build-docker testapp-server-build-docker
+
+# For binary release: default linux/amd64 before local Docker defaults.
+DEVSHARDD_RELEASE_DOCKER_PLATFORM := $(if $(DOCKER_PLATFORM),$(DOCKER_PLATFORM),linux/amd64)
+DEVSHARDD_RELEASE_DOCKER_GOOS := $(if $(DOCKER_GOOS),$(DOCKER_GOOS),linux)
+DEVSHARDD_RELEASE_DOCKER_GOARCH := $(if $(DOCKER_GOARCH),$(DOCKER_GOARCH),$(if $(filter linux/arm64,$(DEVSHARDD_RELEASE_DOCKER_PLATFORM)),arm64,amd64))
 
 include scripts/blst-portable.mk
 
@@ -15,10 +20,15 @@ print-devshard-protocol-version:
 	@echo $(DEVSHARD_PROTOCOL_VERSION)
 TAG_NAME := "release/v$(VERSION)"
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
+PLATFORM ?= linux/amd64
+GOOS ?= linux
+GOARCH ?= amd64
+DEVSHARDD_RELEASE_DIR ?= build/devshardd-release
 ifeq ($(USE_REGISTRY_CACHE),1)
-_MOCK_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/mock-server:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/mock-server:buildcache,mode=min
+_MOCK_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/mock-server:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/mock-server:buildcache,mode=min
 _MOCK_BUILD_CMD := docker buildx build --load $(_MOCK_CACHE_ARGS)
-_DEVSHARDD_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/devshardd:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/devshardd:buildcache,mode=min
+_DEVSHARDD_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/devshardd:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/devshardd:buildcache,mode=min
 _DEVSHARDD_BUILD_CMD := docker buildx build --load $(_DEVSHARDD_CACHE_ARGS)
 else
 _MOCK_CACHE_ARGS :=
@@ -154,6 +164,29 @@ devshardd-build:
 	@echo "$(DEVSHARD_PROTOCOL_VERSION)" > build/devshard-protocol-version
 	@echo "Built build/devshardd ($$(file build/devshardd | grep -o 'statically linked\|dynamically linked'))"
 
+devshardd-release:
+	@$(MAKE) devshardd-build \
+		DEVSHARD_VERSION=$(DEVSHARD_VERSION) \
+		DEVSHARD_PROTOCOL_VERSION=$(DEVSHARD_PROTOCOL_VERSION) \
+		DOCKER_PLATFORM=$(DEVSHARDD_RELEASE_DOCKER_PLATFORM) \
+		DOCKER_GOOS=$(DEVSHARDD_RELEASE_DOCKER_GOOS) \
+		DOCKER_GOARCH=$(DEVSHARDD_RELEASE_DOCKER_GOARCH)
+	@set -e; \
+		release_dir="$(DEVSHARDD_RELEASE_DIR)"; \
+		if [ -z "$$release_dir" ] || [ "$$release_dir" = "/" ]; then \
+			echo "Refusing to clean unsafe DEVSHARDD_RELEASE_DIR='$$release_dir'"; \
+			exit 1; \
+		fi; \
+		rm -rf "$$release_dir"; \
+		mkdir -p "$$release_dir/stage"; \
+		cp build/devshardd "$$release_dir/stage/devshardd"; \
+		chmod 0755 "$$release_dir/stage/devshardd"; \
+		(cd "$$release_dir/stage" && zip -X -q ../devshardd.zip devshardd); \
+		rm -rf "$$release_dir/stage"; \
+		shasum -a 256 "$$release_dir/devshardd.zip" | awk '{print $$1}' > "$$release_dir/devshardd.zip.sha256"; \
+		echo "Built $$release_dir/devshardd.zip"; \
+		echo "SHA256: $$(cat "$$release_dir/devshardd.zip.sha256")"
+
 node-local-build:
 	@echo "Building inference-chain locally..."
 	@make -C inference-chain build
@@ -215,11 +248,15 @@ local-build: api-local-build node-local-build api-test node-test
 	@rm -f api-test-output.log node-test-output.log
 
 build-for-upgrade:
-	@rm public-html/v2/checksums.txt || true
-	@rm public-html/v2/urls.txt || true
-	@make -C inference-chain build-for-upgrade
-	@make -C decentralized-api build-for-upgrade
+	@rm -f public-html/v2/checksums.txt public-html/v2/urls.txt
+	@mkdir -p public-html/v2/inferenced public-html/v2/dapi
+	@rm -f public-html/v2/inferenced/inferenced-*.zip public-html/v2/dapi/decentralized-api-*.zip
+	@make -C inference-chain build-for-upgrade PLATFORM=linux/amd64 GOOS=linux GOARCH=amd64
+	@make -C decentralized-api build-for-upgrade PLATFORM=linux/amd64 GOOS=linux GOARCH=amd64
 
 build-for-upgrade-tests:
-	@make -C inference-chain build-for-upgrade TESTS=1
-	@make -C decentralized-api build-for-upgrade TESTS=1
+	@rm -f public-html/v2/checksums.txt public-html/v2/urls.txt
+	@mkdir -p public-html/v2/inferenced public-html/v2/dapi
+	@rm -f public-html/v2/inferenced/inferenced-*.zip public-html/v2/dapi/decentralized-api-*.zip
+	@make -C inference-chain build-for-upgrade TESTS=1 PLATFORM=linux/amd64 GOOS=linux GOARCH=amd64
+	@make -C decentralized-api build-for-upgrade TESTS=1 PLATFORM=linux/amd64 GOOS=linux GOARCH=amd64
diff --git a/README.md b/README.md
index fc982a0a5b..cffbc3ba0e 100644
--- a/README.md
+++ b/README.md
@@ -26,20 +26,20 @@ We introduce a novel consensus mechanism, **Proof of Work 2.0**, that ensures ne
 For a deeper technical and conceptual explanation, check out [the White Paper](https://gonka.ai/whitepaper.pdf).
 ## Getting started
 
-For the most up-to-date documentation, please visit [https://gonka.ai/introduction/](https://gonka.ai/introduction/).
+For the most up-to-date documentation, please visit [https://gonka.ai/docs/introduction/](https://gonka.ai/docs/introduction/).
 
 To join Testnet:
-- **As Developer**: Explore the [Quickstart Guide](https://gonka.ai/developer/quickstart/) to understand how to create a user account and submit an inference request using the `inferenced` CLI tool.
+- **As Developer**: Explore the [Quickstart Guide](https://gonka.ai/docs/developer/quickstart/) to send your first inference request. The fastest way to start is through a **community broker** — a third party that runs a Gonka gateway and exposes a standard OpenAI-compatible API, so you just plug in a `base_url` and an API key. If you need to pay GNK directly on-chain instead of going through a broker, you can [run your own gateway](https://gonka.ai/docs/developer/gateway-developer-quickstart/) (advanced; requires an allow-listed address).
 - **As Host (Hardware Provider or Node)**:
-    - Review the [Hardware Specifications](https://gonka.ai/participant/hardware-specifications/) to ensure your equipment meets the requirements.
-    - Follow the [Participant Quickstart Guide](https://gonka.ai/participant/quickstart/) to set up your node and start contributing computational resources.
+    - Review the [Hardware Specifications](https://gonka.ai/docs/host/hardware-specifications/) to ensure your equipment meets the requirements.
+    - Follow the [Host Quickstart Guide](https://gonka.ai/docs/host/quickstart/) to set up your node and start contributing computational resources.
 ### Local Quickstart
 
 This section walks you through setting up a local development environment to build and test the core components, without joining the real network or running a full MLNode.
 #### 1. Environment setup
 Make sure you have the following installed:
 1. Git CLI
-2. Go 1.22.8
+2. Go 1.24.2
 3. Docker Desktop (4.37+)
 4. Make
 5. Java 19+
@@ -48,8 +48,8 @@ Make sure you have the following installed:
 #### 2. Build the project
 Clone the repository:
 ```
-git clone https://github.com/gonka-ai/gonka.git
-cd gonka (or repo name)**
+git clone https://github.com/gonka-ai/gonka.git -b main
+cd gonka
 ```
 
 Build chain and API nodes, and run unit tests:
@@ -63,7 +63,7 @@ This command will build locally, deploy a small network of Docker containers, an
 ```
 make run-tests
 ```
-There’s also an option to just run a Docker local chain, without running the tests, use `launch-local-test-chain-w-reset.sh` script for that. The script will spin up a miniature local chain consisting of 3 participants.
+There’s also an option to just run a Docker local chain, without running the tests, use the [`local-test-net/launch.sh`](https://github.com/gonka-ai/gonka/blob/main/local-test-net/launch.sh) script for that. The script will spin up a miniature local chain consisting of 3 participants (1 genesis node plus 2 joining nodes).
 
 To run Go unit tests for `chain` node (`inference-chain`)  and `api` node (`decentralized-api`) use `node-test` and `api-test` make targets.
 ## Architectural overview
@@ -97,7 +97,7 @@ The repository is organized as follows:
 /dev_notes          # Chain developer knowledge base
 /docs               # Documentation on specific aspects of the chain
 /inference-chain    # Chain node
-/prepare-local      # Scripts and configs for running local chain
+/local-test-net     # Scripts and configs for running a local chain
 /testermint         # Integration tests suite
 ```
 ## Testing
@@ -116,8 +116,7 @@ The system is designed around **containerized microservices**. Each component ru
 
 We maintain deployment examples and tooling in the [https://github.com/gonka-ai/gonka/](https://github.com/gonka-ai/gonka/).
 ## Model licenses
-[https://gonka.ai/model-licenses/](https://gonka.ai/model-licenses/)
+[https://gonka.ai/docs/model-licenses/](https://gonka.ai/docs/model-licenses/)
 ## Support
 
-- Reach us at hello@productscience.ai.
-- [Discord](https://discord.com/invite/RADwCT2U6R) – Join for real-time discussions, updates, and support.
+Join the [Gonka community on Discord](https://discord.com/invite/RADwCT2U6R) if you need assistance.
diff --git a/bridge/Dockerfile b/bridge/Dockerfile
index 0ea23ee3fa..8f87973f6e 100644
--- a/bridge/Dockerfile
+++ b/bridge/Dockerfile
@@ -1,5 +1,5 @@
 # Extract Geth binary from prebuilt container
-FROM ghcr.io/product-science/bridge-geth:0.2.12@sha256:57f8e07499b4798337e1a224741657aa7b06dd2669e5411854731139bb2a072c AS geth-source
+FROM ghcr.io/product-science/bridge-geth:0.2.14@sha256:510ef35303ea7c2d400e7647d64d7031380b4b131a92fcbac40e707ad40b5da3 AS geth-source
 
 # Extract Prysm binaries from prebuilt container  
 FROM ghcr.io/product-science/bridge-prysm:0.2.12@sha256:bdace2b516a5c502aa2e5575433f3c35986002ea3bc18e5cb54a307bf4aafa7a AS prysm-source
diff --git a/bridge/Makefile b/bridge/Makefile
index 28b7d986df..d4dca46ba9 100644
--- a/bridge/Makefile
+++ b/bridge/Makefile
@@ -6,8 +6,9 @@ VERSION ?= $(shell git describe --always)
 SET_LATEST ?= 0
 SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
 ifeq ($(USE_REGISTRY_CACHE),1)
-DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/bridge:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/bridge:buildcache,mode=min
+DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/bridge:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/bridge:buildcache,mode=min
 DOCKER_BUILD_PREFIX := docker buildx build --load $(DOCKER_CACHE_ARGS)
 else
 DOCKER_CACHE_ARGS :=
diff --git a/bridge/script.sh b/bridge/script.sh
index 184b222596..5e1186044b 100644
--- a/bridge/script.sh
+++ b/bridge/script.sh
@@ -12,6 +12,23 @@ GETH_DISCOVERY_PORT=${GETH_DISCOVERY_PORT:-$GETH_P2P_PORT}
 PRYSM_P2P_TCP_PORT=${PRYSM_P2P_TCP_PORT:-13000}
 PRYSM_P2P_UDP_PORT=${PRYSM_P2P_UDP_PORT:-12000}
 
+# Bridge continuity settings.
+# Default endpoints and beacon URL to local production API service if unset.
+BRIDGE_POSTBLOCK=${BRIDGE_POSTBLOCK:-http://api:9200/admin/v1/bridge/block}
+BRIDGE_GETADDRESSES=${BRIDGE_GETADDRESSES:-http://api:9000/v1/bridge/addresses}
+BRIDGE_GETLASTBLOCK=${BRIDGE_GETLASTBLOCK:-http://api:9000/v1/bridge/block/latest}
+BEACON_STATE_URL=${BEACON_STATE_URL:-https://beaconstate.info/}
+
+BRIDGE_CACHE_RANGES=${BRIDGE_CACHE_RANGES:-4}
+
+# Build the optional --bridge.getlastblock flag only when the URL is set, so an empty
+# value is never passed as a bare flag. URLs contain no spaces, so word-splitting the
+# unquoted variable into the geth invocation is safe.
+BRIDGE_GETLASTBLOCK_FLAG=""
+if [ -n "$BRIDGE_GETLASTBLOCK" ]; then
+    BRIDGE_GETLASTBLOCK_FLAG="--bridge.getlastblock $BRIDGE_GETLASTBLOCK"
+fi
+
 require_env_vars() {
     missing=false
     for var_name in "$@"; do
@@ -43,14 +60,19 @@ PRYSM_FORMATTED_LOG=/var/log/prysm/beacon.log
 
 # Determine network flags
 NETWORK_FLAGS=""
+CHAIN_ID="ethereum"
 if [ "$ETHEREUM_NETWORK" = "sepolia" ] || [ "$ETHEREUM_NETWORK" = "testnet" ]; then
     echo "Running on Sepolia testnet"
     NETWORK_FLAGS="--sepolia"
+    CHAIN_ID="sepolia"
 else
     echo "Running on Mainnet (default)"
     # Geth defaults to mainnet, no flag needed
 fi
 
+# Watchdog timer variables
+ZERO_PEERS_START_TIME=0
+
 echo "Initializing Ethereum Bridge Service Version 0.1.0"
 
 # Generate JWT secret if it doesn't exist
@@ -188,6 +210,9 @@ start_geth() {
           --ipcdisable \
          --bridge.postblock $BRIDGE_POSTBLOCK \
          --bridge.getaddresses $BRIDGE_GETADDRESSES \
+         --bridge.chain "$CHAIN_ID" \
+         $BRIDGE_GETLASTBLOCK_FLAG \
+         --bridge.cacheranges "$BRIDGE_CACHE_RANGES" \
          --authrpc.addr 127.0.0.1 \
          --authrpc.port $GETH_AUTHRPC_PORT \
          --authrpc.jwtsecret $JWT_SECRET_PATH \
@@ -215,6 +240,9 @@ start_geth() {
                  --ipcdisable \
                  --bridge.postblock $BRIDGE_POSTBLOCK \
                  --bridge.getaddresses $BRIDGE_GETADDRESSES \
+                 --bridge.chain "$CHAIN_ID" \
+                 $BRIDGE_GETLASTBLOCK_FLAG \
+                 --bridge.cacheranges "$BRIDGE_CACHE_RANGES" \
                  --authrpc.addr 127.0.0.1 \
                  --authrpc.port $GETH_AUTHRPC_PORT \
                  --authrpc.jwtsecret $JWT_SECRET_PATH \
@@ -312,6 +340,25 @@ restart_processes() {
     fi
 }
 
+# Function to query geth peer count via JSON-RPC
+get_geth_peer_count() {
+    local resp
+    resp=$(curl -s -m 5 -X POST -H "Content-Type: application/json" \
+        -d '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":1}' \
+        "http://127.0.0.1:$GETH_HTTP_PORT" 2>/dev/null)
+    if [ $? -ne 0 ] || [ -z "$resp" ]; then
+        echo "-1"
+        return
+    fi
+    local hex_val
+    hex_val=$(echo "$resp" | grep -o '"result":"[^"]*"' | cut -d'"' -f4)
+    if [ -z "$hex_val" ]; then
+        echo "-1"
+        return
+    fi
+    printf "%d" "$hex_val" 2>/dev/null || echo "-1"
+}
+
 # Function to check if processes are still running and restart if needed
 check_and_restart_processes() {
     local restart_needed=false
@@ -352,6 +399,39 @@ check_and_restart_processes() {
     if [ "$restart_needed" = "true" ]; then
         echo "Restarting processes due to crash..."
         restart_processes
+        return
+    fi
+
+    # Peer count watchdog check (Mainnet only)
+    if [ "$ETHEREUM_NETWORK" != "sepolia" ] && [ "$ETHEREUM_NETWORK" != "testnet" ]; then
+        if [ -n "$GETH_PID" ] && kill -0 "$GETH_PID" 2>/dev/null; then
+            local peers
+            peers=$(get_geth_peer_count)
+            if [ "$peers" = "0" ]; then
+                if [ "$ZERO_PEERS_START_TIME" -eq 0 ]; then
+                    ZERO_PEERS_START_TIME=$(date +%s)
+                    echo "Geth peer count is zero. Starting watchdog timer..."
+                else
+                    local now
+                    now=$(date +%s)
+                    local elapsed=$((now - ZERO_PEERS_START_TIME))
+                    if [ $elapsed -ge 3600 ]; then
+                        echo "Geth has had zero peers for $elapsed seconds (>= 1 hour). Triggering watchdog restart..."
+                        ZERO_PEERS_START_TIME=0
+                        restart_processes
+                    fi
+                fi
+            else
+                if [ "$ZERO_PEERS_START_TIME" -ne 0 ]; then
+                    echo "Geth peer count recovered to $peers. Resetting watchdog timer."
+                    ZERO_PEERS_START_TIME=0
+                fi
+            fi
+        else
+            ZERO_PEERS_START_TIME=0
+        fi
+    else
+        ZERO_PEERS_START_TIME=0
     fi
 }
 
diff --git a/decentralized-api/Dockerfile b/decentralized-api/Dockerfile
index f5d53496dc..fced065aa4 100644
--- a/decentralized-api/Dockerfile
+++ b/decentralized-api/Dockerfile
@@ -3,7 +3,7 @@
 ################################################################################
 # Build the application
 ################################################################################
-FROM golang:1.24.2-alpine3.20 AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 
 ARG GOOS
 ARG GOARCH
@@ -96,14 +96,14 @@ FROM scratch AS binary-exporter
 # Copy all required files to a flat structure
 COPY --from=builder /app/decentralized-api/build/dapi /build_output/decentralized-api
 COPY --from=builder /app/inference-chain/build/inferenced /build_output/inferenced
-COPY --from=builder /lib/libwasmvm_muslc.x86_64.a /build_output/libwasmvm_muslc.x86_64.a
+COPY --from=builder /lib/libwasmvm_muslc.*.a /build_output/
 COPY --from=builder /usr/lib/libgcc_s.so.1 /build_output/libgcc_s.so.1
 
 ################################################################################
 # Final image
 ################################################################################
 ARG TARGETPLATFORM
-FROM --platform=$TARGETPLATFORM alpine:3.18 AS final
+FROM --platform=$TARGETPLATFORM alpine:3.21 AS final
 
 ARG GOOS
 ARG GOARCH
diff --git a/decentralized-api/Makefile b/decentralized-api/Makefile
index 7cc4c43cab..baa70c2da3 100644
--- a/decentralized-api/Makefile
+++ b/decentralized-api/Makefile
@@ -9,6 +9,9 @@ VERSION ?= $(shell git describe --always)
 DEVSHARD_VERSION ?= $(VERSION)
 SET_LATEST ?= 0
 SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
+PLATFORM ?= linux/amd64
+GOOS ?= linux
+GOARCH ?= amd64
 
 ldflags = -X github.com/cosmos/cosmos-sdk/version.Name=decentralized-api \
 	-X github.com/cosmos/cosmos-sdk/version.AppName=decentralized-api \
@@ -20,9 +23,10 @@ BUILD_FLAGS ?= -ldflags '$(ldflags)'
 WASMVM_STATIC_LINUX_X64_URL := https://github.com/CosmWasm/wasmvm/releases/download/v2.2.4/libwasmvm_muslc.x86_64.a
 
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
 ifeq ($(USE_REGISTRY_CACHE),1)
-DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/api:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/api:buildcache,mode=min
-DOCKER_CACHE_ARGS_UPGRADE := --cache-from type=registry,ref=ghcr.io/gonka-ai/api:buildcache-upgrade --cache-to type=registry,ref=ghcr.io/gonka-ai/api:buildcache-upgrade,mode=min
+DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/api:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/api:buildcache,mode=min
+DOCKER_CACHE_ARGS_UPGRADE := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/api:buildcache-upgrade --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/api:buildcache-upgrade,mode=min
 DOCKER_BUILD_PREFIX := docker buildx build --load $(DOCKER_CACHE_ARGS)
 DOCKER_BUILD_UPGRADE_PREFIX := docker buildx build $(DOCKER_CACHE_ARGS_UPGRADE)
 else
@@ -115,30 +119,26 @@ docker-push:
 	fi
 
 build-for-upgrade:
-	$(eval PLATFORM=linux/amd64)
-	$(eval GOOS=linux)
-	$(eval GOARCH=amd64)
 	$(eval DOCKER_FILE=Dockerfile)
 	$(DOCKER_BUILD_UPGRADE)
-	@echo "--> clearing out ../public-html/v2/dapi"
-	@rm -rf ../public-html/v2/dapi/*
+	@echo "--> staging decentralized-api binary and dependencies for $(GOARCH)"
 	@mkdir -p ../public-html/v2/dapi
-	@echo "--> copying built decentralized-api binary and dependencies to ../public-html/v2/dapi/"
-	@cp ./output/build_output/* ../public-html/v2/dapi/
-	@echo "--> cleaning up intermediate build output"
-	@rm -rf ./output
-	@echo "--> zipping decentralized-api binary with dependencies"
+	@rm -rf ./output/upgrade-package-$(GOARCH)
+	@mkdir -p ./output/upgrade-package-$(GOARCH)
+	@cp ./output/build_output/* ./output/upgrade-package-$(GOARCH)/
+	@echo "--> zipping decentralized-api binary with dependencies for $(GOARCH)"
 	# We set the timestamp to a const and strip metadata in zip so we have a reproduceable checksum
-	@TZ=UTC find ../public-html/v2/dapi -type f -exec touch -t 200001010000 {} \;
-	@cd ../public-html/v2/dapi && zip -X -r decentralized-api-amd64.zip .
-	@echo "--> generating shasum for decentralized-api-amd64.zip"
-	@shasum -a 256 ../public-html/v2/dapi/decentralized-api-amd64.zip
+	@TZ=UTC find ./output/upgrade-package-$(GOARCH) -type f -exec touch -t 200001010000 {} \;
+	@archive_path="$$(pwd)/../public-html/v2/dapi/decentralized-api-$(GOARCH).zip"; \
+		rm -f "$$archive_path"; \
+		cd ./output/upgrade-package-$(GOARCH) && zip -X -r "$$archive_path" .
+	@echo "--> generating shasum for decentralized-api-$(GOARCH).zip"
+	@shasum -a 256 ../public-html/v2/dapi/decentralized-api-$(GOARCH).zip
 	@echo "--> appending to ../public-html/v2/checksums.txt"
-	@echo "decentralized-api-amd64.zip $(shasum -a 256 ../public-html/v2/dapi/decentralized-api-amd64.zip)" >> ../public-html/v2/checksums.txt
-
-	# Disabled ARM builds as requested
-build-for-upgrade-arm:
-	@echo "ARM builds disabled"
+	@checksum=$$(shasum -a 256 ../public-html/v2/dapi/decentralized-api-$(GOARCH).zip | awk '{print $$1}'); \
+		echo "decentralized-api-$(GOARCH).zip $$checksum" >> ../public-html/v2/checksums.txt
+	@echo "--> cleaning up intermediate build output"
+	@rm -rf ./output
 
 download-linux-deps:
 	@echo "--> Downloading static wasmvm library for Linux (x86_64)..."
diff --git a/decentralized-api/apiconfig/config.go b/decentralized-api/apiconfig/config.go
index c928b15dd5..05ebe77b13 100644
--- a/decentralized-api/apiconfig/config.go
+++ b/decentralized-api/apiconfig/config.go
@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	"decentralized-api/poc/earlyshare"
+
 	"github.com/productscience/inference/x/inference/types"
 )
 
@@ -28,6 +30,7 @@ type Config struct {
 	PoCParams                PoCParamsCache           `koanf:"poc_params" json:"poc_params"`
 	TransferAgentAccessCache TransferAgentAccessCache `koanf:"-" json:"-"` // not persisted, synced from chain
 	DevshardVersionsCache    DevshardVersionsCache    `koanf:"-" json:"-"` // not persisted, synced from chain
+	EarlyShareGuard          EarlyShareGuardConfig    `koanf:"early_share_guard" json:"early_share_guard"`
 }
 
 type NatsServerConfig struct {
@@ -252,21 +255,21 @@ func (p PoCParamsCache) GetModelConfig(modelID string) (PoCModelConfigCache, boo
 type DevshardVersionsCache struct {
 	// Versions are approved devshard binaries (`name`, download URL, sha256)
 	// used by versiond/routing policy.
-	Versions                          []DevshardVersion `json:"versions"`
+	Versions []DevshardVersion `json:"versions"`
 	// DevshardRequestsEnabled is the live governance kill-switch for host-side
 	// completion/timeout request handling.
-	DevshardRequestsEnabled bool              `json:"devshard_requests_enabled"`
+	DevshardRequestsEnabled bool `json:"devshard_requests_enabled"`
 	// MaxNonce is the chain upper bound for session nonces.
-	MaxNonce                          uint32            `json:"max_nonce"`
+	MaxNonce uint32 `json:"max_nonce"`
 	// RefusalTimeout is the live refusal timeout used by runtime-config consumers (seconds).
-	RefusalTimeout                    int64             `json:"refusal_timeout"`
+	RefusalTimeout int64 `json:"refusal_timeout"`
 	// ExecutionTimeout is the live execution timeout used by runtime-config consumers (seconds).
-	ExecutionTimeout                  int64             `json:"execution_timeout"`
+	ExecutionTimeout int64 `json:"execution_timeout"`
 	// ValidationRate is the validation sampling rate in basis points (0..10000).
-	ValidationRate                    uint32            `json:"validation_rate"`
+	ValidationRate uint32 `json:"validation_rate"`
 	// VoteThresholdFactor is the vote threshold factor in percent (1..100),
 	// converted to slot threshold at bind time.
-	VoteThresholdFactor               uint32            `json:"vote_threshold_factor"`
+	VoteThresholdFactor uint32 `json:"vote_threshold_factor"`
 }
 
 // DevshardVersion describes a single approved devshard binary.
@@ -281,3 +284,42 @@ type TransferAgentAccessCache struct {
 	AllowedAddresses map[string]struct{} // O(1) lookup
 	IsEnabled        bool                // true if whitelist is non-empty
 }
+
+// EarlyShareGuardConfig configures the DAPI-only early PoC share guard. It
+// runs in enforce mode by default (set mode to "observe" or "disabled" to opt
+// out); see proposals/poc/early-share-guard-dapi.md. The guard
+// captures early on-chain PoC v2 commitments near the first fraction of the
+// generation window and compares them to final commitments during validation.
+type EarlyShareGuardConfig struct {
+	// Mode is one of "disabled", "observe", or "enforce". Empty means disabled.
+	Mode string `koanf:"mode" json:"mode"`
+	// FirstFraction is the fraction of the generation window at which the early
+	// checkpoint is captured (default 1/3). Must be in (0,1).
+	FirstFraction float64 `koanf:"first_fraction" json:"first_fraction"`
+	// ThresholdRatio multiplies the weighted-median early share to derive the
+	// per-stage pass threshold (default 0.5).
+	ThresholdRatio float64 `koanf:"threshold_ratio" json:"threshold_ratio"`
+	// RequireInclusionProof enables the early-vs-final nonce inclusion check.
+	// Defaults to true (set during config load via key existence); set
+	// require_inclusion_proof=false explicitly to disable.
+	RequireInclusionProof bool `koanf:"require_inclusion_proof" json:"require_inclusion_proof"`
+	// InclusionSampleSize is the number of early leaves checked for final-tree
+	// inclusion. It is clamped by the earlyshare package.
+	InclusionSampleSize int `koanf:"inclusion_sample_size" json:"inclusion_sample_size"`
+}
+
+// DefaultEarlyShareGuardConfig returns the guard defaults. It is used to
+// pre-seed the config before koanf unmarshalling so that any field absent from
+// yaml/env keeps its default, while explicitly-set values (including
+// require_inclusion_proof=false) override. Defaults live once in the earlyshare
+// package to keep a single source of truth.
+func DefaultEarlyShareGuardConfig() EarlyShareGuardConfig {
+	d := earlyshare.DefaultConfig()
+	return EarlyShareGuardConfig{
+		Mode:                  string(d.Mode),
+		FirstFraction:         d.FirstFraction,
+		ThresholdRatio:        d.ThresholdRatio,
+		RequireInclusionProof: d.RequireInclusionProof,
+		InclusionSampleSize:   d.InclusionSampleSize,
+	}
+}
diff --git a/decentralized-api/apiconfig/config_manager.go b/decentralized-api/apiconfig/config_manager.go
index 9fb967f192..1df5a61c7c 100644
--- a/decentralized-api/apiconfig/config_manager.go
+++ b/decentralized-api/apiconfig/config_manager.go
@@ -143,6 +143,12 @@ func (cm *ConfigManager) GetChainNodeConfig() ChainNodeConfig {
 	return cm.currentConfig.ChainNode
 }
 
+func (cm *ConfigManager) GetEarlyShareGuardConfig() EarlyShareGuardConfig {
+	cm.mutex.Lock()
+	defer cm.mutex.Unlock()
+	return cm.currentConfig.EarlyShareGuard
+}
+
 func (cm *ConfigManager) GetApiConfig() ApiConfig {
 	cm.mutex.Lock()
 	defer cm.mutex.Unlock()
@@ -608,7 +614,11 @@ func readConfig(provider koanf.Provider) (Config, error) {
 	if err != nil {
 		log.Fatalf("error loading env: %v", err)
 	}
-	var config Config
+	// Pre-seed early-share guard defaults so any field absent from yaml/env keeps
+	// its default while explicitly-set values override. koanf unmarshals with
+	// ZeroFields=false, so only keys actually present overwrite these. This is
+	// the single defaulting mechanism for the guard (works for the bool too).
+	config := Config{EarlyShareGuard: DefaultEarlyShareGuardConfig()}
 	err = k.Unmarshal("", &config)
 	if err != nil {
 		log.Fatalf("error unmarshalling config: %v", err)
diff --git a/decentralized-api/apiconfig/config_test.go b/decentralized-api/apiconfig/config_test.go
index 2ee0a7455d..7a2f9d2b7d 100644
--- a/decentralized-api/apiconfig/config_test.go
+++ b/decentralized-api/apiconfig/config_test.go
@@ -29,6 +29,44 @@ func TestConfigLoad(t *testing.T) {
 	require.Equal(t, "/root/.inference", testManager.GetChainNodeConfig().KeyringDir)
 }
 
+func TestEarlyShareGuardDefaults(t *testing.T) {
+	t.Run("defaults applied when absent from yaml/env", func(t *testing.T) {
+		os.Unsetenv("DAPI_EARLY_SHARE_GUARD__MODE")
+		os.Unsetenv("DAPI_EARLY_SHARE_GUARD__REQUIRE_INCLUSION_PROOF")
+		os.Unsetenv("DAPI_EARLY_SHARE_GUARD__INCLUSION_SAMPLE_SIZE")
+		m := &apiconfig.ConfigManager{KoanProvider: rawbytes.Provider([]byte(testYaml))}
+		require.NoError(t, m.Load())
+
+		got := m.GetEarlyShareGuardConfig()
+		def := apiconfig.DefaultEarlyShareGuardConfig()
+		require.Equal(t, def.Mode, got.Mode)
+		require.Equal(t, def.FirstFraction, got.FirstFraction)
+		require.Equal(t, def.ThresholdRatio, got.ThresholdRatio)
+		require.True(t, got.RequireInclusionProof, "require_inclusion_proof should default to true")
+		require.Equal(t, def.InclusionSampleSize, got.InclusionSampleSize)
+	})
+
+	t.Run("explicit false overrides the true default", func(t *testing.T) {
+		os.Setenv("DAPI_EARLY_SHARE_GUARD__MODE", "enforce")
+		os.Setenv("DAPI_EARLY_SHARE_GUARD__REQUIRE_INCLUSION_PROOF", "false")
+		os.Setenv("DAPI_EARLY_SHARE_GUARD__INCLUSION_SAMPLE_SIZE", "7")
+		defer func() {
+			os.Unsetenv("DAPI_EARLY_SHARE_GUARD__MODE")
+			os.Unsetenv("DAPI_EARLY_SHARE_GUARD__REQUIRE_INCLUSION_PROOF")
+			os.Unsetenv("DAPI_EARLY_SHARE_GUARD__INCLUSION_SAMPLE_SIZE")
+		}()
+		m := &apiconfig.ConfigManager{KoanProvider: rawbytes.Provider([]byte(testYaml))}
+		require.NoError(t, m.Load())
+
+		got := m.GetEarlyShareGuardConfig()
+		require.Equal(t, "enforce", got.Mode)
+		require.False(t, got.RequireInclusionProof, "explicit false must win over default true")
+		require.Equal(t, 7, got.InclusionSampleSize)
+		// Untouched fields keep their defaults.
+		require.Equal(t, apiconfig.DefaultEarlyShareGuardConfig().FirstFraction, got.FirstFraction)
+	})
+}
+
 func TestNewPoCParamsCache(t *testing.T) {
 	cache := apiconfig.NewPoCParamsCache([]*types.PoCModelConfig{
 		nil,
diff --git a/decentralized-api/apiconfig/runtime_config_notifier_test.go b/decentralized-api/apiconfig/runtime_config_notifier_test.go
index e5ae2e627c..0cb04c9e7c 100644
--- a/decentralized-api/apiconfig/runtime_config_notifier_test.go
+++ b/decentralized-api/apiconfig/runtime_config_notifier_test.go
@@ -71,4 +71,3 @@ func TestRuntimeConfigNotifier_ConcurrentNotifyWait(t *testing.T) {
 		t.Fatal("deadlock in concurrent notify/wait")
 	}
 }
-
diff --git a/decentralized-api/apiconfig/sqlite_store.go b/decentralized-api/apiconfig/sqlite_store.go
index 892577329c..4a07f20ba7 100644
--- a/decentralized-api/apiconfig/sqlite_store.go
+++ b/decentralized-api/apiconfig/sqlite_store.go
@@ -116,11 +116,75 @@ CREATE TABLE IF NOT EXISTS bls_dealer_openings (
   created_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now')),
   PRIMARY KEY(epoch_id, recipient_index, ciphertext_index)
 );
-CREATE INDEX IF NOT EXISTS idx_bls_dealer_openings_epoch_id ON bls_dealer_openings(epoch_id);`
+CREATE INDEX IF NOT EXISTS idx_bls_dealer_openings_epoch_id ON bls_dealer_openings(epoch_id);
+
+CREATE TABLE IF NOT EXISTS bridge_state (
+  chain_id TEXT PRIMARY KEY,
+  latest_block INTEGER NOT NULL,
+  updated_at DATETIME NOT NULL DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f','now'))
+);`
 	_, err := db.ExecContext(ctx, stmt)
 	return err
 }
 
+// GetBridgeLatestBlock retrieves the latest successfully processed block number for a chain.
+// If the chain has no row yet, it returns (0, false, nil) to indicate an uninitialized chain.
+func GetBridgeLatestBlock(ctx context.Context, db *sql.DB, chain string) (uint64, bool, error) {
+	if db == nil {
+		return 0, false, errors.New("db is nil")
+	}
+	var latest uint64
+	err := db.QueryRowContext(ctx, "SELECT latest_block FROM bridge_state WHERE chain_id = ?", chain).Scan(&latest)
+	if err == sql.ErrNoRows {
+		return 0, false, nil
+	}
+	if err != nil {
+		return 0, false, err
+	}
+	return latest, true, nil
+}
+
+// SetBridgeLatestBlock upserts the latest processed block number for a chain.
+func SetBridgeLatestBlock(ctx context.Context, db *sql.DB, chain string, blockNum uint64) error {
+	if db == nil {
+		return errors.New("db is nil")
+	}
+	_, err := db.ExecContext(ctx, `
+INSERT INTO bridge_state (chain_id, latest_block, updated_at)
+VALUES (?, ?, STRFTIME('%Y-%m-%d %H:%M:%f','now'))
+ON CONFLICT(chain_id) DO UPDATE SET
+  latest_block = excluded.latest_block,
+  updated_at = STRFTIME('%Y-%m-%d %H:%M:%f','now')
+`, chain, blockNum)
+	return err
+}
+
+// LoadAllBridgeLatestBlocks retrieves the latest block numbers for all chains as a map.
+func LoadAllBridgeLatestBlocks(ctx context.Context, db *sql.DB) (map[string]uint64, error) {
+	if db == nil {
+		return nil, errors.New("db is nil")
+	}
+	rows, err := db.QueryContext(ctx, "SELECT chain_id, latest_block FROM bridge_state")
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	res := make(map[string]uint64)
+	for rows.Next() {
+		var chain string
+		var latest uint64
+		if err := rows.Scan(&chain, &latest); err != nil {
+			return nil, err
+		}
+		res[chain] = latest
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
 // UpsertInferenceNodes replaces or inserts the given nodes by id.
 func UpsertInferenceNodes(ctx context.Context, db *sql.DB, nodes []InferenceNodeConfig) error {
 	if len(nodes) == 0 {
diff --git a/decentralized-api/broker/broker.go b/decentralized-api/broker/broker.go
index d66eb47864..f591f567b1 100644
--- a/decentralized-api/broker/broker.go
+++ b/decentralized-api/broker/broker.go
@@ -218,6 +218,8 @@ type NodeState struct {
 	AdminState      AdminState `json:"admin_state"`
 	// Self-reported by the node. Informational only — do not use for authorization or capability gating.
 	MlNodeVersion string `json:"ml_node_version"`
+	// Self-reported by the node. Informational only - can serve inference while PoC validation runs inside vLLM.
+	PoCValidationInference bool `json:"poc_validation_inference"`
 
 	// Epoch data for this node, keyed by model_id.
 	// We currently expect one item in each map.
@@ -285,6 +287,14 @@ func (s *NodeState) ShouldContinueInference() bool {
 	return len(s.PreservedModels) > 0
 }
 
+// ServesInferenceDuringValidation reports whether a node can take inference while
+// running PoC validation: capable nodes run PoC v2 inside vLLM, so it stays up.
+func (s *NodeState) ServesInferenceDuringValidation() bool {
+	return s.PoCValidationInference &&
+		s.IntendedStatus == types.HardwareNodeStatus_POC &&
+		s.PocIntendedStatus == PocStatusValidating
+}
+
 func ShouldBeOperational(adminState AdminState, latestEpoch uint64, currentPhase types.EpochPhase) bool {
 	if adminState.Enabled {
 		if latestEpoch > adminState.Epoch {
@@ -508,12 +518,17 @@ func (b *Broker) getLeastBusyNode(command LockAvailableNode) *NodeWithState {
 type NodeNotAvailableReason = string
 
 func (b *Broker) nodeAvailable(node *NodeWithState, neededModel string, currentEpoch uint64, currentPhase types.EpochPhase) (bool, NodeNotAvailableReason) {
-	if node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE {
+	servesInferenceDuringValidation := node.State.ServesInferenceDuringValidation()
+	if servesInferenceDuringValidation {
+		logging.Info("nodeAvailable. Node can serve INFERENCE during PoC validation", types.Nodes, "nodeId", node.Node.Id, "intendedStatus", node.State.IntendedStatus, "PoCValidationInference", node.State.PoCValidationInference)
+	}
+
+	if node.State.IntendedStatus != types.HardwareNodeStatus_INFERENCE && !servesInferenceDuringValidation {
 		return false, fmt.Sprintf("Node is not intended for INFERENCE at the moment: %s", node.State.IntendedStatus)
 	}
 	logging.Info("nodeAvailable. Node is intended for INFERENCE", types.Nodes, "nodeId", node.Node.Id, "intendedStatus", node.State.IntendedStatus)
 
-	if node.State.CurrentStatus != types.HardwareNodeStatus_INFERENCE {
+	if node.State.CurrentStatus != types.HardwareNodeStatus_INFERENCE && !servesInferenceDuringValidation {
 		return false, fmt.Sprintf("Node is not in INFERENCE state: %s", node.State.CurrentStatus)
 	}
 	logging.Info("nodeAvailable. Node is in INFERENCE state", types.Nodes, "nodeId", node.Node.Id)
@@ -1331,13 +1346,15 @@ func nodeStatusQueryWorker(broker *Broker) {
 			}
 
 			if queryStatusResult.PrevStatus != queryStatusResult.CurrentStatus ||
-				nodeResp.State.MlNodeVersion != queryStatusResult.MlNodeVersion {
+				nodeResp.State.MlNodeVersion != queryStatusResult.MlNodeVersion ||
+				nodeResp.State.PoCValidationInference != queryStatusResult.PoCValidationInference {
 				statusUpdates = append(statusUpdates, StatusUpdate{
-					NodeId:        nodeResp.Node.Id,
-					PrevStatus:    queryStatusResult.PrevStatus,
-					NewStatus:     queryStatusResult.CurrentStatus,
-					Timestamp:     timestamp,
-					MlNodeVersion: queryStatusResult.MlNodeVersion,
+					NodeId:                 nodeResp.Node.Id,
+					PrevStatus:             queryStatusResult.PrevStatus,
+					NewStatus:              queryStatusResult.CurrentStatus,
+					Timestamp:              timestamp,
+					MlNodeVersion:          queryStatusResult.MlNodeVersion,
+					PoCValidationInference: queryStatusResult.PoCValidationInference,
 				})
 			}
 		}
@@ -1355,9 +1372,10 @@ func nodeStatusQueryWorker(broker *Broker) {
 }
 
 type statusQueryResult struct {
-	PrevStatus    types.HardwareNodeStatus
-	CurrentStatus types.HardwareNodeStatus
-	MlNodeVersion string
+	PrevStatus             types.HardwareNodeStatus
+	CurrentStatus          types.HardwareNodeStatus
+	MlNodeVersion          string
+	PoCValidationInference bool
 }
 
 // Pass by value, because this is supposed to be a readonly function
@@ -1372,6 +1390,7 @@ func (b *Broker) queryNodeStatus(node Node, state NodeState) (*statusQueryResult
 	prevStatus := state.CurrentStatus
 	var currentStatus types.HardwareNodeStatus
 	mlNodeVersion := state.MlNodeVersion
+	pocValidationInference := false
 	if err != nil {
 		logging.Error("queryNodeStatus. Failed to query node status. Assuming currentStatus = FAILED", types.Nodes,
 			"nodeId", nodeId, "error", err)
@@ -1379,6 +1398,7 @@ func (b *Broker) queryNodeStatus(node Node, state NodeState) (*statusQueryResult
 	} else {
 		currentStatus = toStatus(*status)
 		mlNodeVersion = status.Version
+		pocValidationInference = status.PoCValidationInference
 	}
 
 	logging.Info("queryNodeStatus. Queried node status", types.Nodes, "nodeId", nodeId, "currentStatus", currentStatus.String(), "prevStatus", prevStatus.String())
@@ -1422,9 +1442,10 @@ func (b *Broker) queryNodeStatus(node Node, state NodeState) (*statusQueryResult
 	}
 
 	return &statusQueryResult{
-		PrevStatus:    prevStatus,
-		CurrentStatus: currentStatus,
-		MlNodeVersion: mlNodeVersion,
+		PrevStatus:             prevStatus,
+		CurrentStatus:          currentStatus,
+		MlNodeVersion:          mlNodeVersion,
+		PoCValidationInference: pocValidationInference,
 	}, nil
 }
 
diff --git a/decentralized-api/broker/broker_test.go b/decentralized-api/broker/broker_test.go
index 582e26d920..99e3dd7e00 100644
--- a/decentralized-api/broker/broker_test.go
+++ b/decentralized-api/broker/broker_test.go
@@ -666,6 +666,125 @@ func TestEnsurePreservedMembershipCached_KeepsCacheWhenParticipantAddressUnavail
 	assert.True(t, broker.nodes["node-1"].State.PreservedModels["model-a"])
 }
 
+func TestNodeAvailable_ValidationInferenceCapableNode(t *testing.T) {
+	const model = "model1"
+	// AdminState enabled with an epoch below the current one keeps the node
+	// operational regardless of phase, isolating the status-bypass under test.
+	const currentEpoch = uint64(5)
+	operationalAdmin := AdminState{Enabled: true, Epoch: 0}
+
+	newNode := func(mutate func(state *NodeState)) *NodeWithState {
+		state := NodeState{
+			IntendedStatus: types.HardwareNodeStatus_INFERENCE,
+			CurrentStatus:  types.HardwareNodeStatus_INFERENCE,
+			AdminState:     operationalAdmin,
+			EpochModels:    map[string]types.Model{model: {}},
+		}
+		mutate(&state)
+		return &NodeWithState{
+			Node:  Node{Id: "node1", MaxConcurrent: 1},
+			State: state,
+		}
+	}
+
+	// capableValidating is a fully validation-inference-capable node in the
+	// validation step. It passes every gate on its own; each negative case below
+	// composes it with a single defect to prove that only the INFERENCE-status
+	// gates are bypassed and all remaining gates still apply.
+	capableValidating := func(state *NodeState) {
+		state.IntendedStatus = types.HardwareNodeStatus_POC
+		state.CurrentStatus = types.HardwareNodeStatus_POC
+		state.PocIntendedStatus = PocStatusValidating
+		state.PoCValidationInference = true
+	}
+	withDefect := func(defect func(state *NodeState)) func(state *NodeState) {
+		return func(state *NodeState) {
+			capableValidating(state)
+			defect(state)
+		}
+	}
+
+	testCases := []struct {
+		name          string
+		node          *NodeWithState
+		wantAvailable bool
+	}{
+		{
+			name:          "validation-capable node in validation step is available despite POC status",
+			node:          newNode(capableValidating),
+			wantAvailable: true,
+		},
+		{
+			name: "POC node without capability stays unavailable",
+			node: newNode(func(state *NodeState) {
+				state.IntendedStatus = types.HardwareNodeStatus_POC
+				state.CurrentStatus = types.HardwareNodeStatus_POC
+				state.PocIntendedStatus = PocStatusValidating
+				state.PoCValidationInference = false
+			}),
+			wantAvailable: false,
+		},
+		{
+			name: "validation-capable node in generation step stays unavailable",
+			node: newNode(func(state *NodeState) {
+				state.IntendedStatus = types.HardwareNodeStatus_POC
+				state.CurrentStatus = types.HardwareNodeStatus_POC
+				state.PocIntendedStatus = PocStatusGenerating
+				state.PoCValidationInference = true
+			}),
+			wantAvailable: false,
+		},
+		{
+			name:          "plain inference node remains available",
+			node:          newNode(func(state *NodeState) {}),
+			wantAvailable: true,
+		},
+		{
+			name: "node intended for inference but not yet in inference state stays unavailable",
+			node: newNode(func(state *NodeState) {
+				state.CurrentStatus = types.HardwareNodeStatus_POC // intended INFERENCE, not there yet
+			}),
+			wantAvailable: false,
+		},
+		{
+			name: "capable node still blocked while reconciling",
+			node: newNode(withDefect(func(state *NodeState) {
+				state.ReconcileInfo = &ReconcileInfo{Status: types.HardwareNodeStatus_POC, PocStatus: PocStatusValidating}
+			})),
+			wantAvailable: false,
+		},
+		{
+			name: "capable node still blocked when locked to capacity",
+			node: newNode(withDefect(func(state *NodeState) {
+				state.LockCount = 1 // == MaxConcurrent
+			})),
+			wantAvailable: false,
+		},
+		{
+			name: "capable node still blocked when administratively disabled",
+			node: newNode(withDefect(func(state *NodeState) {
+				state.AdminState = AdminState{Enabled: false, Epoch: 0}
+			})),
+			wantAvailable: false,
+		},
+		{
+			name: "capable node still blocked when it lacks the requested model",
+			node: newNode(withDefect(func(state *NodeState) {
+				state.EpochModels = map[string]types.Model{}
+			})),
+			wantAvailable: false,
+		},
+	}
+
+	broker := &Broker{}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			available, reason := broker.nodeAvailable(testCase.node, model, currentEpoch, types.PoCValidatePhase)
+			assert.Equal(t, testCase.wantAvailable, available, "reason: %s", reason)
+		})
+	}
+}
+
 func TestSingleNode(t *testing.T) {
 	broker := NewTestBroker()
 	node := apiconfig.InferenceNodeConfig{
diff --git a/decentralized-api/broker/state_commands.go b/decentralized-api/broker/state_commands.go
index 802cadeb66..3ecbd5aef5 100644
--- a/decentralized-api/broker/state_commands.go
+++ b/decentralized-api/broker/state_commands.go
@@ -312,11 +312,12 @@ func NewSetNodesActualStatusCommand(statusUpdates []StatusUpdate) SetNodesActual
 }
 
 type StatusUpdate struct {
-	NodeId        string
-	PrevStatus    types.HardwareNodeStatus
-	NewStatus     types.HardwareNodeStatus
-	Timestamp     time.Time
-	MlNodeVersion string
+	NodeId                 string
+	PrevStatus             types.HardwareNodeStatus
+	NewStatus              types.HardwareNodeStatus
+	Timestamp              time.Time
+	MlNodeVersion          string
+	PoCValidationInference bool
 }
 
 func (c SetNodesActualStatusCommand) GetResponseChannelCapacity() int {
@@ -350,6 +351,7 @@ func (c SetNodesActualStatusCommand) Execute(b *Broker) {
 
 		node.State.UpdateStatusAt(update.Timestamp, update.NewStatus)
 		node.State.MlNodeVersion = update.MlNodeVersion
+		node.State.PoCValidationInference = update.PoCValidationInference
 	}
 
 	c.Response <- true
diff --git a/decentralized-api/cmd/devshardd/engine.go b/decentralized-api/cmd/devshardd/engine.go
index e3bec3af93..9bebec8bec 100644
--- a/decentralized-api/cmd/devshardd/engine.go
+++ b/decentralized-api/cmd/devshardd/engine.go
@@ -15,14 +15,31 @@ import (
 	mlnodeclient "devshard/mlnode"
 	nmgen "devshard/nodemanager/gen"
 	"devshard/observability"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
+// acquireTimeout bounds each Acquire RPC so a dead dapi fails fast and we
+// can enter local-cache fallback without waiting on gRPC dial/backoff.
+const acquireTimeout = 2 * time.Second
+
+// maxAcquireAttempts is used on the gRPC path when dapi is up but has no free
+// nodes (ResourceExhausted). More attempts than the in-process broker path
+// because dapi's broker may need a few seconds to update node IntendedStatus
+// after an epoch phase transition.
+const maxAcquireAttempts = 10
+
 // devshardEngine implements devshard.InferenceEngine for the standalone
 // devshardd binary. Unlike dapi's in-process adapter it has no broker; it
 // acquires a locked ML node via NodeManager gRPC, POSTs directly, and releases
 // with an outcome reflecting the result.
+//
+// When dapi is unreachable it falls back to mgr's passively learned cache and
+// round-robins direct HTTP without lock/release.
 type devshardEngine struct {
 	mlClient     *mlnodeclient.Client
+	mgr          *mlnodeclient.Manager
 	payloadStore payloadstorage.PayloadStorage
 	httpClient   *http.Client
 	chainParams  internaldevshard.ChainParamsProvider
@@ -30,12 +47,14 @@ type devshardEngine struct {
 
 func newDevshardEngine(
 	mlClient *mlnodeclient.Client,
+	mgr *mlnodeclient.Manager,
 	payloadStore payloadstorage.PayloadStorage,
 	httpClient *http.Client,
 	chainParams internaldevshard.ChainParamsProvider,
 ) *devshardEngine {
 	return &devshardEngine{
 		mlClient:     mlClient,
+		mgr:          mgr,
 		payloadStore: payloadStore,
 		httpClient:   httpClient,
 		chainParams:  chainParams,
@@ -44,10 +63,10 @@ func newDevshardEngine(
 
 // Execute runs an inference on an ML node acquired via NodeManager gRPC.
 //
-// Flow mirrors the in-process dapi EngineAdapter: ModifyRequestBody ->
-// POST to /v1/chat/completions -> processor -> canonicalize + store payloads.
-// The only change is node acquisition (gRPC instead of broker) and the retry
-// policy, which rotates excluded node IDs on transport errors.
+// Flow: ModifyRequestBody -> POST to /v1/chat/completions -> processor ->
+// canonicalize + store payloads.
+// Node acquisition prefers gRPC (dapi authoritative); on dapi-unreachable it
+// falls back to the passive ML-node cache.
 func (e *devshardEngine) Execute(ctx context.Context, req devshard.ExecuteRequest) (*devshard.ExecuteResult, error) {
 	return internaldevshard.ExecuteInferenceWithExecutor(
 		ctx,
@@ -77,33 +96,39 @@ func (e *devshardEngine) executeMLRequest(ctx context.Context, model string, bod
 	return resp, nil
 }
 
-// doWithLockedNode mirrors broker.DoWithLockedNodeHTTPRetry but against the
-// NodeManager gRPC client. It tries up to maxAcquireAttempts acquires,
-// excluding nodes that failed with a transport-class error on earlier
-// attempts. 5xx HTTP responses are also treated as transport-class for the
-// purpose of node rotation. 4xx responses are returned as-is (not retried).
+// doWithLockedNode tries NodeManager gRPC first. On success it records the
+// node in the passive cache (Observe), POSTs, and Releases. If dapi is
+// unreachable it falls back to mgr.PickNode round-robin without lock/release.
+// ResourceExhausted (dapi up, no free nodes) stays on the gRPC retry path.
 func (e *devshardEngine) doWithLockedNode(
 	ctx context.Context,
 	path observability.Path,
 	model string,
 	fn func(endpoint string) (*http.Response, error),
 ) (*http.Response, error) {
-	// More attempts than the in-process broker path because dapi's broker
-	// may need a few seconds to update node IntendedStatus after an epoch
-	// phase transition. The 2s sleep between attempts covers that lag.
-	const maxAcquireAttempts = 10
 	var excluded []string
+	excludedSet := make(map[string]struct{})
 	var lastErr error
 	lastReason := observability.ReasonAcquireErr
 
 	for attempt := 0; attempt < maxAcquireAttempts; attempt++ {
-		acq, err := e.mlClient.Acquire(ctx, model, excluded)
+		acqCtx, cancel := context.WithTimeout(ctx, acquireTimeout)
+		acq, err := e.mlClient.Acquire(acqCtx, model, excluded)
+		cancel()
+
 		if err != nil {
+			if ctx.Err() != nil {
+				lastReason = observability.ReasonTimeout
+				return nil, observability.Classify(lastReason, observability.WhereEngineMLNodeCall, ctx.Err())
+			}
+			if shouldFallback(err) {
+				return e.doWithFallbackNodes(ctx, path, model, excludedSet, fn, err)
+			}
+
+			// dapi up but no nodes (ResourceExhausted) or other transient
+			// acquire errors: sleep and retry; do not fall back.
 			lastReason = observability.ReasonAcquireErr
 			observability.IncMLNodeAttempt(path, lastReason, "")
-			// Couldn't acquire any node (likely ResourceExhausted = no
-			// nodes with IntendedStatus=INFERENCE yet). Sleep before
-			// retrying to give the broker time to process epoch events.
 			lastErr = fmt.Errorf("acquire: %w", err)
 			select {
 			case <-ctx.Done():
@@ -114,6 +139,10 @@ func (e *devshardEngine) doWithLockedNode(
 			continue
 		}
 
+		if e.mgr != nil {
+			e.mgr.Observe(model, acq.NodeId, acq.Endpoint)
+		}
+
 		started := time.Now()
 		resp, httpErr := fn(acq.Endpoint)
 		outcome := nmgen.ReleaseOutcome_SUCCESS
@@ -151,9 +180,10 @@ func (e *devshardEngine) doWithLockedNode(
 			return resp, nil
 		}
 
-		// Failure: rotate excluded set and retry.
+		// Failure: rotate excluded set and retry via gRPC.
 		if acq.NodeId != "" {
 			excluded = append(excluded, acq.NodeId)
+			excludedSet[acq.NodeId] = struct{}{}
 		}
 	}
 
@@ -166,5 +196,84 @@ func (e *devshardEngine) doWithLockedNode(
 	return nil, observability.Classify(lastReason, observability.WhereEngineMLNodeCall, lastErr)
 }
 
+// doWithFallbackNodes serves inference from the passive cache when dapi is
+// unreachable. No lock/release — degraded mode. Rotates on transport/5xx.
+func (e *devshardEngine) doWithFallbackNodes(
+	ctx context.Context,
+	path observability.Path,
+	model string,
+	excluded map[string]struct{},
+	fn func(endpoint string) (*http.Response, error),
+	acquireErr error,
+) (*http.Response, error) {
+	if e.mgr == nil {
+		return nil, observability.Classify(
+			observability.ReasonAcquireErr,
+			observability.WhereEngineMLNodeCall,
+			fmt.Errorf("acquire: %w", acquireErr),
+		)
+	}
+
+	lastErr := fmt.Errorf("acquire: %w", acquireErr)
+	lastReason := observability.ReasonAcquireErr
+
+	for {
+		if ctx.Err() != nil {
+			lastReason = observability.ReasonTimeout
+			return nil, observability.Classify(lastReason, observability.WhereEngineMLNodeCall, ctx.Err())
+		}
+
+		endpoint, nodeID, ok := e.mgr.PickNode(model, excluded)
+		if !ok {
+			observability.IncMLNodeAttempt(path, lastReason, "")
+			return nil, observability.Classify(
+				lastReason,
+				observability.WhereEngineMLNodeCall,
+				fmt.Errorf("mlnode fallback: no cached nodes for model %q: %w", model, lastErr),
+			)
+		}
+
+		started := time.Now()
+		resp, httpErr := fn(endpoint)
+		lastReason = observability.ClassifyMLNodeHTTP(resp, httpErr, ctx.Err())
+		observability.IncMLNodeAttempt(path, lastReason, nodeID)
+		observability.ObserveMLNodeCall(path, nodeID, observability.MetricPhaseTotal, started)
+
+		switch lastReason {
+		case observability.ReasonTransportErr, observability.ReasonTimeout:
+			lastErr = httpErr
+			if lastErr == nil {
+				lastErr = errors.New("mlnode fallback: transport error")
+			}
+			if nodeID != "" {
+				excluded[nodeID] = struct{}{}
+			}
+			continue
+		case observability.ReasonHTTP5xx:
+			resp.Body.Close()
+			lastErr = fmt.Errorf("upstream status %d", resp.StatusCode)
+			if nodeID != "" {
+				excluded[nodeID] = struct{}{}
+			}
+			continue
+		default:
+			// Success and 4xx are returned as-is (no rotation on 4xx).
+			return resp, nil
+		}
+	}
+}
+
+// shouldFallback reports whether an Acquire error means dapi is unreachable
+// and the passive cache should be used. ResourceExhausted is not a fallback
+// trigger — dapi is up and remains authoritative for load balancing.
+func shouldFallback(err error) bool {
+	if mlnodeclient.IsUnavailable(err) {
+		return true
+	}
+	// Short acquire timeout while the request is still live: treat as
+	// unreachable so we fail over instead of sleeping on a dead dapi.
+	return status.Code(err) == codes.DeadlineExceeded
+}
+
 // Compile-time check.
 var _ devshard.InferenceEngine = (*devshardEngine)(nil)
diff --git a/decentralized-api/cmd/devshardd/engine_test.go b/decentralized-api/cmd/devshardd/engine_test.go
new file mode 100644
index 0000000000..e79ad8b76e
--- /dev/null
+++ b/decentralized-api/cmd/devshardd/engine_test.go
@@ -0,0 +1,258 @@
+package main
+
+import (
+	"context"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	mlnodeclient "devshard/mlnode"
+	nmgen "devshard/nodemanager/gen"
+	"devshard/observability"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/status"
+)
+
+type engineMockNM struct {
+	nmgen.UnimplementedNodeManagerServer
+	acquireFunc func(ctx context.Context, req *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error)
+	releaseFunc func(ctx context.Context, req *nmgen.ReleaseMLNodeRequest) (*nmgen.ReleaseMLNodeResponse, error)
+}
+
+func (m *engineMockNM) AcquireMLNode(ctx context.Context, req *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error) {
+	return m.acquireFunc(ctx, req)
+}
+
+func (m *engineMockNM) ReleaseMLNode(ctx context.Context, req *nmgen.ReleaseMLNodeRequest) (*nmgen.ReleaseMLNodeResponse, error) {
+	if m.releaseFunc != nil {
+		return m.releaseFunc(ctx, req)
+	}
+	return &nmgen.ReleaseMLNodeResponse{}, nil
+}
+
+func startEngineMLClient(t *testing.T, srv *engineMockNM) *mlnodeclient.Client {
+	t.Helper()
+	lis, err := net.Listen("tcp", "127.0.0.1:0")
+	require.NoError(t, err)
+
+	grpcSrv := grpc.NewServer()
+	nmgen.RegisterNodeManagerServer(grpcSrv, srv)
+	go grpcSrv.Serve(lis)
+	t.Cleanup(grpcSrv.Stop)
+
+	conn, err := grpc.NewClient(lis.Addr().String(), grpc.WithTransportCredentials(insecure.NewCredentials()))
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = conn.Close() })
+
+	return mlnodeclient.ClientForTest(nmgen.NewNodeManagerClient(conn))
+}
+
+func newTestEngine(ml *mlnodeclient.Client, mgr *mlnodeclient.Manager) *devshardEngine {
+	return &devshardEngine{
+		mlClient:   ml,
+		mgr:        mgr,
+		httpClient: http.DefaultClient,
+	}
+}
+
+func TestDoWithLockedNode_GRPCSuccessObserves(t *testing.T) {
+	var releases atomic.Int32
+	mlHits := atomic.Int32{}
+
+	mlSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mlHits.Add(1)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"ok":true}`))
+	}))
+	t.Cleanup(mlSrv.Close)
+
+	ml := startEngineMLClient(t, &engineMockNM{
+		acquireFunc: func(_ context.Context, req *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error) {
+			assert.Equal(t, "model-a", req.Model)
+			return &nmgen.AcquireMLNodeResponse{
+				LockId:   "lock-1",
+				Endpoint: mlSrv.URL,
+				NodeId:   "node-1",
+			}, nil
+		},
+		releaseFunc: func(_ context.Context, req *nmgen.ReleaseMLNodeRequest) (*nmgen.ReleaseMLNodeResponse, error) {
+			releases.Add(1)
+			assert.Equal(t, "lock-1", req.LockId)
+			assert.Equal(t, nmgen.ReleaseOutcome_SUCCESS, req.Outcome)
+			return &nmgen.ReleaseMLNodeResponse{}, nil
+		},
+	})
+
+	mgr := mlnodeclient.NewManager(time.Hour)
+	eng := newTestEngine(ml, mgr)
+
+	resp, err := eng.doWithLockedNode(context.Background(), observability.PathExecute, "model-a",
+		func(endpoint string) (*http.Response, error) {
+			return http.Get(endpoint)
+		})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	_, _ = io.Copy(io.Discard, resp.Body)
+	_ = resp.Body.Close()
+
+	assert.Equal(t, int32(1), mlHits.Load())
+	assert.Equal(t, int32(1), releases.Load())
+
+	// Passive observe: node is in the cache for fallback.
+	endpoint, nodeID, ok := mgr.PickNode("model-a", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", nodeID)
+	assert.Equal(t, mlSrv.URL, endpoint)
+}
+
+func TestDoWithLockedNode_UnavailableFallsBack(t *testing.T) {
+	var acquires, releases atomic.Int32
+	mlHits := atomic.Int32{}
+
+	mlSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mlHits.Add(1)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"ok":true}`))
+	}))
+	t.Cleanup(mlSrv.Close)
+
+	ml := startEngineMLClient(t, &engineMockNM{
+		acquireFunc: func(_ context.Context, _ *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error) {
+			acquires.Add(1)
+			return nil, status.Error(codes.Unavailable, "dapi down")
+		},
+		releaseFunc: func(_ context.Context, _ *nmgen.ReleaseMLNodeRequest) (*nmgen.ReleaseMLNodeResponse, error) {
+			releases.Add(1)
+			return &nmgen.ReleaseMLNodeResponse{}, nil
+		},
+	})
+
+	mgr := mlnodeclient.NewManager(time.Hour)
+	mgr.Observe("model-a", "node-1", mlSrv.URL)
+	eng := newTestEngine(ml, mgr)
+
+	resp, err := eng.doWithLockedNode(context.Background(), observability.PathExecute, "model-a",
+		func(endpoint string) (*http.Response, error) {
+			return http.Get(endpoint)
+		})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	_, _ = io.Copy(io.Discard, resp.Body)
+	_ = resp.Body.Close()
+
+	assert.Equal(t, int32(1), acquires.Load())
+	assert.Equal(t, int32(0), releases.Load(), "fallback must not Release")
+	assert.Equal(t, int32(1), mlHits.Load())
+}
+
+func TestDoWithLockedNode_ResourceExhaustedDoesNotFallback(t *testing.T) {
+	var acquires atomic.Int32
+	mlHits := atomic.Int32{}
+
+	mlSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mlHits.Add(1)
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(mlSrv.Close)
+
+	ml := startEngineMLClient(t, &engineMockNM{
+		acquireFunc: func(_ context.Context, _ *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error) {
+			acquires.Add(1)
+			return nil, status.Error(codes.ResourceExhausted, "no nodes available")
+		},
+	})
+
+	mgr := mlnodeclient.NewManager(time.Hour)
+	// Cache has a node — fallback must not use it on ResourceExhausted.
+	mgr.Observe("model-a", "node-1", mlSrv.URL)
+	eng := newTestEngine(ml, mgr)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+	defer cancel()
+
+	resp, err := eng.doWithLockedNode(ctx, observability.PathExecute, "model-a",
+		func(endpoint string) (*http.Response, error) {
+			return http.Get(endpoint)
+		})
+	require.Error(t, err)
+	assert.Nil(t, resp)
+	assert.Equal(t, int32(0), mlHits.Load(), "must not fall back to cached node")
+	assert.GreaterOrEqual(t, acquires.Load(), int32(1))
+}
+
+func TestDoWithLockedNode_FallbackRotatesOn5xx(t *testing.T) {
+	var hits1, hits2 atomic.Int32
+
+	bad := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hits1.Add(1)
+		w.WriteHeader(http.StatusBadGateway)
+	}))
+	t.Cleanup(bad.Close)
+
+	good := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hits2.Add(1)
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"ok":true}`))
+	}))
+	t.Cleanup(good.Close)
+
+	ml := startEngineMLClient(t, &engineMockNM{
+		acquireFunc: func(_ context.Context, _ *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error) {
+			return nil, status.Error(codes.Unavailable, "dapi down")
+		},
+	})
+
+	mgr := mlnodeclient.NewManager(time.Hour)
+	mgr.Observe("model-a", "node-bad", bad.URL)
+	mgr.Observe("model-a", "node-good", good.URL)
+	eng := newTestEngine(ml, mgr)
+
+	resp, err := eng.doWithLockedNode(context.Background(), observability.PathExecute, "model-a",
+		func(endpoint string) (*http.Response, error) {
+			return http.Get(endpoint)
+		})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	_, _ = io.Copy(io.Discard, resp.Body)
+	_ = resp.Body.Close()
+
+	assert.Equal(t, int32(1), hits1.Load())
+	assert.Equal(t, int32(1), hits2.Load())
+}
+
+func TestDoWithLockedNode_FallbackEmptyCacheFails(t *testing.T) {
+	ml := startEngineMLClient(t, &engineMockNM{
+		acquireFunc: func(_ context.Context, _ *nmgen.AcquireMLNodeRequest) (*nmgen.AcquireMLNodeResponse, error) {
+			return nil, status.Error(codes.Unavailable, "dapi down")
+		},
+	})
+
+	mgr := mlnodeclient.NewManager(time.Hour)
+	eng := newTestEngine(ml, mgr)
+
+	resp, err := eng.doWithLockedNode(context.Background(), observability.PathExecute, "model-a",
+		func(endpoint string) (*http.Response, error) {
+			return http.Get(endpoint)
+		})
+	require.Error(t, err)
+	assert.Nil(t, resp)
+	assert.Contains(t, err.Error(), "no cached nodes")
+}
+
+func TestShouldFallback(t *testing.T) {
+	assert.True(t, shouldFallback(mlnodeclient.ErrUnavailable))
+	assert.True(t, shouldFallback(status.Error(codes.Unavailable, "x")))
+	assert.True(t, shouldFallback(status.Error(codes.DeadlineExceeded, "timeout")))
+	assert.False(t, shouldFallback(mlnodeclient.ErrNoNodesAvailable))
+	assert.False(t, shouldFallback(status.Error(codes.ResourceExhausted, "x")))
+	assert.False(t, shouldFallback(status.Error(codes.Internal, "x")))
+}
diff --git a/decentralized-api/cmd/devshardd/main.go b/decentralized-api/cmd/devshardd/main.go
index e0d30142de..2f15c8f4b3 100644
--- a/decentralized-api/cmd/devshardd/main.go
+++ b/decentralized-api/cmd/devshardd/main.go
@@ -25,6 +25,7 @@ import (
 	"log"
 	"log/slog"
 	"net/http"
+	_ "net/http/pprof"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -135,6 +136,9 @@ func main() {
 	}
 	defer mlClient.Close()
 
+	mlNodeMgr := newMLNodeManager(ctx)
+	slog.Info("mlnode cache", "ttl", mlNodeMgrTTL())
+
 	payloadDir := filepath.Join(*dataDir, "payloads")
 	if err := os.MkdirAll(payloadDir, 0o755); err != nil {
 		log.Fatalf("create payload dir: %v", err)
@@ -159,8 +163,8 @@ func main() {
 
 	br := internaldevshard.NewChainBridge(recorder)
 
-	engine := newDevshardEngine(mlClient, payloadStore, httpClient, chainParams)
-	validator := newDevshardValidator(mlClient, httpClient, br, recorder, engine, chainParams)
+	engine := newDevshardEngine(mlClient, mlNodeMgr, payloadStore, httpClient, chainParams)
+	validator := newDevshardValidator(mlClient, httpClient, runtimeVersion, br, recorder, engine, chainParams)
 
 	storeDir := filepath.Join(*dataDir, "devshardd")
 	legacyDB := filepath.Join(*dataDir, "devshardd.db")
@@ -184,19 +188,28 @@ func main() {
 	}
 	store := devshardstorage.NewManagedStorage(inner, 3, chainParams)
 	defer store.Close()
-	if paramsSetup.RegisterEpochPrune != nil {
-		cancelEpochPrune := paramsSetup.RegisterEpochPrune(store)
-		defer cancelEpochPrune()
-	}
 
 	manager := internaldevshard.NewHostManager(store, signer, engine, validator, runtimeVersion, br, payloadStore, recorder)
 	manager.SetAvailabilityProvider(availabilityTracker)
 	manager.SetMaxNonceProvider(internaldevshard.RuntimeConfigMaxNonce(chainParams))
 	manager.SetRuntimeParamsProvider(internaldevshard.RuntimeConfigRuntimeParams(chainParams))
+	if paramsSetup.RegisterEpochPrune != nil {
+		cancelEpochPrune := paramsSetup.RegisterEpochPrune(store, func(cutoff uint64) {
+			manager.EvictBefore(cutoff)
+		})
+		defer cancelEpochPrune()
+	}
 
 	if err := manager.RecoverSessions(); err != nil {
 		slog.Warn("recover sessions failed", "error", err)
 	}
+	if watcher, ok := inner.(devshardstorage.PostgresPromotionWatcher); ok {
+		watcher.OnPostgresPromoted(func() {
+			if err := manager.RecoverSessions(); err != nil {
+				slog.Warn("recover sessions after postgres promotion failed", "error", err)
+			}
+		})
+	}
 	store.Start()
 	manager.SetReady()
 
@@ -217,6 +230,7 @@ func main() {
 	manager.Register(e.Group(""))
 
 	addr := fmt.Sprintf(":%d", *port)
+	pprofAddr := fmt.Sprintf("127.0.0.1:%d", *port+10000)
 	errCh := make(chan error, 1)
 	go func() {
 		slog.Info("listening", "addr", addr)
@@ -224,6 +238,12 @@ func main() {
 			errCh <- err
 		}
 	}()
+	go func() {
+		slog.Info("pprof listening", "addr", pprofAddr)
+		if err := http.ListenAndServe(pprofAddr, nil); err != nil && err != http.ErrServerClosed {
+			slog.Warn("pprof listener failed", "addr", pprofAddr, "error", err)
+		}
+	}()
 
 	select {
 	case <-ctx.Done():
@@ -395,6 +415,23 @@ func envOr(key, fallback string) string {
 	return fallback
 }
 
+// newMLNodeManager builds the passive ML-node cache used when dapi is
+// unreachable. TTL is MLNODE_CACHE_TTL (default 10m). Start runs periodic prune.
+func newMLNodeManager(ctx context.Context) *mlnodeclient.Manager {
+	mgr := mlnodeclient.NewManager(mlNodeMgrTTL())
+	mgr.Start(ctx)
+	return mgr
+}
+
+func mlNodeMgrTTL() time.Duration {
+	if v := os.Getenv("MLNODE_CACHE_TTL"); v != "" {
+		if d, err := time.ParseDuration(v); err == nil && d > 0 {
+			return d
+		}
+	}
+	return mlnodeclient.DefaultCacheTTL
+}
+
 func expandHome(path string) (string, error) {
 	if strings.HasPrefix(path, "~/") {
 		home, err := os.UserHomeDir()
diff --git a/decentralized-api/cmd/devshardd/params_provider.go b/decentralized-api/cmd/devshardd/params_provider.go
index 61623cf97d..b116ddb2dc 100644
--- a/decentralized-api/cmd/devshardd/params_provider.go
+++ b/decentralized-api/cmd/devshardd/params_provider.go
@@ -36,7 +36,7 @@ type epochParamsProvider interface {
 // paramsProviderResult holds the active provider and optional epoch-prune hook.
 type paramsProviderResult struct {
 	Provider           epochParamsProvider
-	RegisterEpochPrune func(store *devshardstorage.ManagedStorage) (cancel func())
+	RegisterEpochPrune func(store *devshardstorage.ManagedStorage, evict func(cutoff uint64)) (cancel func())
 	// Source is "adaptive" or "chain"; surfaced for tests / structured logs.
 	Source string
 	// ActiveSource reports grpc|chain when Source is adaptive; nil for chain-only.
@@ -201,7 +201,7 @@ func newAdaptiveParamsResult(
 		ProbeTimeout:       probeTimeout,
 		StaleCheckInterval: staleCheck,
 		Availability:       availability,
-		Log:                  logger,
+		Log:                logger,
 	})
 	if err != nil {
 		return nil, err
@@ -209,9 +209,12 @@ func newAdaptiveParamsResult(
 
 	return &paramsProviderResult{
 		Provider: rc,
-		RegisterEpochPrune: func(store *devshardstorage.ManagedStorage) (cancel func()) {
+		RegisterEpochPrune: func(store *devshardstorage.ManagedStorage, evict func(cutoff uint64)) (cancel func()) {
 			return rc.OnEpochChange(func(_, _ uint64) {
 				store.PruneOnceAsync(ctx)
+				if evict != nil {
+					evict(store.PruneCutoff())
+				}
 			})
 		},
 		Source: paramsSourceAdaptive,
@@ -250,9 +253,12 @@ func newChainParamsResult(
 
 	return &paramsProviderResult{
 		Provider: rc,
-		RegisterEpochPrune: func(store *devshardstorage.ManagedStorage) (cancel func()) {
+		RegisterEpochPrune: func(store *devshardstorage.ManagedStorage, evict func(cutoff uint64)) (cancel func()) {
 			return rc.OnEpochChange(func(_, _ uint64) {
 				store.PruneOnceAsync(ctx)
+				if evict != nil {
+					evict(store.PruneCutoff())
+				}
 			})
 		},
 		Source: paramsSourceChain,
diff --git a/decentralized-api/cmd/devshardd/validation.go b/decentralized-api/cmd/devshardd/validation.go
index c3f41bc977..555619a131 100644
--- a/decentralized-api/cmd/devshardd/validation.go
+++ b/decentralized-api/cmd/devshardd/validation.go
@@ -15,36 +15,38 @@ import (
 )
 
 // devshardValidator implements devshard.ValidationEngine for the standalone
-// devshardd binary. Same shape as dapi's in-process ValidationAdapter; the
-// only structural differences are:
+// devshardd binary. It differs from the old embedded dapi validator in two ways:
 //   - node acquisition uses NodeManager gRPC (no broker)
 //   - the payload-store epoch comes from the mainnet-pinned escrow epoch
 type devshardValidator struct {
-	mlClient    *mlnodeclient.Client
-	httpClient  *http.Client
-	bridge      bridge.MainnetBridge
-	recorder    internaldevshard.PayloadAuthClient
-	engine      *devshardEngine // reused for doWithLockedNode retry loop
-	chainParams internaldevshard.ChainParamsProvider
-	thresholds  *internaldevshard.ValidationThresholdResolver
+	mlClient       *mlnodeclient.Client
+	httpClient     *http.Client
+	bridge         bridge.MainnetBridge
+	recorder       internaldevshard.PayloadAuthClient
+	engine         *devshardEngine // reused for doWithLockedNode retry loop
+	chainParams    internaldevshard.ChainParamsProvider
+	thresholds     *internaldevshard.ValidationThresholdResolver
+	runtimeVersion string
 }
 
 func newDevshardValidator(
 	mlClient *mlnodeclient.Client,
 	httpClient *http.Client,
+	runtimeVersion string,
 	br bridge.MainnetBridge,
 	recorder internaldevshard.PayloadAuthClient,
 	engine *devshardEngine,
 	chainParams internaldevshard.ChainParamsProvider,
 ) *devshardValidator {
 	return &devshardValidator{
-		mlClient:    mlClient,
-		httpClient:  httpClient,
-		bridge:      br,
-		recorder:    recorder,
-		engine:      engine,
-		chainParams: chainParams,
-		thresholds:  internaldevshard.NewValidationThresholdResolver(br, internaldevshard.ValidationThresholdCacheTTL),
+		mlClient:       mlClient,
+		httpClient:     httpClient,
+		bridge:         br,
+		recorder:       recorder,
+		engine:         engine,
+		chainParams:    chainParams,
+		thresholds:     internaldevshard.NewValidationThresholdResolver(br, internaldevshard.ValidationThresholdCacheTTL),
+		runtimeVersion: runtimeVersion,
 	}
 }
 
@@ -56,7 +58,7 @@ func (v *devshardValidator) Validate(ctx context.Context, req devshardpkg.Valida
 		v.bridge,
 		v.recorder,
 		req.EpochID,
-		devshardpkg.VersionedSessionPayloadPath(Version, req.EscrowID),
+		v.sessionPayloadPath(req),
 		v.executeMLRequest,
 		"devshardd",
 		v.chainParams,
@@ -64,6 +66,10 @@ func (v *devshardValidator) Validate(ctx context.Context, req devshardpkg.Valida
 	)
 }
 
+func (v *devshardValidator) sessionPayloadPath(req devshardpkg.ValidateRequest) string {
+	return devshardpkg.VersionedSessionPayloadPath(v.runtimeVersion, req.EscrowID)
+}
+
 func (v *devshardValidator) executeMLRequest(ctx context.Context, model string, body []byte) (*http.Response, error) {
 	resp, err := v.engine.doWithLockedNode(ctx, observability.PathValidate, model, func(endpoint string) (*http.Response, error) {
 		url := endpoint + "/v1/chat/completions"
diff --git a/decentralized-api/cmd/devshardd/validation_test.go b/decentralized-api/cmd/devshardd/validation_test.go
new file mode 100644
index 0000000000..8bbf045b16
--- /dev/null
+++ b/decentralized-api/cmd/devshardd/validation_test.go
@@ -0,0 +1,17 @@
+package main
+
+import (
+	"testing"
+
+	devshardpkg "devshard"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDevshardValidatorPayloadPathUsesRuntimeVersion(t *testing.T) {
+	validator := &devshardValidator{runtimeVersion: "oracle-v2"}
+
+	path := validator.sessionPayloadPath(devshardpkg.ValidateRequest{EscrowID: "escrow-123"})
+
+	require.Equal(t, "devshard/oracle-v2/sessions/escrow-123/payloads", path)
+}
diff --git a/decentralized-api/cosmosclient/cosmosclient.go b/decentralized-api/cosmosclient/cosmosclient.go
index 5c59798b42..3fcfbd9b65 100644
--- a/decentralized-api/cosmosclient/cosmosclient.go
+++ b/decentralized-api/cosmosclient/cosmosclient.go
@@ -271,6 +271,7 @@ type CosmosMessageClient interface {
 	SubmitUnitOfComputePriceProposal(transaction *inferenceapi.MsgSubmitUnitOfComputePriceProposal) error
 	BridgeExchange(transaction *inferencetypes.MsgBridgeExchange) error
 	GetBridgeAddresses(ctx context.Context, chainId string) ([]inferencetypes.BridgeContractAddress, error)
+	BridgeTransactionsByReceipt(ctx context.Context, originChain, blockNumber, receiptIndex string) ([]inferencetypes.BridgeTransaction, error)
 	NewInferenceQueryClient() inferencetypes.QueryClient
 	NewCometQueryClient() cmtservice.ServiceClient
 	BankBalances(ctx context.Context, address string) ([]sdk.Coin, error)
@@ -484,6 +485,18 @@ func (icc *InferenceCosmosClient) GetBridgeAddresses(ctx context.Context, chainI
 	return resp.Addresses, nil
 }
 
+func (icc *InferenceCosmosClient) BridgeTransactionsByReceipt(ctx context.Context, originChain, blockNumber, receiptIndex string) ([]inferencetypes.BridgeTransaction, error) {
+	resp, err := icc.NewInferenceQueryClient().BridgeTransaction(ctx, &inferencetypes.QueryGetBridgeTransactionRequest{
+		OriginChain:  originChain,
+		BlockNumber:  blockNumber,
+		ReceiptIndex: receiptIndex,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return resp.BridgeTransactions, nil
+}
+
 func (icc *InferenceCosmosClient) SendTransactionAsyncWithRetry(msg sdk.Msg, deadlineBlock ...int64) (*sdk.TxResponse, error) {
 	return icc.manager.SendTransactionAsyncWithRetry(msg, deadlineBlock...)
 }
diff --git a/decentralized-api/cosmosclient/mock_cosmos_message_client.go b/decentralized-api/cosmosclient/mock_cosmos_message_client.go
index e5c7b49f8f..9a630c65f2 100644
--- a/decentralized-api/cosmosclient/mock_cosmos_message_client.go
+++ b/decentralized-api/cosmosclient/mock_cosmos_message_client.go
@@ -158,6 +158,15 @@ func (m *MockCosmosMessageClient) GetBridgeAddresses(ctx context.Context, chainI
 	return args.Get(0).([]inferencetypes.BridgeContractAddress), args.Error(1)
 }
 
+func (m *MockCosmosMessageClient) BridgeTransactionsByReceipt(ctx context.Context, originChain, blockNumber, receiptIndex string) ([]inferencetypes.BridgeTransaction, error) {
+	args := m.Called(ctx, originChain, blockNumber, receiptIndex)
+	var txs []inferencetypes.BridgeTransaction
+	if r := args.Get(0); r != nil {
+		txs = r.([]inferencetypes.BridgeTransaction)
+	}
+	return txs, args.Error(1)
+}
+
 func (m *MockCosmosMessageClient) SendTransactionAsyncWithRetry(msg sdk.Msg, deadlineBlock ...int64) (*sdk.TxResponse, error) {
 	args := m.Called(msg)
 	return args.Get(0).(*sdk.TxResponse), args.Error(1)
diff --git a/decentralized-api/cosmosclient/tx_manager/errors.go b/decentralized-api/cosmosclient/tx_manager/errors.go
index 3cc49a5055..a16fe380aa 100644
--- a/decentralized-api/cosmosclient/tx_manager/errors.go
+++ b/decentralized-api/cosmosclient/tx_manager/errors.go
@@ -67,6 +67,10 @@ var retryablePatterns = []string{
 
 	"unordered transaction has a timeout_timestamp that has already passed",
 	"unordered tx ttl exceeds",
+	// Out-of-gas: the per-msg-type estimate underestimated this batch's
+	// real consumption. Retry with a bumped gasWanted (estimateBatchGas
+	// applies a multiplier per attempt, see gas_estimate.go).
+	"out of gas",
 }
 
 // isRetryableRawLog checks if the raw log contains any retryable error patterns
diff --git a/decentralized-api/cosmosclient/tx_manager/gas_estimate.go b/decentralized-api/cosmosclient/tx_manager/gas_estimate.go
new file mode 100644
index 0000000000..eb2f1657a0
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/gas_estimate.go
@@ -0,0 +1,186 @@
+package tx_manager
+
+import (
+	"cosmossdk.io/math"
+	"github.com/cosmos/cosmos-sdk/client"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	blstypes "github.com/productscience/inference/x/bls/types"
+	collateraltypes "github.com/productscience/inference/x/collateral/types"
+	inferencetypes "github.com/productscience/inference/x/inference/types"
+)
+
+// applyGasAndFee writes gasWanted (capped at BatchGasLimit) onto the tx
+// builder and computes the matching fee from minGasPriceNgonka. Extracted
+// for unit testing without keyring/signing setup.
+func applyGasAndFee(tx client.TxBuilder, gasWanted uint64, minGasPriceNgonka int64) {
+	if gasWanted == 0 || gasWanted > BatchGasLimit {
+		gasWanted = BatchGasLimit
+	}
+	tx.SetGasLimit(gasWanted)
+	if minGasPriceNgonka > 0 {
+		feeAmount := math.NewIntFromUint64(gasWanted).MulRaw(minGasPriceNgonka)
+		tx.SetFeeAmount(sdk.NewCoins(sdk.NewCoin(inferencetypes.BaseCoin, feeAmount)))
+	} else {
+		tx.SetFeeAmount(sdk.Coins{})
+	}
+}
+
+// Per-message gas estimates. Cosmos charges fees on gasWanted (not gasUsed),
+// so over-sizing inflates routine costs and under-sizing causes OOG.
+//
+// Numbers are p99 of observed gasUsed × ~1.5 from a 24h mainnet sample
+// (see /tmp/gonka-gas-analysis/report.md). The headroom expects ~1% of txs
+// to OOG; estimateBatchGas doubles per attempt to escape the retry loop.
+//
+// Two messages have linear-scaling formulas mirroring their on-chain
+// ConsumeGas: MsgPoCV2StoreCommit (per-Count) and MsgMLNodeWeightDistribution
+// (per-entry). Re-tune from a fresh sample after a handler change, a new
+// msg type, or a FeeParams.{base_validation_gas,gas_per_poc_count} change.
+const (
+	// Tx-level fixed cost: ante decorators + authz MsgExec unwrap. Mainnet
+	// hosts almost always run in authz mode, so this absorbs the wrap cost.
+	txOverheadGas = uint64(50_000)
+
+	// Doubled per retry attempt so OOG-on-underestimate eventually fits.
+	gasRetryMultiplier = 2.0
+
+	// Inference lifecycle (bypass-exempt).
+	gasStartInference  = uint64(250_000)
+	gasFinishInference = uint64(250_000)
+	gasValidation      = uint64(1_500_000) // outliers up to 2.1M observed
+
+	// PoC duty messages.
+	gasSubmitPocBatch         = uint64(500_000)
+	gasSubmitPocValidationsV2 = uint64(250_000)
+	gasInvalidateInference    = uint64(500_000)
+	gasRevalidateInference    = uint64(500_000)
+
+	// PoCV2StoreCommit linear formula. WARN: gasPoCV2Base mirrors
+	// FeeParams.base_validation_gas (default 500K), gasPoCV2PerCount
+	// mirrors FeeParams.gas_per_poc_count (default 100). If governance
+	// bumps either, retune both — OOG retry will limp along but at the
+	// cost of wasted block time. Future work: read FeeParams at startup.
+	gasPoCV2Base     = uint64(600_000) // 500K base + 50K sdk + 50% headroom
+	gasPoCV2PerCount = uint64(150)     // 100 on-chain + 50%
+
+	// MLNodeWeightDistribution: linear in total node entries.
+	gasMLNodeBase    = uint64(100_000)
+	gasMLNodePerNode = uint64(50_000)
+
+	// Routine host duties (bypass-exempt).
+	gasSubmitHardwareDiff = uint64(500_000) // observed max 435K
+	gasClaimRewards       = uint64(700_000) // scales w/ epoch inferences
+
+	// Other host operations.
+	gasSubmitSeed                   = uint64(80_000)
+	gasSubmitNewParticipant         = uint64(150_000)
+	gasSubmitNewUnfundedParticipant = uint64(150_000)
+	gasBridgeExchange               = uint64(500_000)
+
+	// BLS DKG (bypass-exempt). Sized at observed max + 30% to absorb
+	// network-size growth without OOG-retry storms during DKG.
+	gasSubmitDealerPart                  = uint64(140_000_000)
+	gasSubmitVerificationVector          = uint64(140_000_000)
+	gasSubmitGroupKeyValidationSignature = uint64(160_000_000) // max 116M, p99 33M
+	gasRespondDealerComplaints           = uint64(150_000_000)
+	gasRequestThresholdSignature         = uint64(2_000_000)
+	gasSubmitPartialSignature            = uint64(5_000_000)
+
+	// Cosmos-SDK / cosmwasm.
+	gasBankSend          = uint64(150_000)
+	gasGovVote           = uint64(80_000)
+	gasDepositCollateral = uint64(100_000)
+	gasWasmExecute       = uint64(300_000)
+
+	// Catch-all for unrecognized types. OOG retry covers the under-estimated case.
+	gasDefaultEstimate = uint64(500_000)
+)
+
+// estimateMsgGas returns the gas estimate for a single message.
+func estimateMsgGas(msg sdk.Msg) uint64 {
+	v, _ := lookupMsgGas(msg)
+	return v
+}
+
+// lookupMsgGas returns (estimate, true) for an explicit case in the switch
+// or (gasDefaultEstimate, false) otherwise. Tests use the bool to assert
+// every msg in InferenceOperationKeyPerms has an explicit case — the value
+// alone can't tell us, since several legit estimates equal the default.
+func lookupMsgGas(msg sdk.Msg) (uint64, bool) {
+	switch m := msg.(type) {
+	case *inferencetypes.MsgStartInference:
+		return gasStartInference, true
+	case *inferencetypes.MsgFinishInference:
+		return gasFinishInference, true
+	case *inferencetypes.MsgValidation:
+		return gasValidation, true
+	case *inferencetypes.MsgInvalidateInference:
+		return gasInvalidateInference, true
+	case *inferencetypes.MsgRevalidateInference:
+		return gasRevalidateInference, true
+	case *inferencetypes.MsgSubmitPocBatch:
+		return gasSubmitPocBatch, true
+	case *inferencetypes.MsgSubmitPocValidationsV2:
+		return gasSubmitPocValidationsV2, true
+	case *inferencetypes.MsgPoCV2StoreCommit:
+		var totalCount uint64
+		for _, e := range m.Entries {
+			totalCount += uint64(e.Count)
+		}
+		return gasPoCV2Base + totalCount*gasPoCV2PerCount, true
+	case *inferencetypes.MsgMLNodeWeightDistribution:
+		var totalNodes uint64
+		for _, e := range m.Entries {
+			totalNodes += uint64(len(e.Weights))
+		}
+		return gasMLNodeBase + totalNodes*gasMLNodePerNode, true
+	case *inferencetypes.MsgSubmitHardwareDiff:
+		return gasSubmitHardwareDiff, true
+	case *inferencetypes.MsgClaimRewards:
+		return gasClaimRewards, true
+	case *inferencetypes.MsgSubmitSeed:
+		return gasSubmitSeed, true
+	case *inferencetypes.MsgSubmitNewParticipant:
+		return gasSubmitNewParticipant, true
+	case *inferencetypes.MsgSubmitNewUnfundedParticipant:
+		return gasSubmitNewUnfundedParticipant, true
+	case *inferencetypes.MsgBridgeExchange:
+		return gasBridgeExchange, true
+	case *blstypes.MsgSubmitDealerPart:
+		return gasSubmitDealerPart, true
+	case *blstypes.MsgSubmitVerificationVector:
+		return gasSubmitVerificationVector, true
+	case *blstypes.MsgSubmitGroupKeyValidationSignature:
+		return gasSubmitGroupKeyValidationSignature, true
+	case *blstypes.MsgRespondDealerComplaints:
+		return gasRespondDealerComplaints, true
+	case *blstypes.MsgRequestThresholdSignature:
+		return gasRequestThresholdSignature, true
+	case *blstypes.MsgSubmitPartialSignature:
+		return gasSubmitPartialSignature, true
+	case *collateraltypes.MsgDepositCollateral:
+		return gasDepositCollateral, true
+	default:
+		return gasDefaultEstimate, false
+	}
+}
+
+// estimateBatchGas sums per-msg estimates + tx overhead, then doubles per
+// retry attempt (capped at BatchGasLimit) so OOG retries escape the loop.
+func estimateBatchGas(msgs []sdk.Msg, attempt int) uint64 {
+	gas := txOverheadGas
+	for _, m := range msgs {
+		gas += estimateMsgGas(m)
+	}
+	for i := 0; i < attempt; i++ {
+		gas = uint64(float64(gas) * gasRetryMultiplier)
+		if gas > BatchGasLimit {
+			break
+		}
+	}
+	if gas > BatchGasLimit {
+		return BatchGasLimit
+	}
+	return gas
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/gas_estimate_test.go b/decentralized-api/cosmosclient/tx_manager/gas_estimate_test.go
new file mode 100644
index 0000000000..e290779976
--- /dev/null
+++ b/decentralized-api/cosmosclient/tx_manager/gas_estimate_test.go
@@ -0,0 +1,284 @@
+package tx_manager
+
+import (
+	"testing"
+
+	"cosmossdk.io/math"
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth/tx"
+	"github.com/stretchr/testify/require"
+
+	inferencepkg "github.com/productscience/inference/x/inference"
+	blstypes "github.com/productscience/inference/x/bls/types"
+	collateraltypes "github.com/productscience/inference/x/collateral/types"
+	inferencetypes "github.com/productscience/inference/x/inference/types"
+)
+
+// TestEstimateMsgGas_KnownTypes pins the per-msg-type estimates so that
+// any silent change to the lookup table fails CI rather than shipping a
+// surprise. Numbers come from gas_estimate.go constants; if you intentionally
+// retune a value, update the test in the same commit.
+func TestEstimateMsgGas_KnownTypes(t *testing.T) {
+	cases := []struct {
+		name string
+		msg  sdk.Msg
+		want uint64
+	}{
+		// Inference lifecycle (all bypass-exempt, but still sized).
+		{"MsgStartInference", &inferencetypes.MsgStartInference{}, gasStartInference},
+		{"MsgFinishInference", &inferencetypes.MsgFinishInference{}, gasFinishInference},
+		{"MsgValidation", &inferencetypes.MsgValidation{}, gasValidation},
+		{"MsgInvalidateInference", &inferencetypes.MsgInvalidateInference{}, gasInvalidateInference},
+		{"MsgRevalidateInference", &inferencetypes.MsgRevalidateInference{}, gasRevalidateInference},
+
+		// PoC duty.
+		{"MsgSubmitPocBatch", &inferencetypes.MsgSubmitPocBatch{}, gasSubmitPocBatch},
+		{"MsgSubmitPocValidationsV2", &inferencetypes.MsgSubmitPocValidationsV2{}, gasSubmitPocValidationsV2},
+
+		// Routine host duties (now bypass-exempt).
+		{"MsgSubmitHardwareDiff", &inferencetypes.MsgSubmitHardwareDiff{}, gasSubmitHardwareDiff},
+		{"MsgClaimRewards", &inferencetypes.MsgClaimRewards{}, gasClaimRewards},
+
+		// Other host operations.
+		{"MsgSubmitSeed", &inferencetypes.MsgSubmitSeed{}, gasSubmitSeed},
+		{"MsgSubmitNewParticipant", &inferencetypes.MsgSubmitNewParticipant{}, gasSubmitNewParticipant},
+		{"MsgSubmitNewUnfundedParticipant", &inferencetypes.MsgSubmitNewUnfundedParticipant{}, gasSubmitNewUnfundedParticipant},
+		{"MsgBridgeExchange", &inferencetypes.MsgBridgeExchange{}, gasBridgeExchange},
+
+		// BLS DKG (bypass-exempt).
+		{"MsgSubmitDealerPart", &blstypes.MsgSubmitDealerPart{}, gasSubmitDealerPart},
+		{"MsgSubmitVerificationVector", &blstypes.MsgSubmitVerificationVector{}, gasSubmitVerificationVector},
+		{"MsgSubmitGroupKeyValidationSignature", &blstypes.MsgSubmitGroupKeyValidationSignature{}, gasSubmitGroupKeyValidationSignature},
+		{"MsgRespondDealerComplaints", &blstypes.MsgRespondDealerComplaints{}, gasRespondDealerComplaints},
+		{"MsgRequestThresholdSignature", &blstypes.MsgRequestThresholdSignature{}, gasRequestThresholdSignature},
+		{"MsgSubmitPartialSignature", &blstypes.MsgSubmitPartialSignature{}, gasSubmitPartialSignature},
+
+		// Collateral.
+		{"MsgDepositCollateral", &collateraltypes.MsgDepositCollateral{}, gasDepositCollateral},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := estimateMsgGas(tc.msg)
+			require.Equal(t, tc.want, got)
+		})
+	}
+}
+
+// TestEstimateMsgGas_DefaultFallback confirms that an unknown message type
+// (one not in the switch) falls through to the conservative default and is
+// flagged as not explicit.
+func TestEstimateMsgGas_DefaultFallback(t *testing.T) {
+	// A message type that intentionally isn't in the per-type switch.
+	type unknownMsg struct{ sdk.Msg }
+	got, explicit := lookupMsgGas(&unknownMsg{})
+	require.Equal(t, gasDefaultEstimate, got)
+	require.False(t, explicit)
+	// And the public estimateMsgGas wrapper returns the same value.
+	require.Equal(t, gasDefaultEstimate, estimateMsgGas(&unknownMsg{}))
+}
+
+// TestEstimateMsgGas_PoCV2_LinearInCount asserts the on-chain formula is
+// mirrored: gas should grow base + sum(entry.Count) * per_count.
+func TestEstimateMsgGas_PoCV2_LinearInCount(t *testing.T) {
+	zero := &inferencetypes.MsgPoCV2StoreCommit{}
+	require.Equal(t, gasPoCV2Base, estimateMsgGas(zero), "no entries = base only")
+
+	for _, count := range []uint32{1, 100, 10_000, 1_000_000} {
+		msg := &inferencetypes.MsgPoCV2StoreCommit{
+			Entries: []*inferencetypes.PoCV2CommitEntry{{Count: count}},
+		}
+		want := gasPoCV2Base + uint64(count)*gasPoCV2PerCount
+		require.Equal(t, want, estimateMsgGas(msg),
+			"count=%d should yield base + count*per_count", count)
+	}
+
+	// Multi-entry: per_count applies to summed Count.
+	multi := &inferencetypes.MsgPoCV2StoreCommit{
+		Entries: []*inferencetypes.PoCV2CommitEntry{{Count: 100}, {Count: 200}, {Count: 300}},
+	}
+	want := gasPoCV2Base + uint64(600)*gasPoCV2PerCount
+	require.Equal(t, want, estimateMsgGas(multi))
+}
+
+// TestEstimateMsgGas_MLNodeDistribution_LinearInNodes asserts the gas grows
+// linearly with the total number of node entries summed across all model
+// entries.
+func TestEstimateMsgGas_MLNodeDistribution_LinearInNodes(t *testing.T) {
+	zero := &inferencetypes.MsgMLNodeWeightDistribution{}
+	require.Equal(t, gasMLNodeBase, estimateMsgGas(zero), "no entries = base only")
+
+	// 5 nodes spread across 2 model entries.
+	msg := &inferencetypes.MsgMLNodeWeightDistribution{
+		Entries: []*inferencetypes.MLNodeDistributionEntry{
+			{Weights: []*inferencetypes.MLNodeWeight{{}, {}, {}}},
+			{Weights: []*inferencetypes.MLNodeWeight{{}, {}}},
+		},
+	}
+	want := gasMLNodeBase + uint64(5)*gasMLNodePerNode
+	require.Equal(t, want, estimateMsgGas(msg))
+}
+
+// TestEstimateBatchGas_SumsPlusOverhead confirms the batch-level estimator
+// adds the tx-level overhead and sums per-msg estimates.
+func TestEstimateBatchGas_SumsPlusOverhead(t *testing.T) {
+	msgs := []sdk.Msg{
+		&inferencetypes.MsgFinishInference{}, // gasFinishInference
+		&inferencetypes.MsgFinishInference{}, // gasFinishInference
+		&inferencetypes.MsgSubmitSeed{},      // gasSubmitSeed
+	}
+	want := txOverheadGas + 2*gasFinishInference + gasSubmitSeed
+	require.Equal(t, want, estimateBatchGas(msgs, 0))
+}
+
+// TestEstimateBatchGas_RetryMultiplier asserts each retry attempt doubles
+// gasWanted up to the BatchGasLimit ceiling. This is what lets an OOG-on-
+// underestimate eventually succeed instead of looping at the same gas.
+func TestEstimateBatchGas_RetryMultiplier(t *testing.T) {
+	msgs := []sdk.Msg{&inferencetypes.MsgSubmitSeed{}}
+	base := estimateBatchGas(msgs, 0)
+
+	for attempt := 1; attempt <= 5; attempt++ {
+		expected := base
+		for i := 0; i < attempt; i++ {
+			expected = uint64(float64(expected) * gasRetryMultiplier)
+		}
+		got := estimateBatchGas(msgs, attempt)
+		if expected > BatchGasLimit {
+			require.Equal(t, uint64(BatchGasLimit), got, "attempt=%d should cap at BatchGasLimit", attempt)
+		} else {
+			require.Equal(t, expected, got, "attempt=%d should double base estimate", attempt)
+		}
+	}
+}
+
+// TestEstimateBatchGas_CapsAtBatchGasLimit confirms we never request more
+// gas than the chain's NetworkDutyFeeBypassDecorator GasCap can accommodate
+// (currently 3B; BatchGasLimit is 1B, well within).
+func TestEstimateBatchGas_CapsAtBatchGasLimit(t *testing.T) {
+	// A large PoCV2 commit can naturally exceed BatchGasLimit at high count.
+	huge := &inferencetypes.MsgPoCV2StoreCommit{
+		Entries: []*inferencetypes.PoCV2CommitEntry{{Count: ^uint32(0)}}, // max uint32
+	}
+	got := estimateBatchGas([]sdk.Msg{huge}, 0)
+	require.Equal(t, uint64(BatchGasLimit), got, "should cap, not overflow")
+
+	// Also via retry escalation on a moderate batch.
+	moderate := []sdk.Msg{&inferencetypes.MsgClaimRewards{}}
+	got = estimateBatchGas(moderate, 100) // way more retries than realistic
+	require.Equal(t, uint64(BatchGasLimit), got)
+}
+
+// TestEstimateBatchGas_EmptyBatch returns just the tx-level overhead — no
+// crash on a zero-msg batch.
+func TestEstimateBatchGas_EmptyBatch(t *testing.T) {
+	require.Equal(t, txOverheadGas, estimateBatchGas(nil, 0))
+	require.Equal(t, txOverheadGas, estimateBatchGas([]sdk.Msg{}, 0))
+}
+
+// newTestTxBuilder spins up a real TxBuilder backed by the standard cosmos
+// proto codec. Real builder is cheaper to set up than to stub correctly,
+// since TxBuilder is an interface with several internal-state methods.
+func newTestTxBuilder(t *testing.T) client.TxBuilder {
+	t.Helper()
+	registry := codectypes.NewInterfaceRegistry()
+	cdc := codec.NewProtoCodec(registry)
+	cfg := tx.NewTxConfig(cdc, tx.DefaultSignModes)
+	return cfg.NewTxBuilder()
+}
+
+// TestApplyGasAndFee_SetsGasLimitAndZeroFee covers the v0.2.12 mainnet
+// configuration: minGasPriceNgonka=0, so fees are always empty regardless
+// of gasWanted, and the gas limit reflects the per-batch estimate.
+func TestApplyGasAndFee_SetsGasLimitAndZeroFee(t *testing.T) {
+	b := newTestTxBuilder(t)
+
+	applyGasAndFee(b, 250_000, 0)
+	require.Equal(t, uint64(250_000), b.GetTx().GetGas())
+	require.True(t, b.GetTx().GetFee().IsZero(), "fees must be empty when minGasPrice=0")
+}
+
+// TestApplyGasAndFee_ComputesFeeFromMinGasPrice verifies that when
+// min_gas_price is non-zero (post-v0.2.12), fee = gasWanted × minGasPrice.
+func TestApplyGasAndFee_ComputesFeeFromMinGasPrice(t *testing.T) {
+	b := newTestTxBuilder(t)
+
+	const gasWanted, minGasPrice = uint64(250_000), int64(10)
+	applyGasAndFee(b, gasWanted, minGasPrice)
+
+	require.Equal(t, gasWanted, b.GetTx().GetGas())
+	fees := b.GetTx().GetFee()
+	require.Len(t, fees, 1)
+	require.Equal(t, "ngonka", fees[0].Denom)
+	expected := math.NewIntFromUint64(gasWanted).MulRaw(minGasPrice)
+	require.True(t, fees[0].Amount.Equal(expected),
+		"fee should be gasWanted × minGasPrice, got %s expected %s", fees[0].Amount, expected)
+}
+
+// TestApplyGasAndFee_CapsAtBatchGasLimit confirms we never set gasWanted
+// above the chain's NetworkDutyFeeBypassDecorator GasCap can accommodate.
+// Both 0 and "exceeds limit" should clamp to BatchGasLimit.
+func TestApplyGasAndFee_CapsAtBatchGasLimit(t *testing.T) {
+	// Zero -> use BatchGasLimit (defensive default).
+	b := newTestTxBuilder(t)
+	applyGasAndFee(b, 0, 0)
+	require.Equal(t, uint64(BatchGasLimit), b.GetTx().GetGas())
+
+	// Above limit -> cap at BatchGasLimit.
+	b2 := newTestTxBuilder(t)
+	applyGasAndFee(b2, BatchGasLimit*2, 0)
+	require.Equal(t, uint64(BatchGasLimit), b2.GetTx().GetGas())
+}
+
+// TestBroadcastMessages_EmptyBatch_NoOp pins the early-return guard at
+// the top of broadcastMessagesAtAttempt: a zero-message batch returns
+// (nil, zero-time, nil) without touching the factory or the wire. Without
+// this guard a refactor could route an empty batch into BuildUnsignedTx,
+// which produces a confusing chain-side decode error far from the
+// cause. The guard fields none of the manager's other state, so a zero-
+// value manager is enough to exercise the path.
+func TestBroadcastMessages_EmptyBatch_NoOp(t *testing.T) {
+	m := &manager{}
+
+	resp, ts, err := m.BroadcastMessages("test-id")
+	require.NoError(t, err)
+	require.Nil(t, resp)
+	require.True(t, ts.IsZero())
+
+	// Same for the internal helper that retry uses, with a non-zero attempt.
+	resp, ts, err = m.broadcastMessagesAtAttempt("test-id", 5, nil)
+	require.NoError(t, err)
+	require.Nil(t, resp)
+	require.True(t, ts.IsZero())
+
+	resp, ts, err = m.broadcastMessagesAtAttempt("test-id", 0, []sdk.Msg{})
+	require.NoError(t, err)
+	require.Nil(t, resp)
+	require.True(t, ts.IsZero())
+}
+
+// TestEstimateMsgGas_AllInferenceOperationKeyPermsHaveExplicitEstimate
+// catches the case where someone adds a new message type to the warm key's
+// authz permission list (InferenceOperationKeyPerms) but forgets to add it
+// to the gas estimator switch. Without this guard, the new message would
+// silently fall through to gasDefaultEstimate, which may not be enough to
+// cover its real consumption.
+//
+// We use lookupMsgGas (which returns explicit=true iff the type has a
+// case in the switch) rather than comparing values, because several
+// legitimate per-type estimates happen to coincide with gasDefaultEstimate.
+//
+// If this test fails, add the missing case to lookupMsgGas in
+// gas_estimate.go with a number sized from a fresh mainnet sample.
+func TestEstimateMsgGas_AllInferenceOperationKeyPermsHaveExplicitEstimate(t *testing.T) {
+	for _, msg := range inferencepkg.InferenceOperationKeyPerms {
+		t.Run(sdk.MsgTypeURL(msg), func(t *testing.T) {
+			_, explicit := lookupMsgGas(msg)
+			require.True(t, explicit,
+				"%T is in InferenceOperationKeyPerms but has no explicit gas estimate; "+
+					"add a case to lookupMsgGas in gas_estimate.go", msg)
+		})
+	}
+}
diff --git a/decentralized-api/cosmosclient/tx_manager/tx_manager.go b/decentralized-api/cosmosclient/tx_manager/tx_manager.go
index 2998e19e89..311112e763 100644
--- a/decentralized-api/cosmosclient/tx_manager/tx_manager.go
+++ b/decentralized-api/cosmosclient/tx_manager/tx_manager.go
@@ -14,7 +14,6 @@ import (
 	"sync"
 	"time"
 
-	"cosmossdk.io/math"
 	ctypes "github.com/cometbft/cometbft/rpc/core/types"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/tx"
@@ -572,8 +571,8 @@ func (m *manager) sendTxs() error {
 			}
 
 			if !tx.Sent {
-				logging.Debug("start broadcast batch async", types.Messages, "id", tx.TxInfo.Id)
-				resp, timeout, broadcastErr = m.BroadcastMessages(tx.TxInfo.Id, msgs...)
+				logging.Debug("start broadcast batch async", types.Messages, "id", tx.TxInfo.Id, "attempt", tx.TxInfo.Attempts)
+				resp, timeout, broadcastErr = m.broadcastMessagesAtAttempt(tx.TxInfo.Id, tx.TxInfo.Attempts, msgs)
 			}
 		} else {
 			rawTx, err := m.unpackTx(tx.TxInfo.RawTx)
@@ -584,8 +583,8 @@ func (m *manager) sendTxs() error {
 			}
 
 			if !tx.Sent {
-				logging.Debug("start broadcast tx async", types.Messages, "id", tx.TxInfo.Id)
-				resp, timeout, broadcastErr = m.broadcastMessage(tx.TxInfo.Id, rawTx)
+				logging.Debug("start broadcast tx async", types.Messages, "id", tx.TxInfo.Id, "attempt", tx.TxInfo.Attempts)
+				resp, timeout, broadcastErr = m.broadcastMessageAtAttempt(tx.TxInfo.Id, tx.TxInfo.Attempts, rawTx)
 			}
 		}
 
@@ -795,15 +794,24 @@ func (m *manager) GetJetStream() nats.JetStreamContext {
 	return m.natsJetStream
 }
 
-func (m *manager) BroadcastMessages(id string, msgs ...sdk.Msg) (resp *sdk.TxResponse, ts time.Time, err error) {
+func (m *manager) BroadcastMessages(id string, msgs ...sdk.Msg) (*sdk.TxResponse, time.Time, error) {
+	return m.broadcastMessagesAtAttempt(id, 0, msgs)
+}
+
+// broadcastMessagesAtAttempt is the single broadcast path used by all
+// callers (single-msg, batch, first attempt, retry). attempt=0 sizes
+// gasWanted from the per-msg-type estimate; subsequent attempts bump
+// gasWanted to escape OOG loops. See estimateBatchGas in gas_estimate.go.
+func (m *manager) broadcastMessagesAtAttempt(id string, attempt int, msgs []sdk.Msg) (resp *sdk.TxResponse, timestamp time.Time, err error) {
 	if len(msgs) == 0 {
 		return nil, time.Time{}, nil
 	}
-	if len(msgs) == 1 {
-		return m.broadcastMessage(id, msgs[0])
-	}
 
-	_, op := observability.Chain.StartTxBroadcast(context.Background(), sdk.MsgTypeURL(msgs[0]), len(msgs))
+	batchSize := 0
+	if len(msgs) > 1 {
+		batchSize = len(msgs)
+	}
+	_, op := observability.Chain.StartTxBroadcast(context.Background(), sdk.MsgTypeURL(msgs[0]), batchSize)
 	defer func() {
 		if resp != nil {
 			observability.Chain.SetTxResult(op, resp.TxHash, resp.Code)
@@ -816,7 +824,7 @@ func (m *manager) BroadcastMessages(id string, msgs ...sdk.Msg) (resp *sdk.TxRes
 		return nil, time.Time{}, err
 	}
 
-	var finalMsgs []sdk.Msg
+	finalMsgs := msgs
 	if !m.apiAccount.IsSignerTheMainAccount() {
 		granteeAddress, err := m.apiAccount.SignerAddress()
 		if err != nil {
@@ -824,16 +832,16 @@ func (m *manager) BroadcastMessages(id string, msgs ...sdk.Msg) (resp *sdk.TxRes
 		}
 		execMsg := authztypes.NewMsgExec(granteeAddress, msgs)
 		finalMsgs = []sdk.Msg{&execMsg}
-		logging.Debug("Using authz MsgExec for batch", types.Messages, "grantee", granteeAddress.String(), "msgCount", len(msgs))
-	} else {
-		finalMsgs = msgs
+		logging.Debug("Using authz MsgExec", types.Messages, "grantee", granteeAddress.String(), "msgCount", len(msgs))
 	}
 
 	unsignedTx, err := factory.BuildUnsignedTx(finalMsgs...)
 	if err != nil {
 		return nil, time.Time{}, err
 	}
-	txBytes, timestamp, err := m.getSignedBytes(id, unsignedTx, factory)
+	// gasWanted is sized from the inner messages, not the authz wrapper.
+	gasWanted := estimateBatchGas(msgs, attempt)
+	txBytes, timestamp, err := m.getSignedBytes(id, unsignedTx, factory, gasWanted)
 	if err != nil {
 		return nil, time.Time{}, err
 	}
@@ -843,10 +851,19 @@ func (m *manager) BroadcastMessages(id string, msgs ...sdk.Msg) (resp *sdk.TxRes
 		return nil, time.Time{}, err
 	}
 	if resp.Code != 0 {
-		logging.Error("Batch broadcast failed", types.Messages, "code", resp.Code, "rawLog", resp.RawLog, "tx_id", id, "msgCount", len(msgs))
+		logging.Error("Broadcast failed", types.Messages, "code", resp.Code, "rawLog", resp.RawLog,
+			"tx_id", id, "msgCount", len(msgs), "attempt", attempt, "gasWanted", gasWanted)
 		logFeeRelatedHint(resp.RawLog)
 	} else {
-		logging.Debug("Batch broadcast successful", types.Messages, "tx_id", id, "msgCount", len(msgs))
+		// Surface OOG-retry recoveries so we can spot when the static gas
+		// table needs re-tuning. attempt > 0 means a previous broadcast
+		// hit an OOG (or other retryable error) and we doubled gas.
+		if attempt > 0 {
+			logging.Warn("Broadcast succeeded after retry; static gas estimate may be too low",
+				types.Messages, "tx_id", id, "msgCount", len(msgs), "attempt", attempt, "gasWanted", gasWanted)
+		} else {
+			logging.Debug("Broadcast successful", types.Messages, "tx_id", id, "msgCount", len(msgs))
+		}
 	}
 	return resp, timestamp, nil
 }
@@ -887,53 +904,15 @@ func containsAny(s string, substrs ...string) bool {
 	return false
 }
 
-func (m *manager) broadcastMessage(id string, rawTx sdk.Msg) (resp *sdk.TxResponse, ts time.Time, err error) {
-	originalMsgType := sdk.MsgTypeURL(rawTx)
-	_, op := observability.Chain.StartTxBroadcast(context.Background(), originalMsgType, 0)
-	defer func() {
-		if resp != nil {
-			observability.Chain.SetTxResult(op, resp.TxHash, resp.Code)
-		}
-		op.FinishErr(&err)
-	}()
-
-	factory, err := m.getFactory(id)
-	if err != nil {
-		return nil, time.Time{}, err
-	}
-
-	var finalMsg sdk.Msg = rawTx
-	originalMsgTypeForExec := originalMsgType
-	if !m.apiAccount.IsSignerTheMainAccount() {
-		granteeAddress, err := m.apiAccount.SignerAddress()
-		if err != nil {
-			return nil, time.Time{}, fmt.Errorf("failed to get signer address: %w", err)
-		}
-
-		execMsg := authztypes.NewMsgExec(granteeAddress, []sdk.Msg{rawTx})
-		finalMsg = &execMsg
-		logging.Debug("Using authz MsgExec", types.Messages, "grantee", granteeAddress.String(), "originalMsgType", originalMsgTypeForExec)
-	}
-
-	unsignedTx, err := factory.BuildUnsignedTx(finalMsg)
-	if err != nil {
-		return nil, time.Time{}, err
-	}
-	txBytes, timestamp, err := m.getSignedBytes(id, unsignedTx, factory)
-	if err != nil {
-		return nil, time.Time{}, err
-	}
+func (m *manager) broadcastMessage(id string, rawTx sdk.Msg) (*sdk.TxResponse, time.Time, error) {
+	return m.broadcastMessagesAtAttempt(id, 0, []sdk.Msg{rawTx})
+}
 
-	resp, err = m.client.Context().BroadcastTxSync(txBytes)
-	if err != nil {
-		return nil, time.Time{}, err
-	}
-	if resp.Code != 0 {
-		logging.Error("Broadcast failed immediately", types.Messages, "code", resp.Code, "rawLog", resp.RawLog, "tx_id", id, "originalMsgType", originalMsgTypeForExec)
-	} else {
-		logging.Debug("Broadcast successful", types.Messages, "tx_id", id, "originalMsgType", originalMsgTypeForExec, "resp", resp)
-	}
-	return resp, timestamp, nil
+// broadcastMessageAtAttempt is the retry-aware single-message entry point.
+// Thin wrapper around broadcastMessagesAtAttempt with a one-element slice;
+// kept for symmetry with how the retry loop dispatches.
+func (m *manager) broadcastMessageAtAttempt(id string, attempt int, rawTx sdk.Msg) (*sdk.TxResponse, time.Time, error) {
+	return m.broadcastMessagesAtAttempt(id, attempt, []sdk.Msg{rawTx})
 }
 
 func (m *manager) unpackTx(bz []byte) (sdk.Msg, error) {
@@ -991,7 +970,7 @@ func (m *manager) getFactory(id string) (*tx.Factory, error) {
 	return &factory, nil
 }
 
-func (m *manager) getSignedBytes(id string, unsignedTx client.TxBuilder, factory *tx.Factory) ([]byte, time.Time, error) {
+func (m *manager) getSignedBytes(id string, unsignedTx client.TxBuilder, factory *tx.Factory, gasWanted uint64) ([]byte, time.Time, error) {
 	blockTs := m.blockTimeTracker.latestBlockTime
 	if blockTs.IsZero() {
 		_, err := m.updateChainHalt()
@@ -1003,15 +982,13 @@ func (m *manager) getSignedBytes(id string, unsignedTx client.TxBuilder, factory
 
 	timestamp := getTimestamp(blockTs.UnixNano(), m.defaultTimeout)
 
-	// Fee amount = gas limit × gas price. Network-duty messages (validations,
-	// PoC, inference) are fee-exempt via the bypass decorator, so this fee
-	// will not be charged for exempt messages.
-	unsignedTx.SetGasLimit(BatchGasLimit)
-	if m.minGasPriceNgonka > 0 {
-		unsignedTx.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("ngonka", math.NewInt(BatchGasLimit*m.minGasPriceNgonka))))
-	} else {
-		unsignedTx.SetFeeAmount(sdk.Coins{})
-	}
+	// Fee amount = gasWanted × gas price. gasWanted is sized per-batch by
+	// estimateBatchGas (see gas_estimate.go) instead of a constant, so
+	// routine txs aren't billed at the worst-case PoC commit ceiling.
+	// Network-duty messages (PoC, inference, validation, hardware-diff,
+	// claim-rewards, BLS DKG) are fee-exempt via NetworkDutyFeeBypassDecorator
+	// and pay nothing regardless of gasWanted.
+	applyGasAndFee(unsignedTx, gasWanted, m.minGasPriceNgonka)
 
 	// When the warm key signs on behalf of the cold account (authz mode),
 	// set the cold account as the fee granter so fees are deducted from the
diff --git a/decentralized-api/go.mod b/decentralized-api/go.mod
index 341a17e3a0..efde21fb5c 100644
--- a/decentralized-api/go.mod
+++ b/decentralized-api/go.mod
@@ -313,7 +313,7 @@ require (
 
 replace (
 	devshard => ../devshard
-	github.com/cosmos/cosmos-sdk => github.com/gonka-ai/cosmos-sdk v0.53.3-ps17-observability
+	github.com/cosmos/cosmos-sdk => github.com/gonka-ai/cosmos-sdk v0.53.3-ps19-observability
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 	github.com/productscience/inference => ../inference-chain
 )
diff --git a/decentralized-api/go.sum b/decentralized-api/go.sum
index 7bbf0d7d76..9d28be987d 100644
--- a/decentralized-api/go.sum
+++ b/decentralized-api/go.sum
@@ -625,8 +625,8 @@ github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEW
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
 github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/gonka-ai/cosmos-sdk v0.53.3-ps17-observability h1:vWph4b1Xzvwj9jV3BVD6RXQLqRmCsGNyPAxePlFIU0Q=
-github.com/gonka-ai/cosmos-sdk v0.53.3-ps17-observability/go.mod h1:90S054hIbadFB1MlXVZVC5w0QbKfd1P4b79zT+vvJxw=
+github.com/gonka-ai/cosmos-sdk v0.53.3-ps19-observability h1:jzgFsresYGzIbtF/Ov69GxFQ7NHG42R0bP6nMNdzoQU=
+github.com/gonka-ai/cosmos-sdk v0.53.3-ps19-observability/go.mod h1:90S054hIbadFB1MlXVZVC5w0QbKfd1P4b79zT+vvJxw=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=
diff --git a/decentralized-api/internal/devshard/bridge.go b/decentralized-api/internal/devshard/bridge.go
index c357a29c31..5b5c54c990 100644
--- a/decentralized-api/internal/devshard/bridge.go
+++ b/decentralized-api/internal/devshard/bridge.go
@@ -55,6 +55,7 @@ func (b *ChainBridge) GetEscrow(escrowID string) (*bridge.EscrowInfo, error) {
 		InferenceSealGraceNonces:  resp.Escrow.InferenceSealGraceNonces,
 		InferenceSealGraceSeconds: resp.Escrow.InferenceSealGraceSeconds,
 		AutoSealEveryNNonces:      resp.Escrow.AutoSealEveryNNonces,
+		ValidationRate:            resp.Escrow.ValidationRate,
 		EpochID:                   resp.Escrow.EpochIndex,
 	}, nil
 }
@@ -152,6 +153,6 @@ func (b *ChainBridge) SubmitDisputeState(_ string, _ []byte, _ uint64, _ map[uin
 
 // Compile-time check.
 var (
-	_ bridge.MainnetBridge         = (*ChainBridge)(nil)
+	_ bridge.MainnetBridge           = (*ChainBridge)(nil)
 	_ bridge.SessionBindParamsBridge = (*ChainBridge)(nil)
 )
diff --git a/decentralized-api/internal/devshard/chain_params_fetcher.go b/decentralized-api/internal/devshard/chain_params_fetcher.go
index 4773d6bab4..0bcaebe8fc 100644
--- a/decentralized-api/internal/devshard/chain_params_fetcher.go
+++ b/decentralized-api/internal/devshard/chain_params_fetcher.go
@@ -34,7 +34,7 @@ func NewChainParamsFetcher(qcp InferenceQueryClientProvider) *ChainParamsFetcher
 //   - Params.ValidationParams.LogprobsMode (empty → defaultLogprobsMode in chainProvider.refresh)
 //   - Params.DevshardEscrowParams.DevshardRequestsEnabled, MaxNonce
 //   - Params.DevshardEscrowParams v0.2.13 fields (zero on v0.2.12 chain ⇒
-//     compiled defaults via ApplyLiveSessionParams "if > 0 override" semantics)
+//     compiled defaults; ValidationRate is lane A and ignored at bind)
 //   - EpochInfo.LatestEpoch.Index → CurrentEpochID
 //   - EpochInfo.LatestEpoch.PocStartBlockHeight → ParamsBlockHeight
 //     (used as a non-zero monotone-per-epoch proxy so the OnEpochChange gate
diff --git a/decentralized-api/internal/devshard/config_manager_availability.go b/decentralized-api/internal/devshard/config_manager_availability.go
deleted file mode 100644
index 63d6a56bfd..0000000000
--- a/decentralized-api/internal/devshard/config_manager_availability.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package devshard
-
-import (
-	"decentralized-api/apiconfig"
-	"decentralized-api/chainphase"
-
-	devshardpkg "devshard"
-)
-
-// ConfigManagerAvailability implements devshard.AvailabilityProvider for the
-// embedded dapi host. It reads the same caches the event listener updates each
-// block (no separate AvailabilityTracker on the listener path).
-type ConfigManagerAvailability struct {
-	cm      *apiconfig.ConfigManager
-	tracker *chainphase.ChainPhaseTracker
-}
-
-func NewConfigManagerAvailability(cm *apiconfig.ConfigManager, tracker *chainphase.ChainPhaseTracker) *ConfigManagerAvailability {
-	return &ConfigManagerAvailability{cm: cm, tracker: tracker}
-}
-
-func (a *ConfigManagerAvailability) CurrentAvailability() devshardpkg.AvailabilityStatus {
-	if a == nil || a.cm == nil {
-		return devshardpkg.AvailabilityStatus{Enabled: true}
-	}
-
-	epochID := uint64(0)
-	if a.tracker != nil {
-		if st := a.tracker.GetCurrentEpochState(); st != nil {
-			epochID = st.LatestEpoch.EpochIndex
-		}
-	}
-
-	snap := a.cm.RuntimeConfigSnapshot(epochID)
-	ts := int64(0)
-	if !snap.ServedAt.IsZero() {
-		ts = snap.ServedAt.Unix()
-	}
-	return devshardpkg.AvailabilityStatus{
-		Enabled: snap.DevshardRequestsEnabled,
-		Time:    ts,
-		EpochID: epochID,
-	}
-}
diff --git a/decentralized-api/internal/devshard/config_manager_availability_test.go b/decentralized-api/internal/devshard/config_manager_availability_test.go
deleted file mode 100644
index 20f44acfb9..0000000000
--- a/decentralized-api/internal/devshard/config_manager_availability_test.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package devshard
-
-import (
-	"testing"
-
-	"decentralized-api/apiconfig"
-	"decentralized-api/chainphase"
-
-	"github.com/productscience/inference/x/inference/types"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestConfigManagerAvailability_ReflectsCache(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-	avail := NewConfigManagerAvailability(cm, nil)
-
-	got := avail.CurrentAvailability()
-	require.False(t, got.Enabled)
-
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-		DevshardRequestsEnabled: true,
-	})
-	got = avail.CurrentAvailability()
-	assert.True(t, got.Enabled)
-	assert.NotZero(t, got.Time)
-
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-		DevshardRequestsEnabled: false,
-	})
-	got = avail.CurrentAvailability()
-	assert.False(t, got.Enabled)
-}
-
-func TestConfigManagerAvailability_UsesEpochFromTracker(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{DevshardRequestsEnabled: true})
-
-	tracker := &chainphase.ChainPhaseTracker{}
-	tracker.Update(
-		chainphase.BlockInfo{Height: 10, Hash: "h"},
-		&types.Epoch{Index: 42, PocStartBlockHeight: 1},
-		&types.EpochParams{},
-		true,
-		nil,
-	)
-
-	avail := NewConfigManagerAvailability(cm, tracker)
-	got := avail.CurrentAvailability()
-	assert.True(t, got.Enabled)
-	assert.Equal(t, uint64(42), got.EpochID)
-}
-
-func TestConfigManagerAvailability_NilSafe(t *testing.T) {
-	var a *ConfigManagerAvailability
-	got := a.CurrentAvailability()
-	assert.True(t, got.Enabled)
-}
diff --git a/decentralized-api/internal/devshard/embedded_availability_test.go b/decentralized-api/internal/devshard/embedded_availability_test.go
deleted file mode 100644
index cbf00004a2..0000000000
--- a/decentralized-api/internal/devshard/embedded_availability_test.go
+++ /dev/null
@@ -1,108 +0,0 @@
-package devshard
-
-import (
-	"context"
-	"testing"
-
-	"decentralized-api/apiconfig"
-
-	devshardpkg "devshard"
-	"devshard/host"
-	"devshard/signing"
-	"devshard/state"
-	"devshard/storage"
-	"devshard/stub"
-	"devshard/types"
-
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/proto"
-)
-
-// devshard/internal/testutil is module-internal; keep helpers local for dapi tests.
-var embeddedTestPrompt = []byte(`{"model":"llama","messages":[{"role":"user","content":"prompt"}]}`)
-
-func TestEmbeddedHost_ConfigManagerAvailabilityBlocksCompletion(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{DevshardRequestsEnabled: false})
-
-	h := testHostWithAvailability(t, 1, NewConfigManagerAvailability(cm, nil))
-
-	startDiff := signStartDiff(t, h.User, "escrow-1", 1)
-	_, err := h.Host.HandleRequest(context.Background(), host.HostRequest{
-		Diffs: []types.Diff{startDiff}, Nonce: 1, Payload: startInferencePayload(),
-	})
-	require.ErrorIs(t, err, devshardpkg.ErrRequestsDisabled)
-}
-
-type testHostFixture struct {
-	Host *host.Host
-	User *signing.Secp256k1Signer
-}
-
-func testHostWithAvailability(t *testing.T, hostIdx int, avail devshardpkg.AvailabilityProvider) testHostFixture {
-	t.Helper()
-	hosts := mustGenerateKeys(t, 3)
-	user := mustGenerateKey(t)
-	group := makeSlotGroup(hosts)
-	config := defaultSessionConfig(len(hosts))
-	verifier := signing.NewSecp256k1Verifier()
-	infStore := storage.NewMemory()
-	require.NoError(t, infStore.CreateSession(storage.CreateSessionParams{
-		EscrowID: "escrow-1", Version: runtimeTestVersion, CreatorAddr: user.Address(), Config: config, Group: group, InitialBalance: 10000,
-	}))
-	sm, err := state.NewStateMachine("escrow-1", config, group, 10000, user.Address(), verifier, infStore)
-	require.NoError(t, err)
-	h, err := host.NewHost(sm, hosts[hostIdx], stub.NewInferenceEngine(), "escrow-1", group, nil,
-		host.WithGrace(10),
-		host.WithAvailabilityProvider(avail),
-	)
-	require.NoError(t, err)
-	return testHostFixture{Host: h, User: user}
-}
-
-func mustGenerateKeys(t *testing.T, n int) []*signing.Secp256k1Signer {
-	t.Helper()
-	out := make([]*signing.Secp256k1Signer, n)
-	for i := range out {
-		out[i] = mustGenerateKey(t)
-	}
-	return out
-}
-
-func makeSlotGroup(signers []*signing.Secp256k1Signer) []types.SlotAssignment {
-	group := make([]types.SlotAssignment, len(signers))
-	for i, s := range signers {
-		group[i] = types.SlotAssignment{SlotID: uint32(i), ValidatorAddress: s.Address()}
-	}
-	return group
-}
-
-func defaultSessionConfig(numHosts int) types.SessionConfig {
-	return types.NormalizeSessionConfig(types.SessionConfig{
-		RefusalTimeout: 60, ExecutionTimeout: 1200, TokenPrice: 1,
-		VoteThreshold: uint32(numHosts) / 2, ValidationRate: 5000,
-	}, numHosts)
-}
-
-func signStartDiff(t *testing.T, signer signing.Signer, escrowID string, inferenceID uint64) types.Diff {
-	t.Helper()
-	promptHash, err := devshardpkg.CanonicalPromptHash(embeddedTestPrompt)
-	require.NoError(t, err)
-	txs := []*types.DevshardTx{{Tx: &types.DevshardTx_StartInference{StartInference: &types.MsgStartInference{
-		InferenceId: inferenceID, PromptHash: promptHash, Model: "llama",
-		InputLength: 100, MaxTokens: 50, StartedAt: 1000,
-	}}}}
-	content := &types.DiffContent{Nonce: 1, Txs: txs, EscrowId: escrowID}
-	data, err := proto.MarshalOptions{Deterministic: true}.Marshal(content)
-	require.NoError(t, err)
-	sig, err := signer.Sign(data)
-	require.NoError(t, err)
-	return types.Diff{Nonce: 1, Txs: txs, UserSig: sig}
-}
-
-func startInferencePayload() *host.InferencePayload {
-	return &host.InferencePayload{
-		Prompt: embeddedTestPrompt, Model: "llama",
-		InputLength: 100, MaxTokens: 50, StartedAt: 1000,
-	}
-}
diff --git a/decentralized-api/internal/devshard/engine.go b/decentralized-api/internal/devshard/engine.go
deleted file mode 100644
index 565b19d225..0000000000
--- a/decentralized-api/internal/devshard/engine.go
+++ /dev/null
@@ -1,101 +0,0 @@
-package devshard
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"net/http"
-	"time"
-
-	"decentralized-api/broker"
-	"decentralized-api/chainphase"
-	"decentralized-api/payloadstorage"
-
-	"devshard"
-	"devshard/observability"
-	devshardserver "devshard/server"
-)
-
-// EngineAdapter implements devshard.InferenceEngine by delegating to broker and completionapi.
-type EngineAdapter struct {
-	broker       *broker.Broker
-	nodeVersion  string
-	payloadStore payloadstorage.PayloadStorage
-	phaseTracker *chainphase.ChainPhaseTracker
-	httpClient   *http.Client
-	chainParams  ChainParamsProvider
-}
-
-func NewEngineAdapter(
-	b *broker.Broker,
-	nodeVersion string,
-	ps payloadstorage.PayloadStorage,
-	phaseTracker *chainphase.ChainPhaseTracker,
-	httpClient *http.Client,
-	chainParams ChainParamsProvider,
-) *EngineAdapter {
-	return &EngineAdapter{
-		broker:       b,
-		nodeVersion:  nodeVersion,
-		payloadStore: ps,
-		phaseTracker: phaseTracker,
-		httpClient:   httpClient,
-		chainParams:  chainParams,
-	}
-}
-
-func (e *EngineAdapter) Execute(ctx context.Context, req devshard.ExecuteRequest) (*devshard.ExecuteResult, error) {
-	return ExecuteInferenceWithExecutor(
-		ctx,
-		req,
-		e.payloadStore,
-		req.EpochID,
-		e.executeMLRequest,
-		e.chainParams,
-	)
-}
-
-func (e *EngineAdapter) executeMLRequest(ctx context.Context, model string, body []byte) (*http.Response, error) {
-	lastReason := observability.ReasonAcquireErr
-	resp, err := broker.DoWithLockedNodeHTTPRetry(e.broker, model, nil, 3,
-		func(node *broker.Node) (*http.Response, *broker.ActionError) {
-			url := node.InferenceUrlWithVersion(e.nodeVersion) + "/v1/chat/completions"
-			started := time.Now()
-			httpReq, reqErr := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
-			if reqErr != nil {
-				lastReason = observability.ReasonApplicationErr
-				observability.IncMLNodeAttempt(observability.PathExecute, lastReason, node.Id)
-				return nil, broker.NewApplicationActionError(reqErr)
-			}
-			httpReq.Header.Set("Content-Type", "application/json")
-			observability.InjectRequestContext(ctx, httpReq.Header)
-			observability.AttachRequestID(httpReq)
-			httpResp, postErr := e.httpClient.Do(httpReq)
-			if postErr == nil {
-				observability.ObserveMLNodeCall(observability.PathExecute, node.Id, observability.MetricPhaseTotal, started)
-			}
-			lastReason = observability.ClassifyMLNodeHTTP(httpResp, postErr, ctx.Err())
-			observability.IncMLNodeAttempt(observability.PathExecute, lastReason, node.Id)
-			if postErr != nil {
-				return nil, broker.NewTransportActionError(postErr)
-			}
-			return httpResp, nil
-		},
-	)
-	if err != nil {
-		if lastReason == observability.ReasonOK {
-			lastReason = observability.ReasonTransportErr
-		}
-		return nil, observability.Classify(lastReason, observability.WhereEngineMLNodeCall, fmt.Errorf("broker execute: %w", err))
-	}
-	return resp, nil
-}
-
-// DevshardPayloadKey creates a namespaced storage key for devshard payloads.
-// Format: "devshard:<escrowID>:<inferenceID>" to prevent cross-session collisions.
-func DevshardPayloadKey(escrowID string, inferenceID uint64) string {
-	return devshardserver.PayloadKey(escrowID, inferenceID)
-}
-
-// Compile-time check.
-var _ devshard.InferenceEngine = (*EngineAdapter)(nil)
diff --git a/decentralized-api/internal/devshard/engine_test.go b/decentralized-api/internal/devshard/engine_test.go
index 9c842ee229..110cb5ef03 100644
--- a/decentralized-api/internal/devshard/engine_test.go
+++ b/decentralized-api/internal/devshard/engine_test.go
@@ -185,17 +185,3 @@ func TestModifyRequestBody(t *testing.T) {
 	assert.Equal(t, float64(42), result["seed"])
 	assert.Equal(t, false, result["skip_special_tokens"])
 }
-
-func TestDevshardPayloadKey(t *testing.T) {
-	key := DevshardPayloadKey("escrow-123", 456)
-	assert.Equal(t, "devshard:escrow-123:456", key)
-}
-
-func TestDevshardPayloadKey_DifferentEscrows(t *testing.T) {
-	key1 := DevshardPayloadKey("escrow-1", 100)
-	key2 := DevshardPayloadKey("escrow-2", 100)
-
-	assert.NotEqual(t, key1, key2, "same inference ID in different escrows should have different keys")
-	assert.Equal(t, "devshard:escrow-1:100", key1)
-	assert.Equal(t, "devshard:escrow-2:100", key2)
-}
diff --git a/decentralized-api/internal/devshard/manager.go b/decentralized-api/internal/devshard/manager.go
index 17309a0013..d907e94d6f 100644
--- a/decentralized-api/internal/devshard/manager.go
+++ b/decentralized-api/internal/devshard/manager.go
@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"slices"
 	"strconv"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -41,9 +42,10 @@ import (
 
 // HostManager manages per-escrow devshard sessions with lazy creation.
 type HostManager struct {
-	mu       sync.RWMutex
-	sessions map[string]*transport.Server
-	sf       singleflight.Group
+	mu                 sync.RWMutex
+	sessions           map[string]*transport.Server
+	resolutionFailures map[string]resolutionFailure
+	sf                 singleflight.Group
 
 	readyMu      sync.RWMutex
 	initializing bool
@@ -72,8 +74,16 @@ type HostManager struct {
 const (
 	recoverSessionsConcurrency = 8
 	statsCacheTTL              = 60 * time.Second
+	resolutionFailureTTL       = 30 * time.Second
+	permanentFailureTTL        = 10 * time.Minute
+	maxResolutionFailures      = 1024
 )
 
+type resolutionFailure struct {
+	err       error
+	expiresAt time.Time
+}
+
 type statsShardDetailCache struct {
 	response *statsShardDetailResponse
 	cached   time.Time
@@ -138,18 +148,19 @@ func NewHostManager(
 	recorder PayloadAuthClient,
 ) *HostManager {
 	m := &HostManager{
-		sessions:          make(map[string]*transport.Server),
-		initializing:      true,
-		store:             store,
-		signer:            signer,
-		verifier:          signing.NewSecp256k1Verifier(),
-		engine:            engine,
-		validator:         validator,
-		boundVersion:      boundVersion,
-		bridge:            br,
-		payloadStore:      payloadStore,
-		recorder:          recorder,
-		statsDetailsCache: make(map[string]statsShardDetailCache),
+		sessions:           make(map[string]*transport.Server),
+		resolutionFailures: make(map[string]resolutionFailure),
+		initializing:       true,
+		store:              store,
+		signer:             signer,
+		verifier:           signing.NewSecp256k1Verifier(),
+		engine:             engine,
+		validator:          validator,
+		boundVersion:       boundVersion,
+		bridge:             br,
+		payloadStore:       payloadStore,
+		recorder:           recorder,
+		statsDetailsCache:  make(map[string]statsShardDetailCache),
 	}
 	// Wire the payload prune sink. When payloadStore is nil (tests, tools)
 	// the sink is nil and hosts will not emit any prune events.
@@ -170,6 +181,16 @@ func (m *HostManager) Close() error {
 		}
 		cancel()
 	}
+	m.mu.Lock()
+	sessions := make([]*transport.Server, 0, len(m.sessions))
+	for _, srv := range m.sessions {
+		sessions = append(sessions, srv)
+	}
+	m.sessions = make(map[string]*transport.Server)
+	m.mu.Unlock()
+	for _, srv := range sessions {
+		srv.Host().Close()
+	}
 	return m.store.Close()
 }
 
@@ -204,10 +225,9 @@ func (m *HostManager) SetMaxNonceProvider(p devshardpkg.MaxNonceProvider) {
 }
 
 // SetRuntimeParamsProvider supplies the live long-poll-backed view of session
-// governance params, read at HostManager.create to freeze bind-time fields.
-// freeze ValidationRate / grace / VoteThreshold onto the bound SessionConfig.
-// Until then the provider is captured but not consulted, so wiring this in
-// dapi/devshardd is a no-op for behavior.
+// governance params, read at HostManager.create to freeze lane-B bind-time
+// fields (timeouts, vote_threshold_factor). ValidationRate is lane A and comes
+// from the escrow row via bridge.SessionConfigAtBind.
 func (m *HostManager) SetRuntimeParamsProvider(p RuntimeParamsProvider) {
 	m.params = p
 }
@@ -236,11 +256,17 @@ func (m *HostManager) getOrCreate(escrowID string) (*transport.Server, error) {
 	if srv, ok := m.session(escrowID); ok {
 		return srv, nil
 	}
+	if err := m.cachedResolutionFailure(escrowID, time.Now()); err != nil {
+		return nil, err
+	}
 
 	v, err, _ := m.sf.Do(escrowID, func() (interface{}, error) {
 		if srv, ok := m.session(escrowID); ok {
 			return srv, nil
 		}
+		if err := m.cachedResolutionFailure(escrowID, time.Now()); err != nil {
+			return nil, err
+		}
 
 		srv, err := m.recoverStoredSession(escrowID)
 		if err == nil {
@@ -259,11 +285,67 @@ func (m *HostManager) getOrCreate(escrowID string) (*transport.Server, error) {
 	})
 
 	if err != nil {
+		m.rememberResolutionFailure(escrowID, err, time.Now())
 		return nil, err
 	}
 	return v.(*transport.Server), nil
 }
 
+func (m *HostManager) cachedResolutionFailure(escrowID string, now time.Time) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	cached, ok := m.resolutionFailures[escrowID]
+	if !ok {
+		return nil
+	}
+	if !now.Before(cached.expiresAt) {
+		delete(m.resolutionFailures, escrowID)
+		return nil
+	}
+	return cached.err
+}
+
+func (m *HostManager) rememberResolutionFailure(escrowID string, err error, now time.Time) {
+	if err == nil {
+		return
+	}
+	ttl := resolutionFailureTTL
+	if isPermanentResolutionFailure(err) {
+		ttl = permanentFailureTTL
+	}
+	m.mu.Lock()
+	m.resolutionFailures[escrowID] = resolutionFailure{err: err, expiresAt: now.Add(ttl)}
+	if len(m.resolutionFailures) > maxResolutionFailures {
+		m.sweepExpiredResolutionFailuresLocked(now)
+	}
+	m.mu.Unlock()
+}
+
+func (m *HostManager) sweepExpiredResolutionFailuresLocked(now time.Time) {
+	for escrowID, cached := range m.resolutionFailures {
+		if !now.Before(cached.expiresAt) {
+			delete(m.resolutionFailures, escrowID)
+		}
+	}
+}
+
+func isPermanentResolutionFailure(err error) bool {
+	return errors.Is(err, storage.ErrSessionVersionConflict) ||
+		errors.Is(err, storage.ErrSessionEpochConflict) ||
+		errors.Is(err, storage.ErrEpochPruned)
+}
+
+func (m *HostManager) sessionMatchesBoundVersion(escrowID string) (string, bool, error) {
+	meta, err := m.store.GetSessionMeta(escrowID)
+	if err != nil {
+		return "", false, err
+	}
+	if meta.Version == "" || meta.Version == m.boundVersion {
+		return meta.Version, true, nil
+	}
+	return meta.Version, false, nil
+}
+
 func (m *HostManager) session(escrowID string) (*transport.Server, bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -275,12 +357,45 @@ func (m *HostManager) storeSessionIfAbsent(escrowID string, srv *transport.Serve
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if existing, ok := m.sessions[escrowID]; ok {
+		srv.Host().Close()
 		return existing
 	}
+	delete(m.resolutionFailures, escrowID)
 	m.sessions[escrowID] = srv
+	srv.Host().Start()
 	return srv
 }
 
+func (m *HostManager) EvictBefore(cutoffEpoch uint64) int {
+	if cutoffEpoch == 0 {
+		return 0
+	}
+	m.mu.Lock()
+	evicted := make(map[string]*transport.Server)
+	for escrowID, srv := range m.sessions {
+		if srv.Host().EpochID() >= cutoffEpoch {
+			continue
+		}
+		evicted[escrowID] = srv
+		delete(m.sessions, escrowID)
+		delete(m.resolutionFailures, escrowID)
+	}
+	m.mu.Unlock()
+
+	for escrowID, srv := range evicted {
+		srv.Host().Close()
+		observability.DeleteEscrowMetrics(escrowID)
+	}
+
+	if len(evicted) > 0 {
+		m.statsMu.Lock()
+		m.statsShardsCache = nil
+		m.statsDetailsCache = make(map[string]statsShardDetailCache)
+		m.statsMu.Unlock()
+	}
+	return len(evicted)
+}
+
 func (m *HostManager) create(escrowID string) (*transport.Server, error) {
 	escrow, err := m.bridge.GetEscrow(escrowID)
 	if err != nil {
@@ -294,20 +409,12 @@ func (m *HostManager) create(escrowID string) (*transport.Server, error) {
 
 	creatorAddr := escrow.CreatorAddress
 
-	config := types.SessionConfigFromEscrow(len(group), types.EscrowSessionFields{
-		TokenPrice:                escrow.TokenPrice,
-		CreateDevshardFee:         escrow.CreateDevshardFee,
-		FeePerNonce:               escrow.FeePerNonce,
-		InferenceSealGraceNonces:  escrow.InferenceSealGraceNonces,
-		InferenceSealGraceSeconds: escrow.InferenceSealGraceSeconds,
-		AutoSealEveryNNonces:      escrow.AutoSealEveryNNonces,
-	})
+	config := bridge.SessionConfigAtBind(len(group), escrow)
 	if m.params != nil {
 		live := m.params.SessionParams()
 		config = types.ApplyChainSessionBindParams(config, len(group), types.LiveSessionBindParams{
 			RefusalTimeout:      live.RefusalTimeout,
 			ExecutionTimeout:    live.ExecutionTimeout,
-			ValidationRate:      live.ValidationRate,
 			VoteThresholdFactor: live.VoteThresholdFactor,
 		})
 	} else {
@@ -338,6 +445,7 @@ func (m *HostManager) create(escrowID string) (*transport.Server, error) {
 		Group:          group,
 		InitialBalance: escrow.Amount,
 	}); err != nil {
+		h.Close()
 		return nil, fmt.Errorf("init storage session: %w", err)
 	}
 
@@ -345,6 +453,7 @@ func (m *HostManager) create(escrowID string) (*transport.Server, error) {
 		transport.WithBridge(m.bridge),
 	)
 	if err != nil {
+		h.Close()
 		return nil, fmt.Errorf("create server: %w", err)
 	}
 
@@ -367,7 +476,6 @@ func (m *HostManager) RecoverSessions() error {
 			"duration", time.Since(startedAt))
 		return nil
 	}
-
 	workers := recoverSessionsConcurrency
 	if len(active) < workers {
 		workers = len(active)
@@ -379,6 +487,7 @@ func (m *HostManager) RecoverSessions() error {
 	var wg sync.WaitGroup
 	var recoveredCount atomic.Int64
 	var failedCount atomic.Int64
+	var versionSkippedCount atomic.Int64
 	for i := 0; i < workers; i++ {
 		wg.Add(1)
 		go func() {
@@ -386,6 +495,14 @@ func (m *HostManager) RecoverSessions() error {
 			for sess := range jobs {
 				sessionStartedAt := time.Now()
 				if _, err := m.recoverAndStoreSession(sess.EscrowID); err != nil {
+					if errors.Is(err, storage.ErrSessionVersionConflict) {
+						versionSkippedCount.Add(1)
+						logging.Info("skipping devshard session with foreign version", inferenceTypes.System,
+							"escrow_id", sess.EscrowID, "epoch_id", sess.EpochID,
+							"host_version", m.boundVersion,
+							"duration", time.Since(sessionStartedAt), "error", err)
+						continue
+					}
 					failedCount.Add(1)
 					logging.Error("failed to recover devshard session", inferenceTypes.System,
 						"escrow_id", sess.EscrowID, "epoch_id", sess.EpochID,
@@ -409,6 +526,7 @@ func (m *HostManager) RecoverSessions() error {
 		"session_count", len(active), "worker_count", workers,
 		"recovered_count", recoveredCount.Load(),
 		"failed_count", failedCount.Load(),
+		"version_skipped_count", versionSkippedCount.Load(),
 		"duration", time.Since(startedAt))
 
 	return nil
@@ -517,6 +635,7 @@ func (m *HostManager) recoverStoredSession(escrowID string) (*transport.Server,
 		transport.WithBridge(m.bridge),
 	)
 	if err != nil {
+		h.Close()
 		return nil, fmt.Errorf("create server: %w", err)
 	}
 
@@ -575,11 +694,48 @@ func (m *HostManager) handleStatsShard(c echo.Context) error {
 	}
 	resp, err := m.statsShardDetail(escrowID, time.Now())
 	if err != nil {
+		recordStatsSessionResolutionFailure(c, escrowID, err)
 		return statsHTTPError(err)
 	}
 	return c.JSON(http.StatusOK, resp)
 }
 
+func recordStatsSessionResolutionFailure(c echo.Context, escrowID string, err error) {
+	status, reason := statsSessionResolutionStatus(err)
+	observability.IncSessionResolution("stats_shard_detail", status, reason)
+	observability.Log(c.Request().Context(), observability.LevelWarn,
+		"devshard stats session resolution failed",
+		observability.StageSessionResolved,
+		observability.WhereRoutesSessionResolve,
+		escrowID,
+		reason,
+		err,
+	)
+}
+
+func statsSessionResolutionStatus(err error) (observability.MetricStatus, observability.Reason) {
+	if errors.Is(err, devshardserver.ErrInitializing) {
+		return observability.MetricStatusError, observability.ReasonInitializing
+	}
+	if errors.Is(err, storage.ErrSessionVersionConflict) {
+		return observability.MetricStatusError, observability.ReasonVersionConflict
+	}
+	if errors.Is(err, storage.ErrSessionEpochConflict) {
+		return observability.MetricStatusError, observability.ReasonEpochConflict
+	}
+	msg := err.Error()
+	switch {
+	case strings.Contains(msg, "build group"):
+		return observability.MetricStatusError, observability.ReasonBuildGroupErr
+	case strings.Contains(msg, "get escrow"):
+		return observability.MetricStatusError, observability.ReasonGetEscrowErr
+	case strings.Contains(msg, "storage"):
+		return observability.MetricStatusError, observability.ReasonStorageErr
+	default:
+		return observability.MetricStatusError, observability.ReasonSessionResolveErr
+	}
+}
+
 func (m *HostManager) statsShards(now time.Time) (*statsShardsResponse, error) {
 	if err := m.readinessError(); err != nil {
 		return nil, err
@@ -693,9 +849,23 @@ func (m *HostManager) currentEpochActiveSessions() (uint64, []storage.ActiveSess
 
 	filtered := make([]storage.ActiveSession, 0, len(active))
 	for _, sess := range active {
-		if sess.EpochID == currentEpochID {
-			filtered = append(filtered, sess)
+		if sess.EpochID != currentEpochID {
+			continue
+		}
+		_, matches, err := m.sessionMatchesBoundVersion(sess.EscrowID)
+		if err != nil {
+			logging.Debug("skipping devshard stats session with unreadable meta",
+				inferenceTypes.System,
+				"escrow_id", sess.EscrowID,
+				"epoch_id", sess.EpochID,
+				"error", err,
+			)
+			continue
+		}
+		if !matches {
+			continue
 		}
+		filtered = append(filtered, sess)
 	}
 	slices.SortFunc(filtered, func(a, b storage.ActiveSession) int {
 		return cmp.Compare(a.EpochID, b.EpochID)
diff --git a/decentralized-api/internal/devshard/manager_test.go b/decentralized-api/internal/devshard/manager_test.go
index 4e63271367..738406ec85 100644
--- a/decentralized-api/internal/devshard/manager_test.go
+++ b/decentralized-api/internal/devshard/manager_test.go
@@ -5,11 +5,13 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"path/filepath"
+	"runtime/pprof"
 	"sync"
 	"testing"
 	"time"
@@ -33,6 +35,7 @@ import (
 // runtimeTestVersion is the devshard binary tag used in dapi manager tests
 // (matches versiond / embedded devshard without versiond).
 const runtimeTestVersion = "v1"
+const statsTestRoutePrefix = "/devshard/test"
 
 // mockBridge implements bridge.MainnetBridge for testing recovery.
 type mockBridge struct {
@@ -95,6 +98,12 @@ func (b *countingBridge) SubmitDisputeState(string, []byte, uint64, map[uint32][
 
 var _ bridge.MainnetBridge = (*countingBridge)(nil)
 
+func countHostValidationWorkers() int {
+	var buf bytes.Buffer
+	_ = pprof.Lookup("goroutine").WriteTo(&buf, 2)
+	return bytes.Count(buf.Bytes(), []byte("devshard/host.(*Host).startValidationWorkers.func1"))
+}
+
 type payloadEntry struct {
 	prompt   []byte
 	response []byte
@@ -143,6 +152,31 @@ type currentEpochStore struct {
 
 func (s currentEpochStore) CurrentEpochID() uint64 { return s.epoch }
 
+type metaErrorStore struct {
+	storage.Storage
+	epoch     uint64
+	escrowID  string
+	metaError error
+}
+
+func (s metaErrorStore) CurrentEpochID() uint64 { return s.epoch }
+
+func (s metaErrorStore) GetSessionMeta(escrowID string) (*storage.SessionMeta, error) {
+	if escrowID == s.escrowID {
+		return nil, s.metaError
+	}
+	return s.Storage.GetSessionMeta(escrowID)
+}
+
+type failingCreateStore struct {
+	storage.Storage
+	err error
+}
+
+func (s *failingCreateStore) CreateSession(storage.CreateSessionParams) error {
+	return s.err
+}
+
 type countingListStore struct {
 	storage.Storage
 	listCalls int
@@ -245,7 +279,7 @@ func defaultConfig(n int) types.SessionConfig {
 		ExecutionTimeout: 1200,
 		TokenPrice:       1,
 		VoteThreshold:    uint32(n) / 2,
-		ValidationRate:   5000,
+		ValidationRate:   types.DefaultValidationRate,
 	}
 }
 
@@ -321,6 +355,11 @@ func populateStore(t *testing.T, store storage.Storage, numDiffs int) ([]types.S
 }
 
 func createStoredSession(t *testing.T, store storage.Storage, escrowID string, epochID uint64, numDiffs int) ([]types.SlotAssignment, *signing.Secp256k1Signer, *signing.Secp256k1Signer) {
+	t.Helper()
+	return createStoredSessionWithVersion(t, store, escrowID, epochID, runtimeTestVersion, numDiffs)
+}
+
+func createStoredSessionWithVersion(t *testing.T, store storage.Storage, escrowID string, epochID uint64, version string, numDiffs int) ([]types.SlotAssignment, *signing.Secp256k1Signer, *signing.Secp256k1Signer) {
 	t.Helper()
 	hosts := make([]*signing.Secp256k1Signer, 3)
 	for i := range hosts {
@@ -338,7 +377,7 @@ func createStoredSession(t *testing.T, store storage.Storage, escrowID string, e
 		Config:         config,
 		Group:          group,
 		InitialBalance: 100000000,
-		Version:        runtimeTestVersion,
+		Version:        version,
 	}))
 
 	sm, err := state.NewStateMachine(escrowID, config, group, 100000000, user.Address(), verifier, store,
@@ -376,7 +415,7 @@ func TestStatsShardsListsCurrentEpochWithoutDetails(t *testing.T) {
 	mgr := NewHostManager(counting, hostSigner, stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
 	mgr.SetReady()
 
-	rec := requestStats(t, mgr, "/v1/devshard", "/stats/shards")
+	rec := requestStats(t, mgr, statsTestRoutePrefix, "/stats/shards")
 	require.Equal(t, http.StatusOK, rec.Code, "body: %s", rec.Body.String())
 	require.NotContains(t, rec.Body.String(), "host_stats")
 	require.NotContains(t, rec.Body.String(), "proof")
@@ -398,7 +437,7 @@ func TestStatsShardsListsCurrentEpochWithoutDetails(t *testing.T) {
 	require.Equal(t, "escrow-current", resp.Shards[0].EscrowID)
 	require.Equal(t, uint64(7), resp.Shards[0].EpochID)
 
-	cached := requestStats(t, mgr, "/v1/devshard", "/stats/shards")
+	cached := requestStats(t, mgr, statsTestRoutePrefix, "/stats/shards")
 	require.Equal(t, http.StatusOK, cached.Code, "body: %s", cached.Body.String())
 	require.Equal(t, rec.Body.String(), cached.Body.String())
 	require.Equal(t, 1, counting.listCalls)
@@ -407,6 +446,41 @@ func TestStatsShardsListsCurrentEpochWithoutDetails(t *testing.T) {
 	require.Equal(t, http.StatusOK, rootMounted.Code, "body: %s", rootMounted.Body.String())
 }
 
+func TestStatsShardsSkipsForeignVersionSessions(t *testing.T) {
+	base := newManagerTestStore(t)
+	_, _, hostSigner := createStoredSession(t, base, "escrow-v1", 7, 0)
+	createStoredSessionWithVersion(t, base, "escrow-v2", 7, "v2", 0)
+
+	store := currentEpochStore{Storage: base, epoch: 7}
+	mgr := NewHostManager(store, hostSigner, stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
+	mgr.SetReady()
+
+	rec := requestStats(t, mgr, "/v1/devshard", "/stats/shards")
+	require.Equal(t, http.StatusOK, rec.Code, "body: %s", rec.Body.String())
+	require.Contains(t, rec.Body.String(), "escrow-v1")
+	require.NotContains(t, rec.Body.String(), "escrow-v2")
+}
+
+func TestStatsShardsSkipsSessionsWithUnreadableMeta(t *testing.T) {
+	base := newManagerTestStore(t)
+	_, _, hostSigner := createStoredSession(t, base, "escrow-ok", 7, 0)
+	createStoredSession(t, base, "escrow-bad-meta", 7, 0)
+
+	store := metaErrorStore{
+		Storage:   base,
+		epoch:     7,
+		escrowID:  "escrow-bad-meta",
+		metaError: storage.ErrSessionNotFound,
+	}
+	mgr := NewHostManager(store, hostSigner, stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
+	mgr.SetReady()
+
+	rec := requestStats(t, mgr, statsTestRoutePrefix, "/stats/shards")
+	require.Equal(t, http.StatusOK, rec.Code, "body: %s", rec.Body.String())
+	require.Contains(t, rec.Body.String(), "escrow-ok")
+	require.NotContains(t, rec.Body.String(), "escrow-bad-meta")
+}
+
 func TestStatsShardDetailReturnsStatsOnly(t *testing.T) {
 	base := newManagerTestStore(t)
 	group, _, hostSigner := createStoredSession(t, base, "escrow-detail", 7, 1)
@@ -414,7 +488,7 @@ func TestStatsShardDetailReturnsStatsOnly(t *testing.T) {
 	mgr := NewHostManager(store, hostSigner, stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
 	mgr.SetReady()
 
-	rec := requestStats(t, mgr, "/v1/devshard", "/stats/shards/escrow-detail")
+	rec := requestStats(t, mgr, statsTestRoutePrefix, "/stats/shards/escrow-detail")
 	require.Equal(t, http.StatusOK, rec.Code, "body: %s", rec.Body.String())
 	require.NotContains(t, rec.Body.String(), "inferences")
 	require.NotContains(t, rec.Body.String(), "proof")
@@ -427,7 +501,7 @@ func TestStatsShardDetailReturnsStatsOnly(t *testing.T) {
 		Nonce                       uint64 `json:"nonce"`
 		Version                     string `json:"version"`
 		StateRootAndProtocolVersion string `json:"state_root_and_protocol_version"`
-		HostStats map[string]struct {
+		HostStats                   map[string]struct {
 			Missed               uint32 `json:"missed"`
 			Invalid              uint32 `json:"invalid"`
 			Cost                 uint64 `json:"cost"`
@@ -455,11 +529,25 @@ func TestStatsShardDetailReturnsStatsOnly(t *testing.T) {
 	require.Len(t, resp.HostStats, len(group))
 	require.Equal(t, group, resp.Group)
 
-	cached := requestStats(t, mgr, "/v1/devshard", "/stats/shards/escrow-detail")
+	cached := requestStats(t, mgr, statsTestRoutePrefix, "/stats/shards/escrow-detail")
 	require.Equal(t, http.StatusOK, cached.Code, "body: %s", cached.Body.String())
 	require.Equal(t, rec.Body.String(), cached.Body.String())
 }
 
+func TestStatsShardDetailSkipsForeignVersionSession(t *testing.T) {
+	base := newManagerTestStore(t)
+	_, _, hostSigner := createStoredSessionWithVersion(t, base, "escrow-v2", 7, "v2", 0)
+
+	store := currentEpochStore{Storage: base, epoch: 7}
+	mgr := NewHostManager(store, hostSigner, stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
+	mgr.SetReady()
+
+	before := countHostValidationWorkers()
+	rec := requestStats(t, mgr, "/v1/devshard", "/stats/shards/escrow-v2")
+	require.Equal(t, http.StatusNotFound, rec.Code, "body: %s", rec.Body.String())
+	require.Equal(t, before, countHostValidationWorkers(), "foreign version stats detail must not materialize a host")
+}
+
 func TestRecoverSessions_HappyPath(t *testing.T) {
 	store := newManagerTestStore(t)
 	group, user, hostSigner := populateStore(t, store, 10)
@@ -494,6 +582,66 @@ func TestRecoverSessions_HappyPath(t *testing.T) {
 	require.NotNil(t, srv.Host())
 }
 
+func TestRecoverSessions_SkipsForeignVersionSessions(t *testing.T) {
+	store := newManagerTestStore(t)
+	_, _, hostSigner := createStoredSessionWithVersion(t, store, "escrow-v2", 7, "v2", 1)
+
+	mgr := NewHostManager(store, hostSigner, stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
+	require.NoError(t, mgr.RecoverSessions())
+
+	mgr.mu.RLock()
+	_, ok := mgr.sessions["escrow-v2"]
+	mgr.mu.RUnlock()
+	require.False(t, ok, "foreign-version session must be skipped, not treated as failed recovery")
+}
+
+func TestHostManager_EvictBeforeClosesOldSessions(t *testing.T) {
+	store := newManagerTestStore(t)
+	hosts := make([]*signing.Secp256k1Signer, 3)
+	for i := range hosts {
+		hosts[i] = mustGenerateKey(t)
+	}
+	user := mustGenerateKey(t)
+	group := makeGroup(hosts)
+	config := defaultConfig(3)
+	for _, sess := range []struct {
+		escrowID string
+		epochID  uint64
+	}{
+		{escrowID: "escrow-old", epochID: 5},
+		{escrowID: "escrow-current", epochID: 7},
+	} {
+		require.NoError(t, store.CreateSession(storage.CreateSessionParams{
+			EscrowID:       sess.escrowID,
+			EpochID:        sess.epochID,
+			Version:        runtimeTestVersion,
+			CreatorAddr:    user.Address(),
+			Config:         config,
+			Group:          group,
+			InitialBalance: 100000000,
+		}))
+	}
+
+	mgr := NewHostManager(store, hosts[0], stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, &mockBridge{}, nil, nil)
+	require.NoError(t, mgr.RecoverSessions())
+	t.Cleanup(func() { _ = mgr.Close() })
+	beforeEvict := countHostValidationWorkers()
+	require.GreaterOrEqual(t, beforeEvict, 2*20)
+
+	evicted := mgr.EvictBefore(6)
+	require.Equal(t, 1, evicted)
+	require.Eventually(t, func() bool {
+		return countHostValidationWorkers() <= beforeEvict-20
+	}, time.Second, 10*time.Millisecond)
+
+	mgr.mu.RLock()
+	_, oldOK := mgr.sessions["escrow-old"]
+	_, currentOK := mgr.sessions["escrow-current"]
+	mgr.mu.RUnlock()
+	require.False(t, oldOK)
+	require.True(t, currentOK)
+}
+
 func TestRecoverSessions_LogsRecoveryDurations(t *testing.T) {
 	store := newManagerTestStore(t)
 	group, user, hostSigner := populateStore(t, store, 1)
@@ -797,6 +945,118 @@ func TestSessionServer_GatedUntilReady(t *testing.T) {
 	require.Equal(t, uint64(1), srv.Host().LatestNonce())
 }
 
+func TestSessionServer_StartsRegisteredHost(t *testing.T) {
+	store := newManagerTestStore(t)
+	hosts := make([]*signing.Secp256k1Signer, 3)
+	for i := range hosts {
+		hosts[i] = mustGenerateKey(t)
+	}
+	user := mustGenerateKey(t)
+	addresses := make([]string, len(hosts))
+	for i, h := range hosts {
+		addresses[i] = h.Address()
+	}
+	br := &mockBridge{
+		escrow: &bridge.EscrowInfo{
+			EscrowID:       "escrow-start",
+			EpochID:        7,
+			Amount:         100000,
+			CreatorAddress: user.Address(),
+			Slots:          addresses,
+		},
+	}
+	mgr := NewHostManager(store, hosts[0], stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, br, nil, nil)
+	mgr.SetReady()
+
+	before := countHostValidationWorkers()
+	srv, err := mgr.SessionServer("escrow-start")
+	require.NoError(t, err)
+	t.Cleanup(srv.Host().Close)
+	require.Eventually(t, func() bool {
+		return countHostValidationWorkers() >= before+20
+	}, time.Second, 10*time.Millisecond)
+}
+
+func TestSessionServer_FailedCreateDoesNotStartHost(t *testing.T) {
+	base := newManagerTestStore(t)
+	store := &failingCreateStore{Storage: base, err: storage.ErrEpochPruned}
+	hosts := make([]*signing.Secp256k1Signer, 3)
+	for i := range hosts {
+		hosts[i] = mustGenerateKey(t)
+	}
+	user := mustGenerateKey(t)
+	addresses := make([]string, len(hosts))
+	for i, h := range hosts {
+		addresses[i] = h.Address()
+	}
+	br := &mockBridge{
+		escrow: &bridge.EscrowInfo{
+			EscrowID:       "escrow-pruned",
+			EpochID:        1,
+			Amount:         100000,
+			CreatorAddress: user.Address(),
+			Slots:          addresses,
+		},
+	}
+	mgr := NewHostManager(store, hosts[0], stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, br, nil, nil)
+	mgr.SetReady()
+
+	before := countHostValidationWorkers()
+	_, err := mgr.SessionServer("escrow-pruned")
+	require.ErrorIs(t, err, storage.ErrEpochPruned)
+	require.Equal(t, before, countHostValidationWorkers())
+}
+
+func TestSessionServer_CachesFailedResolution(t *testing.T) {
+	base := newManagerTestStore(t)
+	store := &failingCreateStore{Storage: base, err: storage.ErrEpochPruned}
+	hosts := make([]*signing.Secp256k1Signer, 3)
+	for i := range hosts {
+		hosts[i] = mustGenerateKey(t)
+	}
+	user := mustGenerateKey(t)
+	addresses := make([]string, len(hosts))
+	for i, h := range hosts {
+		addresses[i] = h.Address()
+	}
+	br := &countingBridge{
+		escrow: &bridge.EscrowInfo{
+			EscrowID:       "escrow-cache-failure",
+			EpochID:        1,
+			Amount:         100000,
+			CreatorAddress: user.Address(),
+			Slots:          addresses,
+		},
+	}
+	mgr := NewHostManager(store, hosts[0], stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, br, nil, nil)
+	mgr.SetReady()
+
+	_, err := mgr.SessionServer("escrow-cache-failure")
+	require.ErrorIs(t, err, storage.ErrEpochPruned)
+	_, err = mgr.SessionServer("escrow-cache-failure")
+	require.ErrorIs(t, err, storage.ErrEpochPruned)
+	require.Equal(t, 1, br.getEscrowCalls, "cached failure should avoid rebuilding the same broken escrow")
+}
+
+func TestHostManager_SweepsExpiredResolutionFailures(t *testing.T) {
+	mgr := &HostManager{
+		resolutionFailures: make(map[string]resolutionFailure),
+	}
+	now := time.Unix(1_000, 0)
+	for i := 0; i <= maxResolutionFailures; i++ {
+		mgr.resolutionFailures[fmt.Sprintf("expired-%d", i)] = resolutionFailure{
+			err:       storage.ErrSessionNotFound,
+			expiresAt: now.Add(-time.Second),
+		}
+	}
+
+	mgr.rememberResolutionFailure("fresh", storage.ErrEpochPruned, now)
+
+	require.Len(t, mgr.resolutionFailures, 1)
+	require.Contains(t, mgr.resolutionFailures, "fresh")
+	require.True(t, now.Before(mgr.resolutionFailures["fresh"].expiresAt))
+}
+
 func TestCreateSession_BindsConfiguredVersion(t *testing.T) {
 	store := newManagerTestStore(t)
 	hosts := make([]*signing.Secp256k1Signer, 3)
@@ -857,13 +1117,14 @@ func TestHostManager_Create_FreezesLiveParamsFromProvider(t *testing.T) {
 			TokenPrice:                1,
 			InferenceSealGraceNonces:  123,
 			InferenceSealGraceSeconds: 99,
+			ValidationRate:            6000,
 		},
 	}
 
 	live := SessionParams{
 		RefusalTimeout:      90,
 		ExecutionTimeout:    1800,
-		ValidationRate:      6000,
+		ValidationRate:      9999, // lane B must not override lane A
 		VoteThresholdFactor: 67,
 	}
 	provider := stubRuntimeParams{params: live}
@@ -882,8 +1143,8 @@ func TestHostManager_Create_FreezesLiveParamsFromProvider(t *testing.T) {
 	require.Equal(t, int64(90), meta.Config.RefusalTimeout)
 	require.Equal(t, int64(1800), meta.Config.ExecutionTimeout)
 
-	live.ValidationRate = 9999
-	require.Equal(t, uint32(6000), meta.Config.ValidationRate, "frozen session must not hot-reload")
+	live.ValidationRate = 1111
+	require.Equal(t, uint32(6000), meta.Config.ValidationRate, "validation_rate comes from escrow (lane A), not live provider")
 	require.Equal(t, uint32(123), meta.Config.InferenceSealGraceNonces, "grace comes from escrow snapshot, not live provider")
 }
 
@@ -925,6 +1186,41 @@ func TestHostManager_Create_SnapshotsFeesFromEscrow(t *testing.T) {
 	require.Equal(t, createFee, st.Fees)
 }
 
+func TestHostManager_Create_DefaultValidationRateWhenEscrowOmits(t *testing.T) {
+	store := newManagerTestStore(t)
+	hosts := make([]*signing.Secp256k1Signer, 3)
+	for i := range hosts {
+		hosts[i] = mustGenerateKey(t)
+	}
+	user := mustGenerateKey(t)
+	group := makeGroup(hosts)
+	addresses := make([]string, len(group))
+	for i, s := range group {
+		addresses[i] = s.ValidatorAddress
+	}
+
+	br := &mockBridge{
+		escrow: &bridge.EscrowInfo{
+			EscrowID:       "escrow-1",
+			Amount:         100000,
+			CreatorAddress: user.Address(),
+			Slots:          addresses,
+			TokenPrice:     1,
+			// ValidationRate unset (older chain/dapi)
+		},
+	}
+	provider := stubRuntimeParams{params: SessionParams{ValidationRate: 0}}
+
+	mgr := NewHostManager(store, hosts[0], stub.NewInferenceEngine(), stub.NewValidationEngine(), runtimeTestVersion, br, nil, nil)
+	mgr.SetRuntimeParamsProvider(provider)
+	_, err := mgr.getOrCreate("escrow-1")
+	require.NoError(t, err)
+
+	meta, err := store.GetSessionMeta("escrow-1")
+	require.NoError(t, err)
+	require.Equal(t, types.DefaultValidationRate, meta.Config.ValidationRate)
+}
+
 func TestCreateSession_RejectsExistingDifferentVersion(t *testing.T) {
 	store := newManagerTestStore(t)
 	hosts := make([]*signing.Secp256k1Signer, 3)
@@ -1317,7 +1613,7 @@ func TestStatsShardDetail_ValidationObservabilityAfterDiffApply(t *testing.T) {
 		return total >= 1
 	}, time.Second, 10*time.Millisecond)
 
-	rec := requestStats(t, mgr, "/v1/devshard", "/stats/shards/"+escrowID)
+	rec := requestStats(t, mgr, statsTestRoutePrefix, "/stats/shards/"+escrowID)
 	require.Equal(t, http.StatusOK, rec.Code)
 	var resp struct {
 		ValidationObservability struct {
diff --git a/decentralized-api/internal/devshard/max_nonce_provider.go b/decentralized-api/internal/devshard/max_nonce_provider.go
index 32c1c06655..dcad9a1822 100644
--- a/decentralized-api/internal/devshard/max_nonce_provider.go
+++ b/decentralized-api/internal/devshard/max_nonce_provider.go
@@ -1,23 +1,9 @@
 package devshard
 
 import (
-	"decentralized-api/apiconfig"
 	devshardpkg "devshard"
 )
 
-type configManagerMaxNonce struct {
-	cm *apiconfig.ConfigManager
-}
-
-func (s configManagerMaxNonce) MaxNonce() uint32 {
-	return s.cm.GetDevshardVersions().MaxNonce
-}
-
-// ConfigManagerMaxNonce wraps dapi's devshard versions cache.
-func ConfigManagerMaxNonce(cm *apiconfig.ConfigManager) devshardpkg.MaxNonceProvider {
-	return configManagerMaxNonce{cm: cm}
-}
-
 type runtimeConfigMaxNonce struct {
 	source RuntimeConfigSnapshotSource
 }
diff --git a/decentralized-api/internal/devshard/runtime_params_provider.go b/decentralized-api/internal/devshard/runtime_params_provider.go
index 677adcd913..04a2e9f10c 100644
--- a/decentralized-api/internal/devshard/runtime_params_provider.go
+++ b/decentralized-api/internal/devshard/runtime_params_provider.go
@@ -1,7 +1,6 @@
 package devshard
 
 import (
-	"decentralized-api/apiconfig"
 	"devshard/runtimeconfig"
 )
 
@@ -18,8 +17,8 @@ type RuntimeConfigSnapshotSource interface {
 // session-config-flow-plan: zero means "not provided" so callers can fall
 // through to the compiled defaults baked into SessionConfig.
 //
-// All fields are populated from apiconfig.DevshardVersionsCache /
-// runtimeconfig.Snapshot (long-poll). Zero means "not provided" at bind time.
+// All fields are populated from runtimeconfig.Snapshot (long-poll). Zero means
+// "not provided" at bind time.
 type SessionParams struct {
 	RefusalTimeout      int64
 	ExecutionTimeout    int64
@@ -35,30 +34,8 @@ type RuntimeParamsProvider interface {
 	SessionParams() SessionParams
 }
 
-// configManagerRuntimeParams wraps dapi-embedded apiconfig.ConfigManager.
-type configManagerRuntimeParams struct {
-	cm *apiconfig.ConfigManager
-}
-
-// ConfigManagerRuntimeParams returns a RuntimeParamsProvider backed by dapi's
-// DevshardVersionsCache (same source as GetRuntimeConfig long-poll).
-func ConfigManagerRuntimeParams(cm *apiconfig.ConfigManager) RuntimeParamsProvider {
-	return configManagerRuntimeParams{cm: cm}
-}
-
-func (p configManagerRuntimeParams) SessionParams() SessionParams {
-	cache := p.cm.GetDevshardVersions()
-	return SessionParams{
-		RefusalTimeout:      cache.RefusalTimeout,
-		ExecutionTimeout:    cache.ExecutionTimeout,
-		ValidationRate:      cache.ValidationRate,
-		VoteThresholdFactor: cache.VoteThresholdFactor,
-		MaxNonce:            cache.MaxNonce,
-	}
-}
-
 // runtimeConfigRuntimeParams wraps the devshardd standalone long-poll snapshot
-// source. Mirrors RuntimeConfigMaxNonce — same underlying cache.
+// source. Mirrors RuntimeConfigMaxNonce: same underlying cache.
 type runtimeConfigRuntimeParams struct {
 	source RuntimeConfigSnapshotSource
 }
diff --git a/decentralized-api/internal/devshard/runtime_params_provider_test.go b/decentralized-api/internal/devshard/runtime_params_provider_test.go
index c8cf182d9e..38bf134bd1 100644
--- a/decentralized-api/internal/devshard/runtime_params_provider_test.go
+++ b/decentralized-api/internal/devshard/runtime_params_provider_test.go
@@ -4,7 +4,6 @@ import (
 	"sync"
 	"testing"
 
-	"decentralized-api/apiconfig"
 	"devshard/runtimeconfig"
 
 	"github.com/stretchr/testify/assert"
@@ -28,80 +27,14 @@ func (s *stubSnapshotSource) Snapshot() runtimeconfig.Snapshot {
 	return s.snap
 }
 
-func TestConfigManagerRuntimeParams_FromPopulatedCache(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-		MaxNonce:              2000,
-		ValidationRate:        5000,
-		VoteThresholdFactor:   50,
-		RefusalTimeout:        60,
-		ExecutionTimeout:      1200,
-	})
-
-	p := ConfigManagerRuntimeParams(cm)
-	got := p.SessionParams()
-
-	assert.Equal(t, uint32(2000), got.MaxNonce)
-	assert.Equal(t, uint32(5000), got.ValidationRate)
-	assert.Equal(t, uint32(50), got.VoteThresholdFactor)
-	assert.Equal(t, int64(60), got.RefusalTimeout)
-	assert.Equal(t, int64(1200), got.ExecutionTimeout)
-}
-
-func TestConfigManagerRuntimeParams_EmptyCacheZeroFields(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-
-	p := ConfigManagerRuntimeParams(cm)
-	got := p.SessionParams()
-
-	assert.Equal(t, SessionParams{}, got, "provider must not invent defaults; zero cache → zero params")
-}
-
-func TestConfigManagerRuntimeParams_Phase4FieldsFromCache(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-		MaxNonce:            1,
-		RefusalTimeout:      90,
-		ExecutionTimeout:    1800,
-		ValidationRate:        4000,
-		VoteThresholdFactor: 67,
-	})
-
-	got := ConfigManagerRuntimeParams(cm).SessionParams()
-
-	assert.Equal(t, int64(90), got.RefusalTimeout)
-	assert.Equal(t, int64(1800), got.ExecutionTimeout)
-	assert.Equal(t, uint32(4000), got.ValidationRate)
-	assert.Equal(t, uint32(67), got.VoteThresholdFactor)
-}
-
-func TestConfigManagerRuntimeParams_ReflectsUpdate(t *testing.T) {
-	cm := &apiconfig.ConfigManager{}
-	p := ConfigManagerRuntimeParams(cm)
-
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-		MaxNonce:         12,
-		ValidationRate:   1000,
-	})
-	first := p.SessionParams()
-	assert.Equal(t, uint32(12), first.MaxNonce)
-	assert.Equal(t, uint32(1000), first.ValidationRate)
-
-	cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-		MaxNonce:       22,
-		ValidationRate: 2000,
-	})
-	second := p.SessionParams()
-	assert.Equal(t, uint32(22), second.MaxNonce)
-	assert.Equal(t, uint32(2000), second.ValidationRate)
-}
-
 func TestRuntimeConfigRuntimeParams_FromSnapshot(t *testing.T) {
 	src := &stubSnapshotSource{}
 	src.set(runtimeconfig.Snapshot{
 		MaxNonce:            33,
 		ValidationRate:      6000,
 		VoteThresholdFactor: 50,
+		RefusalTimeout:      60,
+		ExecutionTimeout:    1200,
 	})
 
 	got := RuntimeConfigRuntimeParams(src).SessionParams()
@@ -109,6 +42,8 @@ func TestRuntimeConfigRuntimeParams_FromSnapshot(t *testing.T) {
 	assert.Equal(t, uint32(33), got.MaxNonce)
 	assert.Equal(t, uint32(6000), got.ValidationRate)
 	assert.Equal(t, uint32(50), got.VoteThresholdFactor)
+	assert.Equal(t, int64(60), got.RefusalTimeout)
+	assert.Equal(t, int64(1200), got.ExecutionTimeout)
 }
 
 func TestRuntimeConfigRuntimeParams_ZeroSnapshotZeroFields(t *testing.T) {
@@ -134,23 +69,12 @@ func TestRuntimeParamsProvider_ConcurrentReadsAreSafe(t *testing.T) {
 	const readers = 8
 	const iterations = 200
 
-	t.Run("configManager", func(t *testing.T) {
-		cm := &apiconfig.ConfigManager{}
-		cm.SetDevshardVersions(apiconfig.DevshardVersionsCache{
-			MaxNonce: 7,
-		})
-		p := ConfigManagerRuntimeParams(cm)
-		runConcurrent(t, readers, iterations, func() SessionParams { return p.SessionParams() })
-	})
-
-	t.Run("runtimeConfig", func(t *testing.T) {
-		src := &stubSnapshotSource{}
-		src.set(runtimeconfig.Snapshot{
-			MaxNonce: 7,
-		})
-		p := RuntimeConfigRuntimeParams(src)
-		runConcurrent(t, readers, iterations, func() SessionParams { return p.SessionParams() })
+	src := &stubSnapshotSource{}
+	src.set(runtimeconfig.Snapshot{
+		MaxNonce: 7,
 	})
+	p := RuntimeConfigRuntimeParams(src)
+	runConcurrent(t, readers, iterations, func() SessionParams { return p.SessionParams() })
 }
 
 func runConcurrent(t *testing.T, readers, iterations int, fn func() SessionParams) {
@@ -189,11 +113,12 @@ func runConcurrent(t *testing.T, readers, iterations int, fn func() SessionParam
 func TestHostManager_SetRuntimeParamsProvider_NoBehaviorChange(t *testing.T) {
 	m := &HostManager{}
 
-	p := ConfigManagerRuntimeParams(&apiconfig.ConfigManager{})
+	src := &stubSnapshotSource{}
+	p := RuntimeConfigRuntimeParams(src)
 	m.SetRuntimeParamsProvider(p)
 	require.NotNil(t, m.params)
 
-	other := ConfigManagerRuntimeParams(&apiconfig.ConfigManager{})
+	other := RuntimeConfigRuntimeParams(src)
 	m.SetRuntimeParamsProvider(other)
 	require.NotNil(t, m.params)
 }
diff --git a/decentralized-api/internal/devshard/validation.go b/decentralized-api/internal/devshard/validation.go
deleted file mode 100644
index f584d5c245..0000000000
--- a/decentralized-api/internal/devshard/validation.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package devshard
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"net/http"
-	"time"
-
-	"decentralized-api/broker"
-	"decentralized-api/chainphase"
-
-	"devshard"
-	"devshard/bridge"
-	"devshard/observability"
-)
-
-// ValidationAdapter implements devshard.ValidationEngine by re-executing inference
-// with enforced tokens and comparing logits.
-type ValidationAdapter struct {
-	broker       *broker.Broker
-	nodeVersion  string
-	phaseTracker *chainphase.ChainPhaseTracker
-	httpClient   *http.Client
-	bridge       bridge.MainnetBridge
-	recorder     PayloadAuthClient
-	chainParams  ChainParamsProvider
-	thresholds   *ValidationThresholdResolver
-}
-
-func NewValidationAdapter(
-	b *broker.Broker,
-	nodeVersion string,
-	phaseTracker *chainphase.ChainPhaseTracker,
-	httpClient *http.Client,
-	br bridge.MainnetBridge,
-	recorder PayloadAuthClient,
-	chainParams ChainParamsProvider,
-) *ValidationAdapter {
-	return &ValidationAdapter{
-		broker:       b,
-		nodeVersion:  nodeVersion,
-		phaseTracker: phaseTracker,
-		httpClient:   httpClient,
-		bridge:       br,
-		recorder:     recorder,
-		chainParams:  chainParams,
-		thresholds:   NewValidationThresholdResolver(br, ValidationThresholdCacheTTL),
-	}
-}
-
-func (v *ValidationAdapter) Validate(ctx context.Context, req devshard.ValidateRequest) (*devshard.ValidateResult, error) {
-	return ValidateInferenceWithExecutor(
-		ctx,
-		req,
-		v.httpClient,
-		v.bridge,
-		v.recorder,
-		req.EpochID,
-		devshard.LegacySessionPayloadPath(req.EscrowID),
-		v.executeMLRequest,
-		"devshard",
-		v.chainParams,
-		v.thresholds,
-	)
-}
-
-func (v *ValidationAdapter) executeMLRequest(ctx context.Context, model string, body []byte) (*http.Response, error) {
-	lastReason := observability.ReasonAcquireErr
-	resp, err := broker.DoWithLockedNodeHTTPRetry(v.broker, model, nil, 3,
-		func(node *broker.Node) (*http.Response, *broker.ActionError) {
-			url := node.InferenceUrlWithVersion(v.nodeVersion) + "/v1/chat/completions"
-			started := time.Now()
-			httpReq, reqErr := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
-			if reqErr != nil {
-				lastReason = observability.ReasonApplicationErr
-				observability.IncMLNodeAttempt(observability.PathValidate, lastReason, node.Id)
-				return nil, broker.NewApplicationActionError(reqErr)
-			}
-			httpReq.Header.Set("Content-Type", "application/json")
-			observability.InjectRequestContext(ctx, httpReq.Header)
-			observability.AttachRequestID(httpReq)
-			httpResp, postErr := v.httpClient.Do(httpReq)
-			if postErr == nil {
-				observability.ObserveMLNodeCall(observability.PathValidate, node.Id, observability.MetricPhaseTotal, started)
-			}
-			lastReason = observability.ClassifyMLNodeHTTP(httpResp, postErr, ctx.Err())
-			observability.IncMLNodeAttempt(observability.PathValidate, lastReason, node.Id)
-			if postErr != nil {
-				return nil, broker.NewTransportActionError(postErr)
-			}
-			return httpResp, nil
-		},
-	)
-	if err != nil {
-		if lastReason == observability.ReasonOK {
-			lastReason = observability.ReasonTransportErr
-		}
-		return nil, observability.Classify(lastReason, observability.WhereEngineMLNodeCall, fmt.Errorf("broker validate: %w", err))
-	}
-	return resp, nil
-}
-
-// Compile-time check.
-var _ devshard.ValidationEngine = (*ValidationAdapter)(nil)
diff --git a/decentralized-api/internal/epoch_group_cache.go b/decentralized-api/internal/epoch_group_cache.go
index 247447aeee..3dd06c9ee9 100644
--- a/decentralized-api/internal/epoch_group_cache.go
+++ b/decentralized-api/internal/epoch_group_cache.go
@@ -149,6 +149,8 @@ func (c *EpochGroupDataCache) IsActiveParticipant(ctx context.Context, epochInde
 	return false, nil
 }
 
+
+
 // pruneOldest removes epochs older than currentEpoch - 1
 func (c *EpochGroupDataCache) pruneOldest(currentEpoch uint64) {
 	for epochId := range c.epochCache {
diff --git a/decentralized-api/internal/event_listener/block_observer.go b/decentralized-api/internal/event_listener/block_observer.go
index 9726c05e10..21d852f2e9 100644
--- a/decentralized-api/internal/event_listener/block_observer.go
+++ b/decentralized-api/internal/event_listener/block_observer.go
@@ -15,6 +15,14 @@ import (
 	"github.com/productscience/inference/x/inference/types"
 )
 
+// txEventQueueCapacity bounds the in-memory backlog of synthetic tx events
+// produced by the BlockObserver. When the queue is full, processBlock blocks
+// (applying backpressure to block fetching) instead of letting the backing
+// slice grow without bound and eventually OOM the process. It is sized to
+// comfortably hold several blocks' worth of *relevant* events (irrelevant ones
+// are filtered out before enqueue) while capping worst-case memory.
+const txEventQueueCapacity = 20000
+
 type BlockObserver struct {
 	lastProcessedBlockHeight atomic.Int64
 	lastQueriedBlockHeight   atomic.Int64
@@ -24,6 +32,20 @@ type BlockObserver struct {
 	caughtUp                 atomic.Bool
 	tmClient                 TmHTTPClient
 	notify                   chan struct{}
+	// relevanceFilter, when set, is consulted before enqueuing a synthetic tx
+	// event. Only events for which it returns true are enqueued; this keeps
+	// chain traffic the DAPI has no handler for from consuming queue capacity
+	// and worker time. Barrier events are always enqueued regardless, so block
+	// progress (lastProcessedBlockHeight) still advances for every block.
+	// A nil filter preserves the legacy behavior of enqueuing every event.
+	relevanceFilter func(*chainevents.JSONRPCResponse) bool
+}
+
+// SetRelevanceFilter installs a predicate used to drop irrelevant tx events at
+// the producer before they enter the queue. It must be safe for concurrent use
+// and is expected to be set once during wiring, before Process starts.
+func (bo *BlockObserver) SetRelevanceFilter(filter func(*chainevents.JSONRPCResponse) bool) {
+	bo.relevanceFilter = filter
 }
 
 // TmHTTPClient abstracts the subset of RPC methods we need
@@ -33,7 +55,7 @@ type TmHTTPClient interface {
 }
 
 func NewBlockObserver(manager *apiconfig.ConfigManager) *BlockObserver {
-	queue := NewUnboundedQueue[*chainevents.JSONRPCResponse]()
+	queue := NewBoundedQueue[*chainevents.JSONRPCResponse](txEventQueueCapacity)
 	// Initialize Tendermint RPC client
 	httpClient, err := cosmosclient.NewRpcClient(manager.GetChainNodeConfig().Url)
 	if err != nil {
@@ -64,7 +86,7 @@ func NewBlockObserver(manager *apiconfig.ConfigManager) *BlockObserver {
 
 // NewBlockObserverWithClient allows injecting a custom Tendermint RPC client (used in tests)
 func NewBlockObserverWithClient(manager *apiconfig.ConfigManager, client TmHTTPClient) *BlockObserver {
-	queue := NewUnboundedQueue[*chainevents.JSONRPCResponse]()
+	queue := NewBoundedQueue[*chainevents.JSONRPCResponse](txEventQueueCapacity)
 
 	bo := &BlockObserver{
 		ConfigManager: manager,
@@ -217,10 +239,20 @@ func (bo *BlockObserver) processBlock(ctx context.Context, height int64) bool {
 				Events: events,
 			},
 		}
-		// Enqueue for processing
-		bo.Queue.In <- msg
+		// Drop events the DAPI has no handler for before they consume queue
+		// capacity. The consumer applies the same gate (hasHandler) after
+		// dequeue, so this is behavior-preserving for events that matter.
+		if bo.relevanceFilter != nil && !bo.relevanceFilter(msg) {
+			continue
+		}
+		// Enqueue for processing (blocks under backpressure when the queue is full)
+		if !bo.enqueue(ctx, msg) {
+			return false
+		}
 	}
-	// Enqueue a barrier event to signal block completion when consumed
+	// Always enqueue a barrier event to signal block completion when consumed,
+	// even if every tx event in this block was filtered out. The barrier is how
+	// lastProcessedBlockHeight advances, so it must flow for every observed block.
 	barrier := &chainevents.JSONRPCResponse{
 		JSONRPC: "2.0",
 		ID:      "block-" + strconv.FormatInt(height, 10) + "-barrier",
@@ -230,10 +262,30 @@ func (bo *BlockObserver) processBlock(ctx context.Context, height int64) bool {
 			Events: map[string][]string{"barrier.height": {strconv.FormatInt(height, 10)}},
 		},
 	}
-	bo.Queue.In <- barrier
+	if !bo.enqueue(ctx, barrier) {
+		return false
+	}
 	return true
 }
 
+// enqueue sends an item to the (possibly bounded) queue while honoring context
+// cancellation. Under backpressure the send blocks until a consumer drains an
+// item; selecting on ctx.Done() ensures a backpressured producer can still shut
+// down cleanly instead of deadlocking on a full queue during teardown.
+//
+// Returning false means the item was not enqueued (context cancelled). Callers
+// (processBlock) treat this like a fetch failure: lastQueriedBlockHeight is not
+// advanced, so the block is retried on the next run and no progress is recorded
+// for a partially-enqueued block.
+func (bo *BlockObserver) enqueue(ctx context.Context, msg *chainevents.JSONRPCResponse) bool {
+	select {
+	case bo.Queue.In <- msg:
+		return true
+	case <-ctx.Done():
+		return false
+	}
+}
+
 // signalAllEventsRead is called once the barrier event for a block
 // has been consumed by a worker, meaning all prior events for that block
 // were dequeued. We can now safely advance lastProcessed height.
diff --git a/decentralized-api/internal/event_listener/event_listener.go b/decentralized-api/internal/event_listener/event_listener.go
index 0ce5f020c9..2a440db8ae 100644
--- a/decentralized-api/internal/event_listener/event_listener.go
+++ b/decentralized-api/internal/event_listener/event_listener.go
@@ -116,6 +116,14 @@ func NewEventListener(
 	for _, opt := range opts {
 		opt(el)
 	}
+
+	// Filter out tx events the DAPI has no handler for at the producer, before
+	// they take a slot in the bounded tx queue. This uses the exact same gate
+	// (hasHandler) the consumer applies after dequeue, so it never drops an
+	// event that would have been handled. Barrier events bypass this filter in
+	// processBlock, so per-block progress still advances.
+	bo.SetRelevanceFilter(el.hasHandler)
+
 	return el
 }
 
diff --git a/decentralized-api/internal/event_listener/integration_test.go b/decentralized-api/internal/event_listener/integration_test.go
index 46beac4894..24d1327fb9 100644
--- a/decentralized-api/internal/event_listener/integration_test.go
+++ b/decentralized-api/internal/event_listener/integration_test.go
@@ -54,6 +54,8 @@ type MockOffChainValidator struct{}
 
 func (m *MockOffChainValidator) ValidateAll(pocStartBlockHeight int64, pocStartBlockHash string) {}
 
+func (m *MockOffChainValidator) MaybeCaptureEarlyShare(epochState chainphase.EpochState) {}
+
 type MockOrchestratorChainBridge struct {
 }
 
diff --git a/decentralized-api/internal/event_listener/new_block_dispatcher.go b/decentralized-api/internal/event_listener/new_block_dispatcher.go
index 8691bfd8ac..fd292c7bc1 100644
--- a/decentralized-api/internal/event_listener/new_block_dispatcher.go
+++ b/decentralized-api/internal/event_listener/new_block_dispatcher.go
@@ -38,6 +38,10 @@ type SetHeightFunc func(blockHeight int64) error
 
 type pocValidator interface {
 	ValidateAll(pocStageStartBlockHeight int64, pocStartBlockHash string)
+	// MaybeCaptureEarlyShare is invoked once per synced block to let the
+	// early-share guard capture the early on-chain commitment near the
+	// first-fraction boundary of the active PoC/CPoC generation window.
+	MaybeCaptureEarlyShare(epochState chainphase.EpochState)
 }
 
 // PoCParams contains Proof of Compute parameters
@@ -376,6 +380,13 @@ func (d *OnNewBlockDispatcher) handlePhaseTransitions(epochState chainphase.Epoc
 		return
 	}
 
+	// Early-share guard: between PoC start and end, capture the early on-chain
+	// commitments at the exact first-fraction height of the PoC/CPoC generation
+	// window (no-op when the guard is disabled or this block is not that height).
+	// Same exact-match form as the surrounding stage transitions; a missed height
+	// fails open for the stage.
+	d.offChainValidator.MaybeCaptureEarlyShare(epochState)
+
 	// Check for PoC validation stage transitions
 	if epochContext.IsEndOfPoCStage(blockHeight) {
 		logging.Info("DapiStage:IsEndOfPoCStage. Calling MoveToValidationStage", types.Stages,
diff --git a/decentralized-api/internal/event_listener/unbounded_queue.go b/decentralized-api/internal/event_listener/unbounded_queue.go
index 584041e95a..818f1db7f8 100644
--- a/decentralized-api/internal/event_listener/unbounded_queue.go
+++ b/decentralized-api/internal/event_listener/unbounded_queue.go
@@ -4,8 +4,15 @@ import (
 	"sync"
 )
 
-// UnboundedQueue[T] represents an unbounded thread-safe FIFO queue
-// that exposes channels for enqueuing and dequeuing elements of type T
+// UnboundedQueue[T] represents a thread-safe FIFO queue that exposes channels
+// for enqueuing and dequeuing elements of type T.
+//
+// By default the queue is unbounded (see NewUnboundedQueue). When constructed
+// with NewBoundedQueue it instead enforces a maximum number of buffered items
+// and applies backpressure to producers: a send on In blocks once the queue is
+// full, rather than letting the internal backing slice grow without bound. The
+// In/Out channel API, FIFO ordering, and Close semantics are identical in both
+// modes, so callers do not need to change how they use the queue.
 type UnboundedQueue[T any] struct {
 	// Public channels for interacting with the queue
 	In  chan<- T // Send-only channel for producers
@@ -17,20 +24,43 @@ type UnboundedQueue[T any] struct {
 	done      chan struct{}
 	wg        sync.WaitGroup
 	closeOnce sync.Once // Ensures Close is only executed once
+	capacity  int       // 0 = unbounded; >0 = max buffered items before producers block
 }
 
 // NewUnboundedQueue creates a new unbounded queue that exposes channels
 func NewUnboundedQueue[T any]() *UnboundedQueue[T] {
+	return newQueue[T](0)
+}
+
+// NewBoundedQueue creates a FIFO queue that applies backpressure to producers
+// once `capacity` items are buffered. It preserves the same In/Out channel API
+// and ordering guarantees as NewUnboundedQueue; the only behavioral difference
+// is that a send on In blocks while the queue is full instead of the backing
+// store growing without bound. A capacity <= 0 is treated as unbounded.
+//
+// Note: because the internal input channel is buffered for performance, the
+// effective worst-case number of in-flight items is approximately
+// capacity + len(input buffer) + len(output buffer); the bound is intended to
+// cap memory, not to be an exact admission-control limit.
+func NewBoundedQueue[T any](capacity int) *UnboundedQueue[T] {
+	if capacity < 0 {
+		capacity = 0
+	}
+	return newQueue[T](capacity)
+}
+
+func newQueue[T any](capacity int) *UnboundedQueue[T] {
 	input := make(chan T, 100)  // Buffer size is just for performance
 	output := make(chan T, 100) // Buffer size is just for performance
 	done := make(chan struct{})
 
 	q := &UnboundedQueue[T]{
-		In:     input,  // Public producer channel (send-only)
-		Out:    output, // Public consumer channel (receive-only)
-		input:  input,  // Private full access
-		output: output, // Private full access
-		done:   done,
+		In:       input,  // Public producer channel (send-only)
+		Out:      output, // Public consumer channel (receive-only)
+		input:    input,  // Private full access
+		output:   output, // Private full access
+		done:     done,
+		capacity: capacity,
 	}
 
 	q.wg.Add(1)
@@ -58,8 +88,18 @@ func (q *UnboundedQueue[T]) manage() {
 			first = items[0]
 		}
 
+		// Backpressure: when the queue is bounded and full, stop reading from
+		// the input channel. Producers then block on their send to In until a
+		// consumer drains an item. We keep `out` active so consumers can always
+		// make progress and relieve the pressure (so this never deadlocks as
+		// long as some consumer keeps draining).
+		in := q.input
+		if q.capacity > 0 && len(items) >= q.capacity {
+			in = nil
+		}
+
 		select {
-		case item := <-q.input:
+		case item := <-in:
 			// Store new item from producer
 			items = append(items, item)
 
diff --git a/decentralized-api/internal/event_listener/unbounded_queue_test.go b/decentralized-api/internal/event_listener/unbounded_queue_test.go
index 4a4eb2c15b..3dcf693842 100644
--- a/decentralized-api/internal/event_listener/unbounded_queue_test.go
+++ b/decentralized-api/internal/event_listener/unbounded_queue_test.go
@@ -41,6 +41,49 @@ func TestBasicQueueOperations(t *testing.T) {
 	}
 }
 
+// TestBoundedQueueBackpressureNoDropOrReorder verifies that a bounded queue
+// applies backpressure (a fast producer with a slow consumer never deadlocks
+// and never grows without bound) while still delivering every item exactly
+// once and in FIFO order. This is the core safety property the tx-event queue
+// relies on to avoid the unbounded-memory OOM.
+func TestBoundedQueueBackpressureNoDropOrReorder(t *testing.T) {
+	const capacity = 8
+	q := NewBoundedQueue[int](capacity)
+	defer q.Close()
+
+	const itemCount = 2000
+
+	produceDone := make(chan struct{})
+	go func() {
+		defer close(produceDone)
+		for i := 0; i < itemCount; i++ {
+			q.In <- i // blocks under backpressure once the queue is full
+		}
+	}()
+
+	deadline := time.After(10 * time.Second)
+	for i := 0; i < itemCount; i++ {
+		// Deliberately lag the consumer so the producer must block.
+		if i%100 == 0 {
+			time.Sleep(time.Millisecond)
+		}
+		select {
+		case <-deadline:
+			t.Fatalf("timed out (possible deadlock) after receiving %d/%d items", i, itemCount)
+		case v := <-q.Out:
+			if v != i {
+				t.Fatalf("FIFO violation: expected %d, got %d", i, v)
+			}
+		}
+	}
+
+	select {
+	case <-produceDone:
+	case <-time.After(time.Second):
+		t.Fatal("producer did not finish after all items were consumed")
+	}
+}
+
 // TestQueueClosing verifies that the queue closes properly
 func TestQueueClosing(t *testing.T) {
 	q := NewUnboundedQueue[int]()
diff --git a/decentralized-api/internal/server/admin/bls_handlers.go b/decentralized-api/internal/server/admin/bls_handlers.go
index 4b2b86c8df..a6985a8f70 100644
--- a/decentralized-api/internal/server/admin/bls_handlers.go
+++ b/decentralized-api/internal/server/admin/bls_handlers.go
@@ -1,71 +1,15 @@
 package admin
 
 import (
-	"encoding/json"
-	"fmt"
 	"net/http"
-	"strconv"
 
 	"github.com/labstack/echo/v4"
-	"github.com/productscience/inference/x/bls/types"
 )
 
-// FlexibleUint64 handles both string and number JSON inputs
-type FlexibleUint64 uint64
-
-func (f *FlexibleUint64) UnmarshalJSON(data []byte) error {
-	// Try to unmarshal as a number first
-	var num uint64
-	if err := json.Unmarshal(data, &num); err == nil {
-		*f = FlexibleUint64(num)
-		return nil
-	}
-
-	// If that fails, try as a string
-	var str string
-	if err := json.Unmarshal(data, &str); err != nil {
-		return fmt.Errorf("current_epoch_id must be a number or string, got %s", data)
-	}
-
-	// Convert string to uint64
-	num, err := strconv.ParseUint(str, 10, 64)
-	if err != nil {
-		return fmt.Errorf("current_epoch_id string is not a valid number: %s", str)
-	}
-
-	*f = FlexibleUint64(num)
-	return nil
-}
-
-func (f FlexibleUint64) ToUint64() uint64 {
-	return uint64(f)
-}
-
-type RequestThresholdSignatureDto struct {
-	CurrentEpochId FlexibleUint64 `json:"current_epoch_id"`
-	ChainId        []byte         `json:"chain_id"`
-	RequestId      []byte         `json:"request_id"`
-	Data           [][]byte       `json:"data"`
-}
-
-func (s *Server) postRequestThresholdSignature(c echo.Context) error {
-	var body RequestThresholdSignatureDto
-	if err := c.Bind(&body); err != nil {
-		return echo.NewHTTPError(http.StatusBadRequest, err)
-	}
-
-	msg := &types.MsgRequestThresholdSignature{
-		Creator:        s.recorder.GetAccountAddress(),
-		CurrentEpochId: body.CurrentEpochId.ToUint64(),
-		ChainId:        body.ChainId,
-		RequestId:      body.RequestId,
-		Data:           body.Data,
-	}
-
-	_, err := s.recorder.SendTransactionAsyncNoRetry(msg)
-	if err != nil {
-		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to send transaction: "+err.Error())
-	}
-
-	return c.NoContent(http.StatusOK)
+func blsRequestDeprecated(c echo.Context) error {
+	c.Response().Header().Set("Deprecation", "true")
+	return c.JSON(http.StatusGone, map[string]string{
+		"error":   "deprecated",
+		"message": "admin bls request is deprecated",
+	})
 }
diff --git a/decentralized-api/internal/server/admin/bridge_handlers.go b/decentralized-api/internal/server/admin/bridge_handlers.go
index aadee7284b..07a1543c73 100644
--- a/decentralized-api/internal/server/admin/bridge_handlers.go
+++ b/decentralized-api/internal/server/admin/bridge_handlers.go
@@ -1,8 +1,10 @@
 package admin
 
 import (
+	"errors"
 	"io"
 	"log/slog"
+	"net/http"
 	"strings"
 
 	pserver "decentralized-api/internal/server/public"
@@ -43,15 +45,28 @@ func (s *Server) postBridgeBlock(c echo.Context) error {
 		"receiptsRoot", blockData.ReceiptsRoot,
 		"receiptsCount", len(blockData.Receipts))
 
-	// Add the block to the shared queue
-	blockNumber := s.blockQueue.AddBlock(blockData)
-
-	// Return success response
-	return c.JSON(200, map[string]interface{}{
-		"status":        "success",
-		"message":       "Block queued for processing",
-		"blockNumber":   blockNumber,
-		"receiptsCount": len(blockData.Receipts),
-		"queueSize":     len(s.blockQueue.GetPendingBlocks()),
-	})
+	// The POST is a receipt-ACK, not a commit report. AddBlock returns an error
+	// ONLY when the block could not be accepted into the queue:
+	//   - ErrBridgeQueueFull -> 503 back-pressure (Geth's sendRangeDirectly stops
+	//     and resends later; nothing is dropped),
+	//   - any other error -> 400 (malformed / unexpected input).
+	// Otherwise the block is received (buffered/duplicate/bootstrapping) -> 200.
+	// Commit success/failure is owned by the drain and never reported here.
+	blockNumber, err := s.blockQueue.AddBlock(blockData)
+	switch {
+	case err == nil:
+		return c.JSON(http.StatusOK, map[string]interface{}{
+			"status":        "received",
+			"message":       "Block received",
+			"blockNumber":   blockNumber,
+			"receiptsCount": len(blockData.Receipts),
+			"queueSize":     len(s.blockQueue.GetPendingBlocks()),
+		})
+	case errors.Is(err, pserver.ErrBridgeQueueFull):
+		slog.Warn("Bridge: back-pressure, rejecting block", "blockNumber", blockData.BlockNumber, "error", err)
+		return c.JSON(http.StatusServiceUnavailable, map[string]string{"error": err.Error()})
+	default:
+		slog.Error("Bridge: malformed/unexpected block", "blockNumber", blockData.BlockNumber, "error", err)
+		return c.JSON(http.StatusBadRequest, map[string]string{"error": err.Error()})
+	}
 }
diff --git a/decentralized-api/internal/server/admin/server.go b/decentralized-api/internal/server/admin/server.go
index 55b378da97..141b94544d 100644
--- a/decentralized-api/internal/server/admin/server.go
+++ b/decentralized-api/internal/server/admin/server.go
@@ -8,6 +8,8 @@ import (
 	pserver "decentralized-api/internal/server/public"
 	"decentralized-api/internal/validation"
 	"decentralized-api/payloadstorage"
+	"net/http"
+	_ "net/http/pprof"
 
 	"cosmossdk.io/x/feegrant"
 	upgradetypes "cosmossdk.io/x/upgrade/types"
@@ -59,6 +61,7 @@ func NewServer(
 	}
 
 	e.Use(middleware.LoggingMiddleware)
+	e.Any("/debug/pprof/*", echo.WrapHandler(http.DefaultServeMux))
 	g := e.Group("/admin/v1/")
 
 	g.POST("nodes", s.createNewNode)
@@ -78,7 +81,7 @@ func NewServer(
 	g.POST("models", s.registerModel)
 	g.POST("tx/send", s.sendTransaction)
 
-	g.POST("bls/request", s.postRequestThresholdSignature)
+	g.POST("bls/request", blsRequestDeprecated)
 
 	// Export DB state (human-readable JSON) for admin purposes
 	g.GET("export/db", s.exportDb)
diff --git a/decentralized-api/internal/server/admin/setup_report.go b/decentralized-api/internal/server/admin/setup_report.go
index 532cba2091..cfe7ca0a37 100644
--- a/decentralized-api/internal/server/admin/setup_report.go
+++ b/decentralized-api/internal/server/admin/setup_report.go
@@ -246,7 +246,12 @@ func (s *Server) checkPermissions(ctx context.Context) Check {
 	warmKeyAddr := s.recorder.GetSignerAddress()
 
 	authzQueryClient := authztypes.NewQueryClient(s.recorder.GetClientContext())
-	grantsResp, err := authzQueryClient.GranteeGrants(ctx, &authztypes.QueryGranteeGrantsRequest{
+	// Query only the cold->warm pair. GranteeGrants scans the entire authz store
+	// (grants are keyed granter-first) and trips the node's query-gas-limit on a
+	// populated chain; Grants(granter,grantee) prefix-scans just this pair. Cf. the
+	// keeper's HasWarmKeyGrant.
+	grantsResp, err := authzQueryClient.Grants(ctx, &authztypes.QueryGrantsRequest{
+		Granter: coldKeyAddr,
 		Grantee: warmKeyAddr,
 	})
 
@@ -258,16 +263,14 @@ func (s *Server) checkPermissions(ctx context.Context) Check {
 		}
 	}
 
-	grantedFromColdKey := make(map[string]*authztypes.GrantAuthorization)
+	grantedFromColdKey := make(map[string]*authztypes.Grant)
 	for _, grant := range grantsResp.Grants {
-		if grant.Granter == coldKeyAddr {
-			var authorization authztypes.Authorization
-			if err := s.cdc.UnpackAny(grant.Authorization, &authorization); err != nil {
-				continue
-			}
-			if genericAuth, ok := authorization.(*authztypes.GenericAuthorization); ok {
-				grantedFromColdKey[genericAuth.Msg] = grant
-			}
+		var authorization authztypes.Authorization
+		if err := s.cdc.UnpackAny(grant.Authorization, &authorization); err != nil {
+			continue
+		}
+		if genericAuth, ok := authorization.(*authztypes.GenericAuthorization); ok {
+			grantedFromColdKey[genericAuth.Msg] = grant
 		}
 	}
 
diff --git a/decentralized-api/internal/server/public/app_info_handlers.go b/decentralized-api/internal/server/public/app_info_handlers.go
index 0eb80a7e01..9dd669f5f8 100644
--- a/decentralized-api/internal/server/public/app_info_handlers.go
+++ b/decentralized-api/internal/server/public/app_info_handlers.go
@@ -2,36 +2,125 @@ package public
 
 import (
 	"decentralized-api/logging"
+	"net/http"
+	"sync"
+	"time"
+
 	"github.com/cosmos/cosmos-sdk/client/grpc/cmtservice"
 	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/labstack/echo/v4"
 	"github.com/productscience/inference/x/inference/types"
-	"net/http"
-	"time"
 )
 
+const versionsCacheTTL = 5 * time.Minute
+
+type mlnodeVersionResponse struct {
+	NodeID                 string `json:"node_id"`
+	Version                string `json:"version"`
+	PoCValidationInference bool   `json:"poc_validation_inference"`
+}
+
+type versionsResponse struct {
+	Timestamp   string                  `json:"timestamp"`
+	APIVersion  map[string]string       `json:"api_version"`
+	NodeVersion map[string]string       `json:"node_version"`
+	MLNodes     []mlnodeVersionResponse `json:"mlnodes"`
+}
+
+type versionsCache struct {
+	mu        sync.RWMutex
+	response  *versionsResponse
+	expiresAt time.Time
+	cacheTTL  time.Duration
+}
+
+func newVersionsCache() *versionsCache {
+	return &versionsCache{
+		cacheTTL: versionsCacheTTL,
+	}
+}
+
+func (c *versionsCache) get() (*versionsResponse, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	if c.response == nil || time.Now().After(c.expiresAt) {
+		return nil, false
+	}
+
+	return c.response, true
+}
+
 func (s *Server) getVersions(ctx echo.Context) error {
-	cometClient := s.recorder.NewCometQueryClient()
-	resp, err := cometClient.GetNodeInfo(s.recorder.GetContext(), &cmtservice.GetNodeInfoRequest{})
+	if cached, valid := s.versionsCache.get(); valid {
+		return ctx.JSON(http.StatusOK, cached)
+	}
+
+	response, err := s.getOrGenerateVersionsResponse()
 	if err != nil {
-		logging.Error("Failed to get node info from cosmos node", types.Server, "error", err)
 		return ctx.JSON(http.StatusInternalServerError, map[string]string{
 			"error": "failed to get node info",
 		})
 	}
+
+	return ctx.JSON(http.StatusOK, response)
+}
+
+func (s *Server) getOrGenerateVersionsResponse() (*versionsResponse, error) {
+	s.versionsCache.mu.Lock()
+	defer s.versionsCache.mu.Unlock()
+
+	if s.versionsCache.response != nil && time.Now().Before(s.versionsCache.expiresAt) {
+		return s.versionsCache.response, nil
+	}
+
+	response, err := s.generateVersionsResponse()
+	if err != nil {
+		return nil, err
+	}
+
+	s.versionsCache.response = response
+	s.versionsCache.expiresAt = time.Now().Add(s.versionsCache.cacheTTL)
+
+	return response, nil
+}
+
+func (s *Server) generateVersionsResponse() (*versionsResponse, error) {
+	cometClient := s.recorder.NewCometQueryClient()
+	resp, err := cometClient.GetNodeInfo(s.recorder.GetContext(), &cmtservice.GetNodeInfoRequest{})
+	if err != nil {
+		logging.Error("Failed to get node info from cosmos node", types.Server, "error", err)
+		return nil, err
+	}
 	nodeVersion := resp.ApplicationVersion
 
-	return ctx.JSON(http.StatusOK, map[string]any{
-		"timestamp": time.Now().UTC().Format(time.RFC3339),
-		"api_version": map[string]string{
+	mlnodes := make([]mlnodeVersionResponse, 0)
+	if s.nodeBroker != nil {
+		if nodes, nerr := s.nodeBroker.GetNodes(); nerr != nil {
+			logging.Error("Failed to list ML nodes for /v1/versions", types.Server, "error", nerr)
+		} else {
+			for _, nodeResp := range nodes {
+				mlnodes = append(mlnodes, mlnodeVersionResponse{
+					NodeID:                 nodeResp.Node.Id,
+					Version:                nodeResp.State.MlNodeVersion,
+					PoCValidationInference: nodeResp.State.PoCValidationInference,
+				})
+			}
+		}
+	}
+
+	return &versionsResponse{
+		Timestamp: time.Now().UTC().Format(time.RFC3339),
+		APIVersion: map[string]string{
 			"application_name": version.AppName,
 			"version":          version.Version,
 			"commit":           version.Commit,
 		},
-		"node_version": map[string]string{
+		NodeVersion: map[string]string{
 			"application_name": nodeVersion.Name,
 			"version":          nodeVersion.Version,
 			"commit":           nodeVersion.GitCommit,
 		},
-	})
+		MLNodes: mlnodes,
+	}, nil
 }
diff --git a/decentralized-api/internal/server/public/bridge_handlers.go b/decentralized-api/internal/server/public/bridge_handlers.go
index 202765902f..8134bd9e73 100644
--- a/decentralized-api/internal/server/public/bridge_handlers.go
+++ b/decentralized-api/internal/server/public/bridge_handlers.go
@@ -1,11 +1,15 @@
 package public
 
 import (
+	"context"
+	"database/sql"
+	"decentralized-api/apiconfig"
 	"decentralized-api/cosmosclient"
 	cosmos_client "decentralized-api/cosmosclient"
+	"decentralized-api/internal"
+	"errors"
 
 	"fmt"
-	"io"
 	"log/slog"
 	"net/http"
 	"sort"
@@ -18,16 +22,50 @@ import (
 	"github.com/productscience/inference/x/inference/types"
 )
 
-// BlockQueue manages a queue of blocks to be processed
+// ErrBridgeQueueFull is the single sentinel that signals back-pressure: the
+// per-chain out-of-order buffer is full, so the block cannot be accepted right
+// now. The admin POST handler maps ONLY this error to HTTP 503 so Geth's
+// sendRangeDirectly stops and resends later; no block is ever dropped while
+// reporting success.
+var ErrBridgeQueueFull = errors.New("Bridge: Queue is full")
+
+// Bridge commit-confirmation tuning. Confirmation is an index-independent
+// module-state poll via the already-deployed BridgeTransaction query (no chain
+// upgrade required), bounded so the drain never blocks forever on a receipt that
+// is not (yet) recorded; on deadline the block is left in the queue and retried
+// on the next POST.
+const (
+	bridgeConfirmTimeout      = 60 * time.Second
+	bridgeConfirmPollInterval = 2 * time.Second
+)
+
+// minBlocksToBootstrap is the number of blocks we buffer on a fresh (uninitialized)
+// chain before sorting and choosing the minimum block number as the bootstrap origin.
+// Buffering protects against network latency delivering a higher block before the
+// lowest one (which would otherwise be permanently discarded as a duplicate).
+const minBlocksToBootstrap = 6
+
+// maxBufferedBlocksPerChain bounds the number of out-of-order blocks buffered per
+// chain (M3). It prevents unbounded memory growth if latest+1 never arrives (deep
+// gap or a withheld block). Sized well above the bootstrap threshold and the
+// realistic in-flight segment depth.
+const maxBufferedBlocksPerChain = 10000
+
+// BridgeQueue manages an in-memory queue of blocks processed synchronously and in
+// strict sequential order per chain. Blocks are committed to the Cosmos chain inside
+// the HTTP request thread (no background workers); progress is mirrored to SQLite so
+// the node bootstraps cleanly after restarts.
 type BridgeQueue struct {
-	pendingBlocks             map[string]*BridgeBlock // Key is blockNumber
-	lock                      sync.RWMutex
-	minBlocksBeforeProcessing int // Minimum number of blocks needed before starting processing
-	recorder                  cosmosclient.CosmosMessageClient
-	processCh                 chan struct{} // Channel to signal processing is needed
+	pendingBlocks map[string]*BridgeBlock // Key: "chain:blockNumber"
+	latestBlocks  map[string]uint64       // Key: "chain" -> latest processed block number (in memory)
+	lock          sync.RWMutex            // Protects both maps (RWMutex: handshake GET reads under RLock)
+	drainMu       sync.Mutex              // Serializes drains; held WITHOUT the data lock during network I/O
+	recorder      cosmosclient.CosmosMessageClient
+	db            *sql.DB
+	epochCache    *internal.EpochGroupDataCache
 }
 
-// PostBlockResponse is returned by postBlock on success
+// PostBlockResponse is returned by the admin POST handler on success.
 type PostBlockResponse struct {
 	Status        string `json:"status"`
 	Message       string `json:"message"`
@@ -36,72 +74,235 @@ type PostBlockResponse struct {
 	QueueSize     int    `json:"queueSize"`
 }
 
-// BridgeStatusResponse represents the current status of the bridge queue
+// BridgeStatusResponse represents the current status of the bridge queue.
 type BridgeStatusResponse struct {
-	PendingBlocksCount        int            `json:"pendingBlocksCount"`
-	PendingReceiptsCount      int            `json:"pendingReceiptsCount"`
-	BlockCountByNumber        map[string]int `json:"blockCountByNumber"`
-	EarliestBlockNumber       uint64         `json:"earliestBlockNumber"`
-	LatestBlockNumber         uint64         `json:"latestBlockNumber"`
-	ReadyToProcess            bool           `json:"readyToProcess"`
-	MinBlocksBeforeProcessing int            `json:"minBlocksBeforeProcessing"`
+	PendingBlocksCount   int            `json:"pendingBlocksCount"`
+	PendingReceiptsCount int            `json:"pendingReceiptsCount"`
+	BlockCountByNumber   map[string]int `json:"blockCountByNumber"`
+	EarliestBlockNumber  uint64         `json:"earliestBlockNumber"`
+	LatestBlockNumber    uint64         `json:"latestBlockNumber"`
 }
 
-// BridgeAddressesResponse returns bridge contract addresses for a chain
+// BridgeAddressesResponse returns bridge contract addresses for a chain.
 type BridgeAddressesResponse struct {
 	ChainName string   `json:"chain_name"`
 	ChainID   string   `json:"chain_id"`
 	Addresses []string `json:"addresses"`
 }
 
-// NewBlockQueue creates a new queue for blocks with receipts
-func NewBlockQueue(recorder cosmosclient.CosmosMessageClient) *BridgeQueue {
-	queue := &BridgeQueue{
-		pendingBlocks:             make(map[string]*BridgeBlock),
-		minBlocksBeforeProcessing: 6,
-		recorder:                  recorder,
-		processCh:                 make(chan struct{}, 1), // Buffered channel to prevent blocking
+// LatestBridgeBlockResponse is the handshake payload served by GET /v1/bridge/block/latest.
+type LatestBridgeBlockResponse struct {
+	ChainId     string `json:"chainId"`
+	BlockNumber uint64 `json:"blockNumber"`
+}
+
+// NewBlockQueue creates a new queue for blocks with receipts. The latest processed
+// block numbers per chain are loaded once from SQLite at startup into the in-memory
+// latestBlocks map, so subsequent duplicate/out-of-order checks never touch disk.
+// The epoch cache is created internally from the recorder; it provides O(1) cached
+// active-participant checks so the drain skips receipts while the validator is not
+// in the active set (preventing queue stalls and unnecessary Cosmos broadcasts).
+func NewBlockQueue(recorder cosmosclient.CosmosMessageClient, db *sql.DB) *BridgeQueue {
+	q := &BridgeQueue{
+		pendingBlocks: make(map[string]*BridgeBlock),
+		latestBlocks:  make(map[string]uint64),
+		recorder:      recorder,
+		db:            db,
+		epochCache:    internal.NewEpochGroupDataCache(recorder),
+	}
+
+	// Load persisted bridge states from SQLite once on startup.
+	if db != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		states, err := apiconfig.LoadAllBridgeLatestBlocks(ctx, db)
+		if err != nil {
+			slog.Error("Bridge: Failed to load bridge states at startup", "err", err)
+		} else {
+			q.latestBlocks = states
+			slog.Info("Bridge: Loaded bridge states at startup", "states", states)
+		}
 	}
 
-	// Start the queue processor
-	go queue.init()
+	return q
+}
+
+// GetLatestBlock returns the latest processed block for a chain (handshake read
+// path). It is the only safe way for the public GET handler to read latestBlocks,
+// which the admin POST handler writes concurrently.
+func (q *BridgeQueue) GetLatestBlock(chain string) (uint64, bool) {
+	q.lock.RLock()
+	defer q.lock.RUnlock()
+	v, ok := q.latestBlocks[chain]
+	return v, ok
+}
 
-	return queue
+// AddBlock is a receipt-ACK: it accepts a block into the queue (ACCEPT phase,
+// under the data lock) and then triggers the drain (DRAIN phase, under drainMu
+// with NO data lock held during network I/O). The returned error means ONLY that
+// the block could not be accepted:
+//   - malformed input (block-number parse / bootstrap persistence failure), or
+//   - back-pressure (ErrBridgeQueueFull, buffer full).
+//
+// Every received outcome (buffered, duplicate, bootstrapping) returns
+// (blockNumber, nil). Commit success/failure is NOT reported through this call;
+// it is owned by the drain, which advances `latest` only after every receipt of a
+// block is confirmed recorded on-chain.
+func (q *BridgeQueue) AddBlock(block BridgeBlock) (string, error) {
+	if err := q.accept(block); err != nil {
+		return "", err
+	}
+	q.drain(block.OriginChain)
+	return block.BlockNumber, nil
 }
 
-// AddBlock adds a block to the queue
-func (q *BridgeQueue) AddBlock(block BridgeBlock) string {
+// accept performs the ACCEPT phase under the data lock only: parse/validate,
+// bootstrap, dedup, buffer, and back-pressure. It performs NO network I/O. The
+// only quick disk write here is the bootstrap origin commit (SQLite), which is
+// not network I/O and must be consistent with the in-memory bootstrap value.
+func (q *BridgeQueue) accept(block BridgeBlock) error {
 	q.lock.Lock()
 	defer q.lock.Unlock()
 
-	// Check if block already exists
-	if _, exists := q.pendingBlocks[block.BlockNumber]; exists {
-		slog.Info("Block already in queue", "blockNumber", block.BlockNumber)
-		return block.BlockNumber
+	blockNum, err := strconv.ParseUint(block.BlockNumber, 10, 64)
+	if err != nil {
+		return fmt.Errorf("Bridge: Invalid block number %q: %w", block.BlockNumber, err)
 	}
 
-	q.pendingBlocks[block.BlockNumber] = &block
+	latest, exists := q.latestBlocks[block.OriginChain]
+
+	// Case A: Uninitialized chain (bootstrapping / first run).
+	if !exists {
+		key := fmt.Sprintf("%s:%d", block.OriginChain, blockNum)
+		q.pendingBlocks[key] = &block
+		slog.Info("Bridge: Buffered block during bootstrapping", "chain", block.OriginChain, "block", blockNum)
+
+		// Count buffered blocks for this chain.
+		var chainBlocks []uint64
+		for _, pBlock := range q.pendingBlocks {
+			if pBlock.OriginChain == block.OriginChain {
+				if val, err := strconv.ParseUint(pBlock.BlockNumber, 10, 64); err == nil {
+					chainBlocks = append(chainBlocks, val)
+				}
+			}
+		}
 
-	slog.Info("Bridge queue: Added block as pending",
-		"blockNumber", block.BlockNumber,
-		"originChain", block.OriginChain,
-		"receiptsCount", len(block.Receipts),
-		"queueLength", len(q.pendingBlocks))
+		// Wait until we have enough blocks to establish correct ordering.
+		if len(chainBlocks) < minBlocksToBootstrap {
+			slog.Info("Bridge: Awaiting more blocks to bootstrap bridge state",
+				"chain", block.OriginChain, "count", len(chainBlocks), "target", minBlocksToBootstrap)
+			return nil
+		}
 
-	// Signal processing if we have enough blocks
-	if len(q.pendingBlocks) >= q.minBlocksBeforeProcessing {
-		select {
-		case q.processCh <- struct{}{}:
-			// Signal sent successfully
-		default:
-			// Channel is full, processing is already queued
+		// Sort to find the minimum block number.
+		sort.Slice(chainBlocks, func(i, j int) bool { return chainBlocks[i] < chainBlocks[j] })
+		minBlock := chainBlocks[0]
+
+		// Bootstrap latest to minBlock - 1 (or 0 if minBlock == 0).
+		bootstrapVal := uint64(0)
+		if minBlock > 0 {
+			bootstrapVal = minBlock - 1
+		}
+		slog.Info("Bridge: Bootstrapping bridge state from buffered blocks", "chain", block.OriginChain, "val", bootstrapVal)
+
+		// Commit the bootstrapped origin immediately, BEFORE draining any block.
+		// If the first block (latest+1) later fails to commit, the chain is already
+		// marked initialized at `latest`, so Geth's retry is recognized as latest+1
+		// rather than re-entering the bootstrapping buffer loop.
+		if err := apiconfig.SetBridgeLatestBlock(context.Background(), q.db, block.OriginChain, bootstrapVal); err != nil {
+			return fmt.Errorf("Bridge: failed to bootstrap SQLite state: %w", err)
 		}
+		q.latestBlocks[block.OriginChain] = bootstrapVal
+		// minBlock = latest+1 is already buffered; the drain (started by AddBlock)
+		// will pick it up at latest+1.
+		return nil
 	}
 
-	return block.BlockNumber
+	// Case B: Initialized-chain guards.
+	if blockNum <= latest {
+		slog.Info("Bridge: Discarding duplicate block", "block", blockNum, "latest", latest)
+		return nil
+	}
+	if blockNum > latest+1 {
+		// Out-of-order: enforce the per-chain cap as BACK-PRESSURE (never drop).
+		// A full buffer returns ErrBridgeQueueFull -> 503, so Geth stops and resends
+		// later; back-pressure self-clears as the drain confirms blocks and frees
+		// space. This is the ONLY place this sentinel is returned.
+		if q.countPendingForChain(block.OriginChain) >= maxBufferedBlocksPerChain {
+			return fmt.Errorf("%w: chain=%s pending=%d cap=%d",
+				ErrBridgeQueueFull, block.OriginChain,
+				q.countPendingForChain(block.OriginChain), maxBufferedBlocksPerChain)
+		}
+		key := fmt.Sprintf("%s:%d", block.OriginChain, blockNum)
+		q.pendingBlocks[key] = &block
+		slog.Info("Bridge: Buffered out-of-order block", "block", blockNum, "expected", latest+1)
+		return nil
+	}
+	// Sequential: buffer the incoming block for the unified drain.
+	q.pendingBlocks[fmt.Sprintf("%s:%d", block.OriginChain, blockNum)] = &block
+	return nil
 }
 
-// GetPendingBlocks returns all pending blocks
+// drain commits buffered blocks from latest+1 in strict sequential order. It is
+// serialized by drainMu (one drain at a time) and never holds the data lock
+// across network I/O: the data lock is taken only for quick in-memory reads
+// (peek latest+1) and the advance/delete write. A block whose receipts are not
+// all confirmed is left in the queue and retried on the next POST's drain.
+func (q *BridgeQueue) drain(chain string) {
+	q.drainMu.Lock()
+	defer q.drainMu.Unlock()
+
+	ctx := context.Background()
+	for {
+		// Quick read under the data lock: copy the next block pointer out.
+		q.lock.RLock()
+		latest := q.latestBlocks[chain]
+		key := fmt.Sprintf("%s:%d", chain, latest+1)
+		nextBlock, ok := q.pendingBlocks[key]
+		q.lock.RUnlock()
+		if !ok {
+			return
+		}
+
+		slog.Info("Bridge: Processing sequential block", "chain", chain, "block", nextBlock.BlockNumber)
+
+		// Network I/O with NO lock held: broadcast + confirm each receipt.
+		if err := q.processBlockReceipts(ctx, nextBlock); err != nil {
+			// Not (yet) confirmed on-chain: leave the block buffered, do NOT advance
+			// latest, do NOT surface to the POST. Retried on the next POST's drain.
+			slog.Warn("Bridge: Block not yet committed; leaving in queue",
+				"chain", chain, "block", latest+1, "err", err)
+			return
+		}
+
+		// Quick write under the data lock: advance latest (SQLite + memory) and
+		// delete the committed block.
+		q.lock.Lock()
+		if err := apiconfig.SetBridgeLatestBlock(ctx, q.db, chain, latest+1); err != nil {
+			q.lock.Unlock()
+			slog.Error("Bridge: Failed to persist latest block; not advancing latest pointer",
+				"chain", chain, "block", latest+1, "err", err)
+			return
+		}
+		q.latestBlocks[chain] = latest + 1
+		delete(q.pendingBlocks, key)
+		q.lock.Unlock()
+	}
+}
+
+// countPendingForChain returns the number of buffered blocks for a chain.
+// Caller must hold q.lock.
+func (q *BridgeQueue) countPendingForChain(chain string) int {
+	count := 0
+	for _, pBlock := range q.pendingBlocks {
+		if pBlock.OriginChain == chain {
+			count++
+		}
+	}
+	return count
+}
+
+// GetPendingBlocks returns all pending blocks.
 func (q *BridgeQueue) GetPendingBlocks() []BridgeBlock {
 	q.lock.RLock()
 	defer q.lock.RUnlock()
@@ -120,126 +321,89 @@ func (q *BridgeQueue) GetQueueSize() int {
 	return len(q.pendingBlocks)
 }
 
-// Init sets up the queue processing
-func (q *BridgeQueue) init() {
-	ticker := time.NewTicker(5 * time.Minute) // Process every 5 minutes regardless
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			slog.Info("Bridge queue: Processing blocks due to timeout")
-			q.processBlocks()
-		case <-q.processCh:
-			// Process blocks when minimum threshold is reached
-			slog.Info("Bridge queue: Processing blocks due to minimum threshold reached")
-			q.processBlocks()
-		}
+// checkValidatorActive checks whether the local validator is in the active set
+// for the current epoch. Returns (active, err): active=true means broadcast,
+// active=false+nil means skip & advance, non-nil error means the node can't
+// reach the chain so the drain should pause and retry later.
+func (q *BridgeQueue) checkValidatorActive(ctx context.Context) (bool, error) {
+	queryClient := q.recorder.NewInferenceQueryClient()
+	resp, err := queryClient.GetCurrentEpoch(ctx, &types.QueryGetCurrentEpochRequest{})
+	if err != nil {
+		return false, fmt.Errorf("failed to resolve current epoch: %w", err)
 	}
+	return q.epochCache.IsActiveParticipant(ctx, resp.Epoch, q.recorder.GetAccountAddress())
 }
 
-// processBlocks processes queued blocks in order starting from the earliest
-func (q *BridgeQueue) processBlocks() {
-	for {
-		block, exists := q.getNextBlock()
-		if !exists {
-			break
+// processBlockReceipts commits every receipt in a block. Three outcomes:
+//   - active validator: broadcast + confirm each receipt (normal path).
+//   - not active: skip receipts and advance latest — other validators handle them.
+//   - epoch query error: pause the drain (return error), retry on next POST.
+func (q *BridgeQueue) processBlockReceipts(ctx context.Context, block *BridgeBlock) error {
+	if len(block.Receipts) > 0 {
+		active, err := q.checkValidatorActive(ctx)
+		if err != nil {
+			return fmt.Errorf("Bridge: Cannot determine active status, pausing drain: %w", err)
 		}
-
-		// Process the block and its receipts
-		slog.Info("Processing block",
-			"blockNumber", block.BlockNumber,
-			"originChain", block.OriginChain,
-			"receiptsRoot", block.ReceiptsRoot,
-			"receiptsCount", len(block.Receipts))
-
-		// Process each receipt in the block
-		for _, receipt := range block.Receipts {
-			// Process the receipt with block information
-			q.processReceipt(receipt, block)
+		if !active {
+			slog.Info("Bridge: Validator not active; skipping receipts and advancing",
+				"block", block.BlockNumber,
+				"receipts", len(block.Receipts))
+			return nil
 		}
 	}
-}
-
-// getNextBlock retrieves and removes the earliest block from the queue
-func (q *BridgeQueue) getNextBlock() (BridgeBlock, bool) {
-	q.lock.Lock()
-	defer q.lock.Unlock()
-
-	if len(q.pendingBlocks) == 0 {
-		return BridgeBlock{}, false
-	}
-
-	// Create a slice of all blocks
-	var blocks []struct {
-		blockNumber string
-		block       BridgeBlock
+	for _, receipt := range block.Receipts {
+		if err := q.commitReceipt(ctx, receipt, *block); err != nil {
+			return err
+		}
 	}
+	return nil
+}
 
-	for blockNum, pendingBlock := range q.pendingBlocks {
-		blocks = append(blocks, struct {
-			blockNumber string
-			block       BridgeBlock
-		}{
-			blockNumber: blockNum,
-			block:       *pendingBlock,
-		})
+// commitReceipt sends a receipt optimistically (no pre-check) and then treats an
+// index-independent module-state read as the AUTHORITY for whether it is
+// committed. The chain's "already validated" dedup response is treated as success
+// (so re-sent blocks make forward progress instead of stalling on dedup errors).
+func (q *BridgeQueue) commitReceipt(ctx context.Context, receipt BridgeReceipt, block BridgeBlock) error {
+	msg, err := q.buildBridgeExchangeMsg(receipt, block)
+	if err != nil {
+		return err
 	}
 
-	// Sort blocks by block number (ascending)
-	sort.Slice(blocks, func(i, j int) bool {
-		blockNumI, errI := strconv.ParseUint(blocks[i].blockNumber, 10, 64)
-		blockNumJ, errJ := strconv.ParseUint(blocks[j].blockNumber, 10, 64)
-
-		// If parsing fails, fall back to string comparison
-		if errI != nil || errJ != nil {
-			return blocks[i].blockNumber < blocks[j].blockNumber
-		}
-
-		return blockNumI < blockNumJ
-	})
-
-	// Get the earliest block
-	earliestBlock := blocks[0]
-
-	// Remove it from the queue
-	delete(q.pendingBlocks, earliestBlock.blockNumber)
-
-	slog.Info("Retrieved next block for processing",
-		"blockNumber", earliestBlock.blockNumber,
-		"remainingBlocks", len(q.pendingBlocks))
-
-	return earliestBlock.block, true
-}
-
-// processReceipt handles an individual receipt (similar to previous cosmos processing)
-func (q *BridgeQueue) processReceipt(receipt BridgeReceipt, block BridgeBlock) {
-	// Process the transaction (e.g., create Cosmos transaction)
-	slog.Info("Processing receipt",
+	slog.Info("Bridge: Committing receipt",
 		"chain", block.OriginChain,
 		"contract", receipt.ContractAddress,
-		"owner", receipt.OwnerAddress,
-		"publicKey", receipt.OwnerPubKey,
+		"owner", msg.OwnerAddress,
 		"amount", receipt.Amount,
 		"blockNumber", block.BlockNumber,
 		"receiptIndex", receipt.ReceiptIndex)
 
-	// Derive Cosmos address from public key
+	// 1. Send optimistically. "already recorded by us" is success, not failure;
+	// any other error is uncertain -> stop and retry on the next POST. We do NOT
+	// rely on the broadcast's own nil (broadcastMessage can swallow Code != 0);
+	// the confirmation read below is the authority.
+	if err := q.recorder.BridgeExchange(msg); err != nil && !isAlreadyRecorded(err) {
+		return fmt.Errorf("Bridge: Exchange submit not confirmable: %w", err)
+	}
+
+	// 2. Confirm via index-independent state read (bounded poll).
+	return q.confirmReceiptRecorded(ctx, msg)
+}
+
+// buildBridgeExchangeMsg builds the MsgBridgeExchange for a receipt, deriving the
+// owner's Cosmos address from its public key. The same content fields feed the
+// confirmation query, so the on-chain content hash matches exactly.
+func (q *BridgeQueue) buildBridgeExchangeMsg(receipt BridgeReceipt, block BridgeBlock) (*types.MsgBridgeExchange, error) {
 	cosmosAddress, err := cosmos_client.PubKeyToAddress(receipt.OwnerPubKey)
 	if err != nil {
-		slog.Error("Failed to derive Cosmos address from public key",
-			"error", err,
-			"publicKey", receipt.OwnerPubKey)
-		return
+		return nil, fmt.Errorf("Bridge: Failed to derive Cosmos address from public key %q: %w", receipt.OwnerPubKey, err)
 	}
 
-	// Format the public key with 0x prefix if it doesn't already have it
 	ownerPubKey := receipt.OwnerPubKey
 	if !strings.HasPrefix(ownerPubKey, "0x") {
 		ownerPubKey = "0x" + ownerPubKey
 	}
 
-	msg := &types.MsgBridgeExchange{
+	return &types.MsgBridgeExchange{
 		Validator:       q.recorder.GetAccountAddress(),
 		OriginChain:     block.OriginChain,
 		ContractAddress: receipt.ContractAddress,
@@ -249,129 +413,148 @@ func (q *BridgeQueue) processReceipt(receipt BridgeReceipt, block BridgeBlock) {
 		BlockNumber:     block.BlockNumber,
 		ReceiptIndex:    receipt.ReceiptIndex,
 		ReceiptsRoot:    block.ReceiptsRoot,
-	}
+	}, nil
+}
 
-	err = q.recorder.BridgeExchange(msg)
-	if err != nil {
-		slog.Error("Error processing bridge exchange",
-			"error", err,
-			"blockNumber", block.BlockNumber,
-			"receiptIndex", receipt.ReceiptIndex)
+// confirmReceiptRecorded polls the chain (via the already-deployed, index-
+// independent BridgeTransaction query) until our validator's confirmation for
+// this exact receipt content is present, or a bounded deadline elapses. A
+// deadline is "uncertain" -> the receipt is left uncommitted and retried on the
+// next POST's drain.
+func (q *BridgeQueue) confirmReceiptRecorded(ctx context.Context, msg *types.MsgBridgeExchange) error {
+	deadline := time.Now().Add(bridgeConfirmTimeout)
+	for {
+		recorded, err := q.receiptRecorded(ctx, msg)
+		if err == nil && recorded {
+			return nil
+		}
+		if err != nil {
+			slog.Warn("Bridge: Confirmation query failed; will retry",
+				"blockNumber", msg.BlockNumber, "receiptIndex", msg.ReceiptIndex, "err", err)
+		}
+
+		if time.Now().After(deadline) {
+			return fmt.Errorf("Bridge: Receipt not confirmed within %s: chain=%s block=%s receiptIndex=%s",
+				bridgeConfirmTimeout, msg.OriginChain, msg.BlockNumber, msg.ReceiptIndex)
+		}
+
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(bridgeConfirmPollInterval):
+		}
 	}
 }
 
-// postBlock handles POST requests to submit finalized blocks with optional receipts
-func (s *Server) postBlock(c echo.Context) error {
-	// Debug: Log raw request body
-	rawBody := c.Request().Body
-	bodyBytes, err := io.ReadAll(rawBody)
+// receiptRecorded reports whether our validator's confirmation for this exact
+// receipt content is present in chain state. It uses the existing
+// BridgeTransaction query (filtered by chain/block/receiptIndex) and then matches
+// the remaining content fields, so a conflicting transaction (same receipt
+// location, different content) cannot be mistaken for ours.
+func (q *BridgeQueue) receiptRecorded(ctx context.Context, msg *types.MsgBridgeExchange) (bool, error) {
+	txs, err := q.recorder.BridgeTransactionsByReceipt(ctx, msg.OriginChain, msg.BlockNumber, msg.ReceiptIndex)
 	if err != nil {
-		slog.Error("Failed to read request body", "error", err)
-		return echo.NewHTTPError(http.StatusBadRequest, "Failed to read request body")
+		return false, err
 	}
+	for _, tx := range txs {
+		if !bridgeTxMatchesMsg(tx, msg) {
+			continue
+		}
+		for _, v := range tx.Validators {
+			if v == msg.Validator {
+				return true, nil
+			}
+		}
+	}
+	return false, nil
+}
 
-	// Log the raw JSON for debugging
-	slog.Info("Received raw request body", "body", string(bodyBytes))
-
-	// Reset the body for binding
-	c.Request().Body = io.NopCloser(strings.NewReader(string(bodyBytes)))
+// bridgeTxMatchesMsg reports whether an on-chain bridge transaction has the same
+// content as our message. The query already filters by chain/block/receiptIndex;
+// matching the remaining content fields guards against confirming on a conflicting
+// entry. ContractAddress is compared case-insensitively because the chain
+// normalizes it to lowercase (see msg_server_bridge_exchange.go).
+func bridgeTxMatchesMsg(tx types.BridgeTransaction, msg *types.MsgBridgeExchange) bool {
+	return tx.ChainId == msg.OriginChain &&
+		strings.EqualFold(tx.ContractAddress, msg.ContractAddress) &&
+		tx.OwnerAddress == msg.OwnerAddress &&
+		tx.Amount == msg.Amount &&
+		tx.BlockNumber == msg.BlockNumber &&
+		tx.ReceiptIndex == msg.ReceiptIndex &&
+		tx.ReceiptsRoot == msg.ReceiptsRoot
+}
 
-	var blockData BridgeBlock
-	if err := c.Bind(&blockData); err != nil {
-		slog.Error("Failed to decode block data", "error", err)
-		return echo.NewHTTPError(http.StatusBadRequest, "Invalid request body: "+err.Error())
+// isAlreadyRecorded reports whether the broadcast error is the chain's dedup
+// signal that our validator already recorded this exact receipt. This is treated
+// as success (§1.3). The string match is fragile and only an optimization to skip
+// a redundant poll; the confirmation read remains the authority.
+func isAlreadyRecorded(err error) bool {
+	if err == nil {
+		return false
 	}
+	return strings.Contains(err.Error(), "Bridge: Validator has already validated this transaction")
+}
 
-	// Validate required fields
-	if blockData.BlockNumber == "" || blockData.ReceiptsRoot == "" || blockData.OriginChain == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "Required fields missing: blockNumber, receiptsRoot, originChain")
+// getLatestBridgeBlock serves the Geth startup/continuity handshake. It returns ONLY
+// the unified `blockNumber` key (plus `chainId`). When a chain is uninitialized the
+// blockNumber is omitted so Geth's tri-state parser treats it as "uninitialized" and
+// falls back to legacy behavior.
+func (s *Server) getLatestBridgeBlock(c echo.Context) error {
+	chain := c.QueryParam("chain")
+	if chain == "" {
+		return echo.NewHTTPError(http.StatusBadRequest, "Chain parameter is required (e.g., 'ethereum')")
 	}
-
-	slog.Info("Received finalized block",
-		"blockNumber", blockData.BlockNumber,
-		"originChain", blockData.OriginChain,
-		"receiptsRoot", blockData.ReceiptsRoot,
-		"receiptsCount", len(blockData.Receipts))
-
-	// Debug: Log each receipt to see what we're actually receiving
-	for i, receipt := range blockData.Receipts {
-		slog.Info("Received receipt details",
-			"receiptIndex", i,
-			"contract", receipt.ContractAddress,
-			"owner", receipt.OwnerAddress,
-			"publicKey", receipt.OwnerPubKey,
-			"publicKeyLength", len(receipt.OwnerPubKey),
-			"amount", receipt.Amount,
-			"receiptIndex", receipt.ReceiptIndex)
+	latest, ok := s.blockQueue.GetLatestBlock(chain)
+	if !ok {
+		// Uninitialized: omit blockNumber so Geth falls back to legacy.
+		return c.JSON(http.StatusOK, map[string]string{"chainId": chain})
 	}
-
-	// Add the block to the queue
-	blockNumber := s.blockQueue.AddBlock(blockData)
-
-	// Return success response
-	return c.JSON(http.StatusOK, &PostBlockResponse{
-		Status:        "success",
-		Message:       "Block queued for processing",
-		BlockNumber:   blockNumber,
-		ReceiptsCount: len(blockData.Receipts),
-		QueueSize:     s.blockQueue.GetQueueSize(),
-	})
+	return c.JSON(http.StatusOK, &LatestBridgeBlockResponse{ChainId: chain, BlockNumber: latest})
 }
 
-// getBridgeStatus returns information about the queue status
+// getBridgeStatus returns information about the queue status.
 func (s *Server) getBridgeStatus(c echo.Context) error {
 	pendingBlocks := s.blockQueue.GetPendingBlocks()
 
-	// Group blocks by number
+	// Group blocks by number.
 	blockCountByNumber := make(map[string]int)
 
-	// Track earliest and latest block numbers
+	// Track earliest and latest block numbers.
 	var blockNumbers []uint64
 
 	for _, block := range pendingBlocks {
 		blockNum := block.BlockNumber
 		blockCountByNumber[blockNum]++
 
-		// Parse block number for sorting
-		if blockNum, err := strconv.ParseUint(block.BlockNumber, 10, 64); err == nil {
-			blockNumbers = append(blockNumbers, blockNum)
+		if parsed, err := strconv.ParseUint(block.BlockNumber, 10, 64); err == nil {
+			blockNumbers = append(blockNumbers, parsed)
 		}
 	}
 
 	var earliestBlock, latestBlock uint64
-	var readyToProcess bool
-
 	if len(blockNumbers) > 0 {
-		// Sort the block numbers
-		sort.Slice(blockNumbers, func(i, j int) bool {
-			return blockNumbers[i] < blockNumbers[j]
-		})
-
+		sort.Slice(blockNumbers, func(i, j int) bool { return blockNumbers[i] < blockNumbers[j] })
 		earliestBlock = blockNumbers[0]
 		latestBlock = blockNumbers[len(blockNumbers)-1]
-		readyToProcess = len(blockNumbers) >= s.blockQueue.minBlocksBeforeProcessing
 	}
 
-	// Count total receipts in all blocks
 	totalReceipts := 0
 	for _, block := range pendingBlocks {
 		totalReceipts += len(block.Receipts)
 	}
 
 	response := &BridgeStatusResponse{
-		PendingBlocksCount:        len(pendingBlocks),
-		PendingReceiptsCount:      totalReceipts,
-		BlockCountByNumber:        blockCountByNumber,
-		EarliestBlockNumber:       earliestBlock,
-		LatestBlockNumber:         latestBlock,
-		ReadyToProcess:            readyToProcess,
-		MinBlocksBeforeProcessing: s.blockQueue.minBlocksBeforeProcessing,
+		PendingBlocksCount:   len(pendingBlocks),
+		PendingReceiptsCount: totalReceipts,
+		BlockCountByNumber:   blockCountByNumber,
+		EarliestBlockNumber:  earliestBlock,
+		LatestBlockNumber:    latestBlock,
 	}
 
 	return c.JSON(http.StatusOK, response)
 }
 
-// getBridgeAddresses returns bridge addresses for a specific chain by name
+// getBridgeAddresses returns bridge addresses for a specific chain by name.
 func (s *Server) getBridgeAddresses(c echo.Context) error {
 	chainName := c.QueryParam("chain")
 
@@ -379,16 +562,14 @@ func (s *Server) getBridgeAddresses(c echo.Context) error {
 		return echo.NewHTTPError(http.StatusBadRequest, "Chain parameter is required (e.g., 'ethereum', 'polygon')")
 	}
 
-	// Use chainName directly as chainId
+	// Use chainName directly as chainId.
 	chainId := chainName
 
-	// Get addresses for this chain
 	addresses, err := s.recorder.GetBridgeAddresses(c.Request().Context(), chainId)
 	if err != nil {
 		return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to get addresses for chain '%s': %v", chainName, err))
 	}
 
-	// Convert to simple address list for API response
 	var addressList []string
 	for _, item := range addresses {
 		addressList = append(addressList, item.Address)
diff --git a/decentralized-api/internal/server/public/classic_inference_deprecation_test.go b/decentralized-api/internal/server/public/classic_inference_deprecation_test.go
new file mode 100644
index 0000000000..a62db3e97d
--- /dev/null
+++ b/decentralized-api/internal/server/public/classic_inference_deprecation_test.go
@@ -0,0 +1,62 @@
+package public
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestClassicInferenceRoutesReturnDeprecated(t *testing.T) {
+	s := NewServer(nil, newTestConfigManager(t), nil, nil, nil, nil)
+
+	tests := []struct {
+		name   string
+		method string
+		path   string
+		body   string
+	}{
+		{
+			name:   "post chat completions",
+			method: http.MethodPost,
+			path:   "/v1/chat/completions",
+			body:   `{"model":"test","messages":[{"role":"user","content":"hi"}]}`,
+		},
+		{
+			name:   "get chat completions",
+			method: http.MethodGet,
+			path:   "/v1/chat/completions?id=abc",
+		},
+		{
+			name:   "post completions",
+			method: http.MethodPost,
+			path:   "/v1/completions",
+			body:   `{"model":"test","prompt":"hi"}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest(tt.method, tt.path, strings.NewReader(tt.body))
+			if tt.body != "" {
+				req.Header.Set("Content-Type", "application/json")
+			}
+			rec := httptest.NewRecorder()
+
+			s.e.ServeHTTP(rec, req)
+
+			require.Equal(t, http.StatusGone, rec.Code)
+			require.Equal(t, "true", rec.Header().Get("Deprecation"))
+			require.Contains(t, rec.Header().Get("Link"), "/devshard/{version}")
+
+			var body map[string]string
+			require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &body))
+			require.Equal(t, "deprecated", body["error"])
+			require.Contains(t, body["message"], "classic inference is deprecated")
+			require.Contains(t, body["message"], "devshard")
+		})
+	}
+}
diff --git a/decentralized-api/internal/server/public/devshard_deprecation_test.go b/decentralized-api/internal/server/public/devshard_deprecation_test.go
new file mode 100644
index 0000000000..cd4057e02e
--- /dev/null
+++ b/decentralized-api/internal/server/public/devshard_deprecation_test.go
@@ -0,0 +1,34 @@
+package public
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewServerRegistersDeprecatedDevshardPaths(t *testing.T) {
+	s := NewServer(nil, newTestConfigManager(t), nil, nil, nil, nil)
+	for _, path := range []string{
+		"/v1/devshard",
+		"/v1/devshard/stats/shards",
+		"/v1/devshard/sessions/escrow-1/mempool",
+	} {
+		t.Run(path, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, path, nil)
+			rec := httptest.NewRecorder()
+			s.e.ServeHTTP(rec, req)
+
+			require.Equal(t, http.StatusGone, rec.Code)
+			require.Equal(t, "true", rec.Header().Get("Deprecation"))
+			require.Contains(t, rec.Header().Get("Link"), "/devshard/{version}")
+
+			var body map[string]string
+			require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &body))
+			require.Equal(t, "deprecated", body["error"])
+			require.Contains(t, body["message"], "/devshard/{version}")
+		})
+	}
+}
diff --git a/decentralized-api/internal/server/public/poc_handler.go b/decentralized-api/internal/server/public/poc_handler.go
index c355496bbc..9fb62a0837 100644
--- a/decentralized-api/internal/server/public/poc_handler.go
+++ b/decentralized-api/internal/server/public/poc_handler.go
@@ -66,6 +66,27 @@ func (s *StringUint32) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// StringInt32 unmarshals from both JSON number and string.
+type StringInt32 int32
+
+func (s *StringInt32) UnmarshalJSON(data []byte) error {
+	var num int32
+	if err := json.Unmarshal(data, &num); err == nil {
+		*s = StringInt32(num)
+		return nil
+	}
+	var str string
+	if err := json.Unmarshal(data, &str); err != nil {
+		return err
+	}
+	num64, err := strconv.ParseInt(str, 10, 32)
+	if err != nil {
+		return err
+	}
+	*s = StringInt32(num64)
+	return nil
+}
+
 // PocProofsRequest is the request body for POST /v1/poc/proofs
 // Uses StringInt64/StringUint32 to accept both number and string JSON encoding
 type PocProofsRequest struct {
@@ -81,6 +102,20 @@ type PocProofsRequest struct {
 	Signature              string      `json:"signature"`                // base64-encoded signature
 }
 
+// PocProofsByNonceRequest is the request body for POST /v1/poc/proofs/by-nonce.
+type PocProofsByNonceRequest struct {
+	PocStageStartBlockHeight StringInt64   `json:"poc_stage_start_block_height"`
+	ModelId                  string        `json:"model_id"`
+	RootHash                 string        `json:"root_hash"` // base64-encoded 32 bytes
+	Count                    StringUint32  `json:"count"`     // snapshot leaf count
+	Nonces                   []StringInt32 `json:"nonces"`
+
+	ValidatorAddress       string      `json:"validator_address"`        // validator's cold key (for authz lookup)
+	ValidatorSignerAddress string      `json:"validator_signer_address"` // actual signer (cold or warm key)
+	Timestamp              StringInt64 `json:"timestamp"`                // unix nanoseconds
+	Signature              string      `json:"signature"`                // base64-encoded signature
+}
+
 // PocProofItem is a single proof in the response
 type PocProofItem struct {
 	LeafIndex   uint32   `json:"leaf_index"`
@@ -97,6 +132,17 @@ type PocProofsResponse struct {
 	Signature     string         `json:"signature,omitempty"`      // base64-encoded signature
 }
 
+type pocProofRequestCommon struct {
+	PocStageStartBlockHeight StringInt64
+	ModelId                  string
+	RootHash                 string
+	Count                    StringUint32
+	ValidatorAddress         string
+	ValidatorSignerAddress   string
+	Timestamp                StringInt64
+	Signature                string
+}
+
 // PocArtifactsStateResponse is the response for GET /v1/poc/artifacts/state
 type PocArtifactsStateResponse struct {
 	PocStageStartBlockHeight int64  `json:"poc_stage_start_block_height"`
@@ -116,47 +162,212 @@ func (s *Server) postPocProofs(ctx echo.Context) error {
 		return echo.NewHTTPError(http.StatusBadRequest, "invalid request body")
 	}
 
-	// Validate required fields
+	if len(req.LeafIndices) == 0 {
+		return echo.NewHTTPError(http.StatusBadRequest, "leaf_indices required")
+	}
+	if len(req.LeafIndices) > maxLeafIndicesPerRequest {
+		return echo.NewHTTPError(http.StatusBadRequest, "too many leaf_indices (max 500)")
+	}
+	common := pocProofRequestCommon{
+		PocStageStartBlockHeight: req.PocStageStartBlockHeight,
+		ModelId:                  req.ModelId,
+		RootHash:                 req.RootHash,
+		Count:                    req.Count,
+		ValidatorAddress:         req.ValidatorAddress,
+		ValidatorSignerAddress:   req.ValidatorSignerAddress,
+		Timestamp:                req.Timestamp,
+		Signature:                req.Signature,
+	}
+	rootHash, reqCount, stageStore, err := s.preparePocProofRequest(ctx, common, func(rootHash []byte, signerPubkey string) error {
+		return verifyPocProofsSignatureWithPubkey(&req, rootHash, signerPubkey)
+	})
+	if err != nil {
+		return err
+	}
+
+	// Validate all leaf indices are within snapshot range
+	for _, leafIndex := range req.LeafIndices {
+		if uint32(leafIndex) >= reqCount {
+			return echo.NewHTTPError(http.StatusBadRequest, "leaf_index out of snapshot range")
+		}
+	}
+
+	// Generate proofs using snapshot-consistent method to ensure artifact and proof
+	// are from the same tree state (prevents serving current-tree artifact with snapshot proof)
+	proofs := make([]PocProofItem, 0, len(req.LeafIndices))
+	leafIndices := make([]uint32, len(req.LeafIndices))
+	for i, leafIndex := range req.LeafIndices {
+		leafIndices[i] = uint32(leafIndex)
+	}
+	entries, err := stageStore.GetArtifactsAndProofs(leafIndices, reqCount)
+	if err != nil {
+		if err == artifacts.ErrLeafIndexOutOfRange {
+			return echo.NewHTTPError(http.StatusBadRequest, "leaf_index out of range")
+		}
+		logging.Error("Failed to get artifacts and proofs", types.Validation,
+			"count", reqCount, "error", err)
+		return echo.NewHTTPError(http.StatusInternalServerError, "failed to get artifact and proof")
+	}
+	for _, entry := range entries {
+		proofs = append(proofs, buildPocProofItem(entry.DenseIndex, entry.Nonce, entry.Vector, entry.Proof))
+	}
+
+	logging.Info("Serving PoC proofs", types.Validation,
+		"validatorAddress", req.ValidatorAddress, "count", len(proofs))
+
+	// Build and sign response
+	respTimestamp := time.Now().UnixNano()
+	signerAddress := s.recorder.GetSignerAddress()
+
+	signPayload := buildPocProofsResponseSignPayload(
+		int64(req.PocStageStartBlockHeight),
+		req.ModelId,
+		rootHash,
+		reqCount,
+		proofs,
+		respTimestamp,
+		signerAddress,
+	)
+
+	signature, err := s.recorder.SignBytes(signPayload)
+	if err != nil {
+		logging.Error("Failed to sign response", types.Validation, "error", err)
+		return ctx.JSON(http.StatusOK, PocProofsResponse{Proofs: proofs})
+	}
+
+	return ctx.JSON(http.StatusOK, PocProofsResponse{
+		Proofs:        proofs,
+		SignerAddress: signerAddress,
+		Timestamp:     respTimestamp,
+		Signature:     base64.StdEncoding.EncodeToString(signature),
+	})
+}
+
+// postPocProofsByNonce handles POST /v1/poc/proofs/by-nonce.
+func (s *Server) postPocProofsByNonce(ctx echo.Context) error {
+	if s.artifactStore == nil {
+		return echo.NewHTTPError(http.StatusServiceUnavailable, "artifact store not configured")
+	}
+
+	var req PocProofsByNonceRequest
+	if err := ctx.Bind(&req); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "invalid request body")
+	}
+
+	if len(req.Nonces) == 0 {
+		return echo.NewHTTPError(http.StatusBadRequest, "nonces required")
+	}
+	if len(req.Nonces) > maxLeafIndicesPerRequest {
+		return echo.NewHTTPError(http.StatusBadRequest, "too many nonces (max 500)")
+	}
+	common := pocProofRequestCommon{
+		PocStageStartBlockHeight: req.PocStageStartBlockHeight,
+		ModelId:                  req.ModelId,
+		RootHash:                 req.RootHash,
+		Count:                    req.Count,
+		ValidatorAddress:         req.ValidatorAddress,
+		ValidatorSignerAddress:   req.ValidatorSignerAddress,
+		Timestamp:                req.Timestamp,
+		Signature:                req.Signature,
+	}
+	rootHash, reqCount, stageStore, err := s.preparePocProofRequest(ctx, common, func(rootHash []byte, signerPubkey string) error {
+		return verifyPocProofsByNonceSignatureWithPubkey(&req, rootHash, signerPubkey)
+	})
+	if err != nil {
+		return err
+	}
+
+	proofs := make([]PocProofItem, 0, len(req.Nonces))
+	nonces := make([]int32, len(req.Nonces))
+	for i, requestedNonce := range req.Nonces {
+		nonces[i] = int32(requestedNonce)
+	}
+	entries, err := stageStore.GetArtifactsAndProofsByNonce(nonces, reqCount)
+	if err != nil {
+		logging.Error("Failed to get artifacts and proofs by nonce", types.Validation,
+			"count", reqCount, "error", err)
+		return echo.NewHTTPError(http.StatusInternalServerError, "failed to get artifact and proof")
+	}
+	for _, entry := range entries {
+		proofs = append(proofs, buildPocProofItem(entry.DenseIndex, entry.Nonce, entry.Vector, entry.Proof))
+	}
+
+	logging.Info("Serving PoC proofs by nonce", types.Validation,
+		"validatorAddress", req.ValidatorAddress, "requested", len(req.Nonces), "returned", len(proofs))
+
+	respTimestamp := time.Now().UnixNano()
+	signerAddress := s.recorder.GetSignerAddress()
+	signPayload := buildPocProofsResponseSignPayload(
+		int64(req.PocStageStartBlockHeight),
+		req.ModelId,
+		rootHash,
+		reqCount,
+		proofs,
+		respTimestamp,
+		signerAddress,
+	)
+
+	signature, err := s.recorder.SignBytes(signPayload)
+	if err != nil {
+		logging.Error("Failed to sign response", types.Validation, "error", err)
+		return ctx.JSON(http.StatusOK, PocProofsResponse{Proofs: proofs})
+	}
+
+	return ctx.JSON(http.StatusOK, PocProofsResponse{
+		Proofs:        proofs,
+		SignerAddress: signerAddress,
+		Timestamp:     respTimestamp,
+		Signature:     base64.StdEncoding.EncodeToString(signature),
+	})
+}
+
+func buildPocProofItem(leafIndex uint32, nonce int32, vector []byte, proof [][]byte) PocProofItem {
+	proofStrings := make([]string, len(proof))
+	for i, hash := range proof {
+		proofStrings[i] = base64.StdEncoding.EncodeToString(hash)
+	}
+	return PocProofItem{
+		LeafIndex:   leafIndex,
+		NonceValue:  nonce,
+		VectorBytes: base64.StdEncoding.EncodeToString(vector),
+		Proof:       proofStrings,
+	}
+}
+
+func (s *Server) preparePocProofRequest(
+	ctx echo.Context,
+	req pocProofRequestCommon,
+	verifySignature func(rootHash []byte, signerPubkey string) error,
+) ([]byte, uint32, artifacts.ArtifactStore, error) {
 	if req.ModelId == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "model_id required")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "model_id required")
 	}
 	if req.RootHash == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "root_hash required")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "root_hash required")
 	}
 	if req.ValidatorAddress == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "validator_address required")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "validator_address required")
 	}
 	if req.ValidatorSignerAddress == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "validator_signer_address required")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "validator_signer_address required")
 	}
 	if req.Signature == "" {
-		return echo.NewHTTPError(http.StatusBadRequest, "signature required")
-	}
-	if len(req.LeafIndices) == 0 {
-		return echo.NewHTTPError(http.StatusBadRequest, "leaf_indices required")
-	}
-	if len(req.LeafIndices) > maxLeafIndicesPerRequest {
-		return echo.NewHTTPError(http.StatusBadRequest, "too many leaf_indices (max 500)")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "signature required")
 	}
 
-	// Decode root_hash
 	rootHash, err := base64.StdEncoding.DecodeString(req.RootHash)
 	if err != nil || len(rootHash) != 32 {
-		return echo.NewHTTPError(http.StatusBadRequest, "invalid root_hash (must be 32 bytes base64)")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "invalid root_hash (must be 32 bytes base64)")
 	}
 
-	// Validate timestamp is within acceptable window (+/-5 minutes)
 	nowNanos := time.Now().UnixNano()
 	reqTimestamp := int64(req.Timestamp)
 	if reqTimestamp < nowNanos-timestampWindowNanos || reqTimestamp > nowNanos+timestampWindowNanos {
 		logging.Warn("PoC proofs request timestamp out of range", types.Validation,
 			"timestamp", reqTimestamp, "now", nowNanos)
-		return echo.NewHTTPError(http.StatusBadRequest, "timestamp out of acceptable window")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "timestamp out of acceptable window")
 	}
 
-	// Get pubkey for the specific signer address (via authz cache)
-	// validator_address = cold key for authz lookup
-	// validator_signer_address = actual signer (must be authorized for validator_address)
 	signerPubkey, err := s.authzCache.GetPubKeyForSigner(
 		ctx.Request().Context(),
 		req.ValidatorAddress,
@@ -168,123 +379,57 @@ func (s *Server) postPocProofs(ctx echo.Context) error {
 			"validatorAddress", req.ValidatorAddress,
 			"validatorSignerAddress", req.ValidatorSignerAddress,
 			"error", err)
-		return echo.NewHTTPError(http.StatusUnauthorized, "validator not found")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusUnauthorized, "validator not found")
 	}
 	if signerPubkey == "" {
 		logging.Warn("Signer not authorized for validator", types.Validation,
 			"validatorAddress", req.ValidatorAddress,
 			"validatorSignerAddress", req.ValidatorSignerAddress)
-		return echo.NewHTTPError(http.StatusUnauthorized, "signer not authorized for validator")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusUnauthorized, "signer not authorized for validator")
 	}
 
-	// Verify signature against the specific signer's pubkey
-	if err := verifyPocProofsSignatureWithPubkey(&req, rootHash, signerPubkey); err != nil {
+	if err := verifySignature(rootHash, signerPubkey); err != nil {
 		logging.Warn("Invalid PoC proofs signature", types.Validation,
 			"validatorAddress", req.ValidatorAddress,
 			"validatorSignerAddress", req.ValidatorSignerAddress, "error", err)
-		return echo.NewHTTPError(http.StatusUnauthorized, "invalid signature")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusUnauthorized, "invalid signature")
 	}
 
-	// Get stage-specific artifact store
 	stageStore, err := s.artifactStore.GetStore(int64(req.PocStageStartBlockHeight), req.ModelId)
 	if err != nil {
 		logging.Warn("Stage store not found", types.Validation,
 			"pocStageStartBlockHeight", req.PocStageStartBlockHeight,
 			"modelId", req.ModelId,
 			"error", err)
-		return echo.NewHTTPError(http.StatusNotFound, "not found for height (may be pruned or not yet created)")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusNotFound, "not found for height (may be pruned or not yet created)")
 	}
 
-	// Snapshot binding validation: verify (root_hash, count) matches store state
 	reqCount := uint32(req.Count)
+
+	// No per-validator snapshot-count quota is needed: committed counts are
+	// served from retained copy-on-write snapshots in O(depth), and any
+	// non-committed count is rejected outright (its root can never match the
+	// on-chain commitment), so a proof request can no longer trigger an O(N)
+	// rebuild — the rebuild-DoS surface the quota guarded against is gone.
 	storeRoot, err := stageStore.GetRootAt(reqCount)
 	if err != nil {
-		logging.Warn("Snapshot count exceeds store", types.Validation,
+		logging.Warn("Snapshot count not servable", types.Validation,
+			"validatorAddress", req.ValidatorAddress,
 			"pocStageStartBlockHeight", req.PocStageStartBlockHeight,
+			"modelId", req.ModelId,
 			"requestedCount", reqCount, "error", err)
-		return echo.NewHTTPError(http.StatusBadRequest, "count exceeds stored artifacts")
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "count exceeds stored artifacts")
 	}
 	if !bytes.Equal(rootHash, storeRoot) {
 		logging.Warn("Root hash mismatch", types.Validation,
+			"validatorAddress", req.ValidatorAddress,
 			"pocStageStartBlockHeight", req.PocStageStartBlockHeight,
+			"modelId", req.ModelId,
 			"requestedCount", reqCount)
-		return echo.NewHTTPError(http.StatusBadRequest, "root_hash does not match store state at count")
-	}
-
-	// Validate all leaf indices are within snapshot range
-	for _, leafIndex := range req.LeafIndices {
-		if uint32(leafIndex) >= reqCount {
-			return echo.NewHTTPError(http.StatusBadRequest, "leaf_index out of snapshot range")
-		}
-	}
-
-	// Generate proofs
-	proofs := make([]PocProofItem, 0, len(req.LeafIndices))
-	for _, leafIndex := range req.LeafIndices {
-		leafIdx := uint32(leafIndex)
-		nonce, vector, err := stageStore.GetArtifact(leafIdx)
-		if err != nil {
-			if err == artifacts.ErrLeafIndexOutOfRange {
-				return echo.NewHTTPError(http.StatusBadRequest, "leaf_index out of range")
-			}
-			logging.Error("Failed to get artifact", types.Validation,
-				"leafIndex", leafIdx, "error", err)
-			return echo.NewHTTPError(http.StatusInternalServerError, "failed to get artifact")
-		}
-
-		proof, err := stageStore.GetProof(leafIdx, reqCount)
-		if err != nil {
-			if err == artifacts.ErrLeafIndexOutOfRange {
-				return echo.NewHTTPError(http.StatusBadRequest, "leaf_index out of range for proof")
-			}
-			logging.Error("Failed to get proof", types.Validation,
-				"leafIndex", leafIdx, "count", reqCount, "error", err)
-			return echo.NewHTTPError(http.StatusBadRequest, "failed to generate proof")
-		}
-
-		// Encode proof hashes as base64
-		proofStrings := make([]string, len(proof))
-		for i, hash := range proof {
-			proofStrings[i] = base64.StdEncoding.EncodeToString(hash)
-		}
-
-		proofs = append(proofs, PocProofItem{
-			LeafIndex:   leafIdx,
-			NonceValue:  nonce,
-			VectorBytes: base64.StdEncoding.EncodeToString(vector),
-			Proof:       proofStrings,
-		})
+		return nil, 0, nil, echo.NewHTTPError(http.StatusBadRequest, "root_hash does not match store state at count")
 	}
 
-	logging.Info("Serving PoC proofs", types.Validation,
-		"validatorAddress", req.ValidatorAddress, "count", len(proofs))
-
-	// Build and sign response
-	respTimestamp := time.Now().UnixNano()
-	signerAddress := s.recorder.GetSignerAddress()
-
-	signPayload := buildPocProofsResponseSignPayload(
-		int64(req.PocStageStartBlockHeight),
-		req.ModelId,
-		rootHash,
-		reqCount,
-		proofs,
-		respTimestamp,
-		signerAddress,
-	)
-
-	signature, err := s.recorder.SignBytes(signPayload)
-	if err != nil {
-		logging.Error("Failed to sign response", types.Validation, "error", err)
-		return ctx.JSON(http.StatusOK, PocProofsResponse{Proofs: proofs})
-	}
-
-	return ctx.JSON(http.StatusOK, PocProofsResponse{
-		Proofs:        proofs,
-		SignerAddress: signerAddress,
-		Timestamp:     respTimestamp,
-		Signature:     base64.StdEncoding.EncodeToString(signature),
-	})
+	return rootHash, reqCount, stageStore, nil
 }
 
 // getPocArtifactsState returns the current artifact store state for a given height.
@@ -366,6 +511,29 @@ func buildPocProofsSignPayload(req *PocProofsRequest, rootHash []byte) []byte {
 	return []byte(hex.EncodeToString(hash[:]))
 }
 
+// buildPocProofsByNonceSignPayload builds the binary payload for by-nonce proof
+// requests. The leading domain tag prevents signatures for leaf-index requests
+// from replaying as nonce requests.
+func buildPocProofsByNonceSignPayload(req *PocProofsByNonceRequest, rootHash []byte) []byte {
+	buf := new(bytes.Buffer)
+
+	writeLengthPrefixedString(buf, "poc-proofs-by-nonce-v1")
+	binary.Write(buf, binary.LittleEndian, int64(req.PocStageStartBlockHeight))
+	writeLengthPrefixedString(buf, req.ModelId)
+	buf.Write(rootHash)
+	binary.Write(buf, binary.LittleEndian, uint32(req.Count))
+	binary.Write(buf, binary.LittleEndian, uint32(len(req.Nonces)))
+	for _, nonce := range req.Nonces {
+		binary.Write(buf, binary.LittleEndian, int32(nonce))
+	}
+	binary.Write(buf, binary.LittleEndian, int64(req.Timestamp))
+	writeLengthPrefixedString(buf, req.ValidatorAddress)
+	writeLengthPrefixedString(buf, req.ValidatorSignerAddress)
+
+	hash := sha256.Sum256(buf.Bytes())
+	return []byte(hex.EncodeToString(hash[:]))
+}
+
 // writeLengthPrefixedString writes len(s) as a LE uint32 followed by the
 // raw string bytes. Used by all proof sign payload builders so that
 // variable-length fields cannot collide across distinct semantic inputs.
@@ -397,6 +565,29 @@ func verifyPocProofsSignatureWithPubkey(req *PocProofsRequest, rootHash []byte,
 	return echo.NewHTTPError(http.StatusUnauthorized, "signature verification failed")
 }
 
+// verifyPocProofsByNonceSignatureWithPubkey verifies the signature for a
+// by-nonce request against a specific signer pubkey.
+func verifyPocProofsByNonceSignatureWithPubkey(req *PocProofsByNonceRequest, rootHash []byte, pubkeyB64 string) error {
+	payload := buildPocProofsByNonceSignPayload(req, rootHash)
+
+	signatureBytes, err := base64.StdEncoding.DecodeString(req.Signature)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "invalid signature encoding")
+	}
+
+	pubkeyBytes, err := base64.StdEncoding.DecodeString(pubkeyB64)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusInternalServerError, "invalid pubkey encoding")
+	}
+
+	pubkey := secp256k1.PubKey{Key: pubkeyBytes}
+	if pubkey.VerifySignature(payload, signatureBytes) {
+		return nil
+	}
+
+	return echo.NewHTTPError(http.StatusUnauthorized, "signature verification failed")
+}
+
 // buildPocProofsResponseSignPayload builds the binary payload for response signature.
 // Format: hex(SHA256(
 //
diff --git a/decentralized-api/internal/server/public/poc_handler_test.go b/decentralized-api/internal/server/public/poc_handler_test.go
index 2d22a77c5c..4eefc717f5 100644
--- a/decentralized-api/internal/server/public/poc_handler_test.go
+++ b/decentralized-api/internal/server/public/poc_handler_test.go
@@ -115,6 +115,82 @@ func TestBuildPocProofsSignPayload(t *testing.T) {
 	assert.Equal(t, expectedHex, string(payload))
 }
 
+func TestBuildPocProofsByNonceSignPayload(t *testing.T) {
+	rootHash := make([]byte, 32)
+	for i := range rootHash {
+		rootHash[i] = byte(i)
+	}
+
+	req := &PocProofsByNonceRequest{
+		PocStageStartBlockHeight: 12345,
+		ModelId:                  "model-a",
+		RootHash:                 base64.StdEncoding.EncodeToString(rootHash),
+		Count:                    50000,
+		Nonces:                   []StringInt32{0, 42, -7},
+		ValidatorAddress:         "gonka1validator",
+		ValidatorSignerAddress:   "gonka1signer",
+		Timestamp:                1700000000000000000,
+	}
+
+	payload := buildPocProofsByNonceSignPayload(req, rootHash)
+	assert.Len(t, payload, 64)
+
+	buf := new(bytes.Buffer)
+	binary.Write(buf, binary.LittleEndian, uint32(len("poc-proofs-by-nonce-v1")))
+	buf.WriteString("poc-proofs-by-nonce-v1")
+	binary.Write(buf, binary.LittleEndian, int64(12345))
+	binary.Write(buf, binary.LittleEndian, uint32(len("model-a")))
+	buf.WriteString("model-a")
+	buf.Write(rootHash)
+	binary.Write(buf, binary.LittleEndian, uint32(50000))
+	binary.Write(buf, binary.LittleEndian, uint32(3)) // num_nonces
+	binary.Write(buf, binary.LittleEndian, int32(0))
+	binary.Write(buf, binary.LittleEndian, int32(42))
+	binary.Write(buf, binary.LittleEndian, int32(-7))
+	binary.Write(buf, binary.LittleEndian, int64(1700000000000000000))
+	binary.Write(buf, binary.LittleEndian, uint32(len("gonka1validator")))
+	buf.WriteString("gonka1validator")
+	binary.Write(buf, binary.LittleEndian, uint32(len("gonka1signer")))
+	buf.WriteString("gonka1signer")
+
+	expectedHash := sha256.Sum256(buf.Bytes())
+	expectedHex := fmt.Sprintf("%x", expectedHash)
+	assert.Equal(t, expectedHex, string(payload))
+}
+
+func TestPocProofsByNonceSignatureRejectsLeafIndexReplay(t *testing.T) {
+	rootHash := make([]byte, 32)
+	privKey := secp256k1.GenPrivKey()
+	pubKeyB64 := base64.StdEncoding.EncodeToString(privKey.PubKey().Bytes())
+
+	leafReq := &PocProofsRequest{
+		PocStageStartBlockHeight: 100,
+		ModelId:                  "model-a",
+		RootHash:                 base64.StdEncoding.EncodeToString(rootHash),
+		Count:                    10,
+		LeafIndices:              []StringUint32{1, 2},
+		ValidatorAddress:         "validator-address",
+		ValidatorSignerAddress:   "validator-address",
+		Timestamp:                StringInt64(time.Now().UnixNano()),
+	}
+	signature, err := privKey.Sign(buildPocProofsSignPayload(leafReq, rootHash))
+	assert.NoError(t, err)
+
+	nonceReq := &PocProofsByNonceRequest{
+		PocStageStartBlockHeight: leafReq.PocStageStartBlockHeight,
+		ModelId:                  leafReq.ModelId,
+		RootHash:                 leafReq.RootHash,
+		Count:                    leafReq.Count,
+		Nonces:                   []StringInt32{1, 2},
+		ValidatorAddress:         leafReq.ValidatorAddress,
+		ValidatorSignerAddress:   leafReq.ValidatorSignerAddress,
+		Timestamp:                leafReq.Timestamp,
+		Signature:                base64.StdEncoding.EncodeToString(signature),
+	}
+
+	assert.Error(t, verifyPocProofsByNonceSignatureWithPubkey(nonceReq, rootHash, pubKeyB64))
+}
+
 func TestStringInt64_UnmarshalJSON(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -260,12 +336,12 @@ func TestGetPocArtifactsState_UsesModelScopedStore(t *testing.T) {
 
 	modelStore, err := store.GetOrCreateStore(100, "org/model-a")
 	assert.NoError(t, err)
-	assert.NoError(t, modelStore.Add(1, []byte("artifact-a")))
+	assert.NoError(t, modelStore.AddWithNode(1, []byte("artifact-a"), ""))
 	assert.NoError(t, modelStore.Flush())
 
 	otherStore, err := store.GetOrCreateStore(100, "model-b")
 	assert.NoError(t, err)
-	assert.NoError(t, otherStore.Add(2, []byte("artifact-b")))
+	assert.NoError(t, otherStore.AddWithNode(2, []byte("artifact-b"), ""))
 	assert.NoError(t, otherStore.Flush())
 
 	server := &Server{artifactStore: store}
@@ -291,13 +367,13 @@ func TestPostPocProofs_UsesModelScopedStore(t *testing.T) {
 
 	modelAStore, err := store.GetOrCreateStore(100, "model-a")
 	assert.NoError(t, err)
-	assert.NoError(t, modelAStore.Add(1, []byte{1, 2, 3, 4}))
+	assert.NoError(t, modelAStore.AddWithNode(1, []byte{1, 2, 3, 4}, ""))
 	assert.NoError(t, modelAStore.Flush())
 	modelACount, modelARoot := modelAStore.GetFlushedRoot()
 
 	modelBStore, err := store.GetOrCreateStore(100, "model-b")
 	assert.NoError(t, err)
-	assert.NoError(t, modelBStore.Add(2, []byte{5, 6, 7, 8}))
+	assert.NoError(t, modelBStore.AddWithNode(2, []byte{5, 6, 7, 8}, ""))
 	assert.NoError(t, modelBStore.Flush())
 	_, modelBRoot := modelBStore.GetFlushedRoot()
 	assert.False(t, bytes.Equal(modelARoot, modelBRoot))
@@ -350,3 +426,71 @@ func TestPostPocProofs_UsesModelScopedStore(t *testing.T) {
 	assert.Equal(t, uint32(0), resp.Proofs[0].LeafIndex)
 	mockRecorder.AssertExpectations(t)
 }
+
+func TestPostPocProofsByNonce_UsesModelScopedStore(t *testing.T) {
+	store := artifacts.NewManagedArtifactStore(t.TempDir(), 3)
+	defer store.Close()
+
+	modelAStore, err := store.GetOrCreateStore(100, "model-a")
+	assert.NoError(t, err)
+	assert.NoError(t, modelAStore.AddWithNode(10, []byte{1, 2, 3, 4}, ""))
+	assert.NoError(t, modelAStore.AddWithNode(30, []byte{5, 6, 7, 8}, ""))
+	assert.NoError(t, modelAStore.Flush())
+	modelACount, modelARoot := modelAStore.GetFlushedRoot()
+
+	modelBStore, err := store.GetOrCreateStore(100, "model-b")
+	assert.NoError(t, err)
+	assert.NoError(t, modelBStore.AddWithNode(10, []byte{9, 10, 11, 12}, ""))
+	assert.NoError(t, modelBStore.Flush())
+	_, modelBRoot := modelBStore.GetFlushedRoot()
+	assert.False(t, bytes.Equal(modelARoot, modelBRoot))
+
+	privKey := secp256k1.GenPrivKey()
+	pubKeyB64 := base64.StdEncoding.EncodeToString(privKey.PubKey().Bytes())
+	queryClient, cleanup := newProofQueryClient(t, &proofQueryServer{pubkeyB64: pubKeyB64})
+	defer cleanup()
+
+	mockRecorder := &cosmosclient.MockCosmosMessageClient{}
+	mockRecorder.On("NewInferenceQueryClient").Return(queryClient)
+	mockRecorder.On("GetSignerAddress").Return("participant-signer")
+	mockRecorder.On("SignBytes", mock.Anything).Return([]byte("response-signature"), nil)
+
+	server := &Server{
+		artifactStore: store,
+		recorder:      mockRecorder,
+		authzCache:    authzcache.NewAuthzCache(mockRecorder),
+	}
+
+	reqBody := &PocProofsByNonceRequest{
+		PocStageStartBlockHeight: 100,
+		ModelId:                  "model-a",
+		RootHash:                 base64.StdEncoding.EncodeToString(modelARoot),
+		Count:                    StringUint32(modelACount),
+		Nonces:                   []StringInt32{10, 99},
+		ValidatorAddress:         "validator-address",
+		ValidatorSignerAddress:   "validator-address",
+		Timestamp:                StringInt64(time.Now().UnixNano()),
+	}
+	signature, err := privKey.Sign(buildPocProofsByNonceSignPayload(reqBody, modelARoot))
+	assert.NoError(t, err)
+	reqBody.Signature = base64.StdEncoding.EncodeToString(signature)
+
+	body, err := json.Marshal(reqBody)
+	assert.NoError(t, err)
+
+	req := httptest.NewRequest(http.MethodPost, "/v1/poc/proofs/by-nonce", bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	rec := httptest.NewRecorder()
+	e := echo.New()
+
+	err = server.postPocProofsByNonce(e.NewContext(req, rec))
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+
+	var resp PocProofsResponse
+	assert.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+	assert.Len(t, resp.Proofs, 1)
+	assert.Equal(t, int32(10), resp.Proofs[0].NonceValue)
+	assert.Equal(t, uint32(0), resp.Proofs[0].LeafIndex)
+	mockRecorder.AssertExpectations(t)
+}
diff --git a/decentralized-api/internal/server/public/post_chat_handler_interruption_test.go b/decentralized-api/internal/server/public/post_chat_handler_interruption_test.go
deleted file mode 100644
index 1916c804d7..0000000000
--- a/decentralized-api/internal/server/public/post_chat_handler_interruption_test.go
+++ /dev/null
@@ -1,1132 +0,0 @@
-package public
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"decentralized-api/apiconfig"
-	"decentralized-api/broker"
-	"decentralized-api/chainphase"
-	"decentralized-api/completionapi"
-	"decentralized-api/cosmosclient"
-	"decentralized-api/mlnodeclient"
-	"decentralized-api/utils"
-
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/crypto/hd"
-	"github.com/cosmos/cosmos-sdk/crypto/keyring"
-	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
-	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/knadh/koanf/providers/file"
-	"github.com/productscience/inference/api/inference/inference"
-	"github.com/productscience/inference/x/inference/calculations"
-	"github.com/productscience/inference/x/inference/types"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/grpc"
-
-	cmtbytes "github.com/cometbft/cometbft/libs/bytes"
-	ctypes "github.com/cometbft/cometbft/rpc/core/types"
-)
-
-// ============================================================================
-// Test Keys for Signing
-// ============================================================================
-
-type testSigningKey struct {
-	key *secp256k1.PrivKey
-}
-
-func newTestSigningKey() *testSigningKey {
-	return &testSigningKey{key: secp256k1.GenPrivKey()}
-}
-
-func (t *testSigningKey) GetPubKeyBase64() string {
-	return base64.StdEncoding.EncodeToString(t.key.PubKey().Bytes())
-}
-
-// SignBytes implements calculations.Signer interface
-func (t *testSigningKey) SignBytes(msg []byte) (string, error) {
-	sig, err := t.key.Sign(msg)
-	if err != nil {
-		return "", err
-	}
-	return base64.StdEncoding.EncodeToString(sig), nil
-}
-
-// ============================================================================
-// Test Keyring Helper
-// ============================================================================
-
-// setupTestCodec creates a properly configured codec for keyring operations
-func setupTestCodec() codec.Codec {
-	registry := codectypes.NewInterfaceRegistry()
-	registry.RegisterInterface("cosmos.crypto.PubKey", (*cryptotypes.PubKey)(nil))
-	registry.RegisterInterface("cosmos.crypto.PrivKey", (*cryptotypes.PrivKey)(nil))
-	registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &secp256k1.PubKey{})
-	registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &secp256k1.PrivKey{})
-	return codec.NewProtoCodec(registry)
-}
-
-// createTestKeyring creates an in-memory keyring with a test key and returns the keyring and address
-func createTestKeyring(t *testing.T) (*keyring.Keyring, string) {
-	cdc := setupTestCodec()
-	kr := keyring.NewInMemory(cdc)
-
-	keyName := "test-executor-key"
-	record, _, err := kr.NewMnemonic(
-		keyName,
-		keyring.English,
-		sdk.FullFundraiserPath,
-		"",
-		hd.Secp256k1,
-	)
-	require.NoError(t, err)
-	require.NotNil(t, record)
-
-	// Get the address from the record
-	addr, err := record.GetAddress()
-	require.NoError(t, err)
-
-	return &kr, addr.String()
-}
-
-// ============================================================================
-// Test Suite
-// ============================================================================
-
-type interruptionTestSuite struct {
-	t               *testing.T
-	mockRecorder    *cosmosclient.MockCosmosMessageClient
-	mockQueryClient *mockInterruptionQueryClient
-	mockMLServer    *httptest.Server
-	mockClientFactory *mlnodeclient.MockClientFactory
-	server          *Server
-	configManager   *apiconfig.ConfigManager
-	nodeBroker      *broker.Broker
-	phaseTracker    *chainphase.ChainPhaseTracker
-
-	// Keys for signing
-	devKey *testSigningKey
-	taKey  *testSigningKey
-
-	// Executor address (generated from keyring)
-	executorAddress string
-
-	// Track calls
-	finishInferenceCalls []*inference.MsgFinishInference
-	mu                   sync.Mutex
-}
-
-func (s *interruptionTestSuite) getFinishInferenceCalls() []*inference.MsgFinishInference {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	result := make([]*inference.MsgFinishInference, len(s.finishInferenceCalls))
-	copy(result, s.finishInferenceCalls)
-	return result
-}
-
-func (s *interruptionTestSuite) clearFinishInferenceCalls() {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.finishInferenceCalls = nil
-}
-
-const (
-	finishInferenceAsyncMaxWait   = 5 * time.Second
-	finishInferenceAsyncPoll      = 10 * time.Millisecond
-	finishInferenceAsyncStable    = 100 * time.Millisecond
-	finishInferenceAsyncMinSettle = 300 * time.Millisecond
-)
-
-// waitForFinishInferenceCallsAtLeast polls until at least minCount FinishInference
-// recordings exist or timeout expires (for slow CI runners).
-func (s *interruptionTestSuite) waitForFinishInferenceCallsAtLeast(minCount int, timeout time.Duration) []*inference.MsgFinishInference {
-	deadline := time.Now().Add(timeout)
-	for time.Now().Before(deadline) {
-		calls := s.getFinishInferenceCalls()
-		if len(calls) >= minCount {
-			return calls
-		}
-		time.Sleep(finishInferenceAsyncPoll)
-	}
-	return s.getFinishInferenceCalls()
-}
-
-// awaitAsyncFinishInferenceSettled waits for async FinishInference recording to
-// finish: either the call count is stable for finishInferenceAsyncStable after
-// finishInferenceAsyncMinSettle, or finishInferenceAsyncMaxWait elapses.
-func (s *interruptionTestSuite) awaitAsyncFinishInferenceSettled() {
-	start := time.Now()
-	deadline := start.Add(finishInferenceAsyncMaxWait)
-	var lastCount int = -1
-	var stableSince time.Time
-
-	for time.Now().Before(deadline) {
-		count := len(s.getFinishInferenceCalls())
-		if count != lastCount {
-			lastCount = count
-			stableSince = time.Now()
-		} else if !stableSince.IsZero() &&
-			time.Since(stableSince) >= finishInferenceAsyncStable &&
-			time.Since(start) >= finishInferenceAsyncMinSettle {
-			return
-		}
-		time.Sleep(finishInferenceAsyncPoll)
-	}
-}
-
-func (s *interruptionTestSuite) cleanup() {
-	if s.mockMLServer != nil {
-		s.mockMLServer.Close()
-	}
-}
-
-// waitForInferenceNodeReady blocks until the broker considers the node available
-// for inference (INFERENCE status and no in-flight reconciliation). Without this,
-// ServeHTTP can race reconciliation and return "no nodes available for inference".
-func (s *interruptionTestSuite) waitForInferenceNodeReady(t *testing.T, nodeID string) {
-	t.Helper()
-
-	if !s.pollInferenceNodeReady(nodeID, 2*time.Second) {
-		// Reconciliation may not finish in time on slow CI; force stable INFERENCE status.
-		setStatusCmd := broker.NewSetNodesActualStatusCommand([]broker.StatusUpdate{
-			{
-				NodeId:     nodeID,
-				PrevStatus: types.HardwareNodeStatus_UNKNOWN,
-				NewStatus:  types.HardwareNodeStatus_INFERENCE,
-				Timestamp:  time.Now(),
-			},
-		})
-		err := s.nodeBroker.QueueMessage(setStatusCmd)
-		require.NoError(t, err)
-		require.True(t, <-setStatusCmd.Response)
-	}
-
-	if !s.pollInferenceNodeReady(nodeID, 2*time.Second) {
-		t.Fatalf("node %q did not reach stable INFERENCE status in time", nodeID)
-	}
-}
-
-func (s *interruptionTestSuite) pollInferenceNodeReady(nodeID string, timeout time.Duration) bool {
-	deadline := time.Now().Add(timeout)
-	for time.Now().Before(deadline) {
-		nodes, err := s.nodeBroker.GetNodes()
-		if err == nil {
-			for _, n := range nodes {
-				if n.Node.Id == nodeID &&
-					n.State.IntendedStatus == types.HardwareNodeStatus_INFERENCE &&
-					n.State.CurrentStatus == types.HardwareNodeStatus_INFERENCE &&
-					n.State.ReconcileInfo == nil {
-					return true
-				}
-			}
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	return false
-}
-
-func (s *interruptionTestSuite) waitForFinishInferenceCalls(t *testing.T, want int, timeout time.Duration) []*inference.MsgFinishInference {
-	t.Helper()
-	deadline := time.Now().Add(timeout)
-	for time.Now().Before(deadline) {
-		calls := s.getFinishInferenceCalls()
-		if len(calls) >= want {
-			return calls
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	calls := s.getFinishInferenceCalls()
-	require.Len(t, calls, want, "timed out waiting for FinishInference calls")
-	return calls
-}
-
-// ============================================================================
-// Mock Query Client
-// ============================================================================
-
-type mockInterruptionQueryClient struct {
-	types.QueryClient
-	mock.Mock
-}
-
-func (m *mockInterruptionQueryClient) ModelsAll(ctx context.Context, in *types.QueryModelsAllRequest, opts ...grpc.CallOption) (*types.QueryModelsAllResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryModelsAllResponse), args.Error(1)
-}
-
-func (m *mockInterruptionQueryClient) EpochGroupData(ctx context.Context, in *types.QueryGetEpochGroupDataRequest, opts ...grpc.CallOption) (*types.QueryGetEpochGroupDataResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryGetEpochGroupDataResponse), args.Error(1)
-}
-
-func (m *mockInterruptionQueryClient) Params(ctx context.Context, in *types.QueryParamsRequest, opts ...grpc.CallOption) (*types.QueryParamsResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryParamsResponse), args.Error(1)
-}
-
-func (m *mockInterruptionQueryClient) GetRandomExecutor(ctx context.Context, in *types.QueryGetRandomExecutorRequest, opts ...grpc.CallOption) (*types.QueryGetRandomExecutorResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryGetRandomExecutorResponse), args.Error(1)
-}
-
-func (m *mockInterruptionQueryClient) GranteesByMessageType(ctx context.Context, in *types.QueryGranteesByMessageTypeRequest, opts ...grpc.CallOption) (*types.QueryGranteesByMessageTypeResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryGranteesByMessageTypeResponse), args.Error(1)
-}
-
-func (m *mockInterruptionQueryClient) AccountByAddress(ctx context.Context, in *types.QueryAccountByAddressRequest, opts ...grpc.CallOption) (*types.QueryAccountByAddressResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryAccountByAddressResponse), args.Error(1)
-}
-
-func (m *mockInterruptionQueryClient) GetModelPerTokenPrice(ctx context.Context, in *types.QueryGetModelPerTokenPriceRequest, opts ...grpc.CallOption) (*types.QueryGetModelPerTokenPriceResponse, error) {
-	args := m.Called(ctx, in)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).(*types.QueryGetModelPerTokenPriceResponse), args.Error(1)
-}
-
-// mockParticipantInfo for broker setup
-type mockInterruptionParticipantInfo struct {
-	mock.Mock
-}
-
-func (m *mockInterruptionParticipantInfo) GetAddress() string {
-	args := m.Called()
-	return args.String(0)
-}
-
-func (m *mockInterruptionParticipantInfo) GetPubKey() string {
-	args := m.Called()
-	return args.String(0)
-}
-
-// ============================================================================
-// Mock ML Node Server
-// ============================================================================
-
-type mockMLNodeBehavior struct {
-	responseType       string        // "streaming" | "json"
-	chunks             []string      // chunks to send for streaming
-	delayBetweenChunks time.Duration // delay between chunks
-	abortAfterChunks   int           // -1 = complete all chunks, N = abort after N chunks
-	statusCode         int           // HTTP status code
-	responseBody       string        // response body for JSON mode
-	initialDelay       time.Duration // delay before starting response
-}
-
-func newMockMLServer(behavior *mockMLNodeBehavior) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if behavior.initialDelay > 0 {
-			time.Sleep(behavior.initialDelay)
-		}
-
-		if behavior.statusCode != 0 && behavior.statusCode != 200 {
-			w.WriteHeader(behavior.statusCode)
-			if behavior.responseBody != "" {
-				w.Write([]byte(behavior.responseBody))
-			} else {
-				w.Write([]byte(`{"error": "mock error"}`))
-			}
-			return
-		}
-
-		if behavior.responseType == "streaming" {
-			w.Header().Set("Content-Type", "text/event-stream")
-			w.Header().Set("Cache-Control", "no-cache")
-			w.Header().Set("Connection", "keep-alive")
-			w.WriteHeader(http.StatusOK)
-
-			flusher, ok := w.(http.Flusher)
-			if !ok {
-				http.Error(w, "Streaming not supported", http.StatusInternalServerError)
-				return
-			}
-
-			chunksToSend := len(behavior.chunks)
-			if behavior.abortAfterChunks >= 0 && behavior.abortAfterChunks < chunksToSend {
-				chunksToSend = behavior.abortAfterChunks
-			}
-
-			for i := 0; i < chunksToSend; i++ {
-				if behavior.delayBetweenChunks > 0 && i > 0 {
-					time.Sleep(behavior.delayBetweenChunks)
-				}
-				fmt.Fprintln(w, behavior.chunks[i])
-				flusher.Flush()
-			}
-
-			// If abort requested, close connection abruptly
-			if behavior.abortAfterChunks >= 0 && behavior.abortAfterChunks < len(behavior.chunks) {
-				return
-			}
-
-			// Send DONE marker for complete streams
-			fmt.Fprintln(w, "data: [DONE]")
-			flusher.Flush()
-		} else {
-			// JSON mode
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			w.Write([]byte(behavior.responseBody))
-		}
-	}))
-}
-
-// ============================================================================
-// Test Data Helpers
-// ============================================================================
-
-func generateStreamingChunks(inferenceId string, model string, tokenCount int) []string {
-	chunks := make([]string, 0, tokenCount+1)
-
-	for i := 0; i < tokenCount; i++ {
-		chunk := fmt.Sprintf(`data: {"id":"%s","object":"chat.completion.chunk","created":%d,"model":"%s","choices":[{"index":0,"delta":{"content":"token%d"},"logprobs":{"content":[{"token":"token%d","logprob":-0.1,"bytes":[116],"top_logprobs":[]}]},"finish_reason":null}]}`,
-			inferenceId, time.Now().Unix(), model, i, i)
-		chunks = append(chunks, chunk)
-	}
-
-	// Final chunk with usage info
-	finalChunk := fmt.Sprintf(`data: {"id":"%s","object":"chat.completion.chunk","created":%d,"model":"%s","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":{"prompt_tokens":10,"completion_tokens":%d,"total_tokens":%d}}`,
-		inferenceId, time.Now().Unix(), model, tokenCount, 10+tokenCount)
-	chunks = append(chunks, finalChunk)
-
-	return chunks
-}
-
-func generateJSONResponse(inferenceId string, model string, promptTokens, completionTokens int) string {
-	return fmt.Sprintf(`{
-		"id": "%s",
-		"object": "chat.completion",
-		"created": %d,
-		"model": "%s",
-		"choices": [{
-			"index": 0,
-			"message": {"role": "assistant", "content": "Hello! How can I help you?"},
-			"logprobs": {"content": [{"token": "Hello", "logprob": -0.1, "bytes": [72], "top_logprobs": []}]},
-			"finish_reason": "stop"
-		}],
-		"usage": {"prompt_tokens": %d, "completion_tokens": %d, "total_tokens": %d}
-	}`, inferenceId, time.Now().Unix(), model, promptTokens, completionTokens, promptTokens+completionTokens)
-}
-
-// ============================================================================
-// Test Setup
-// ============================================================================
-
-func setupInterruptionTestWithMLServer(t *testing.T, mlBehavior *mockMLNodeBehavior) *interruptionTestSuite {
-	os.Setenv("ENFORCED_MODEL_ID", "disabled")
-
-	suite := &interruptionTestSuite{
-		t:                    t,
-		finishInferenceCalls: make([]*inference.MsgFinishInference, 0),
-		devKey:               newTestSigningKey(),
-		taKey:                newTestSigningKey(),
-	}
-
-	// 1. Create mock ML server
-	suite.mockMLServer = newMockMLServer(mlBehavior)
-
-	// 2. Create config manager
-	tmpFile, err := os.CreateTemp("", "config-*.yaml")
-	require.NoError(t, err)
-	t.Cleanup(func() { os.Remove(tmpFile.Name()) })
-
-	_, err = tmpFile.Write([]byte("nodes: []\ncurrent_node_version: v1"))
-	require.NoError(t, err)
-	tmpFile.Close()
-
-	suite.configManager = &apiconfig.ConfigManager{
-		KoanProvider:   file.Provider(tmpFile.Name()),
-		WriterProvider: apiconfig.NewFileWriteCloserProvider(tmpFile.Name()),
-	}
-	err = suite.configManager.Load()
-	require.NoError(t, err)
-
-	// 3. Create mock recorder
-	suite.mockRecorder = &cosmosclient.MockCosmosMessageClient{}
-	suite.mockQueryClient = &mockInterruptionQueryClient{}
-
-	// Setup query client mocks
-	suite.mockQueryClient.On("ModelsAll", mock.Anything, mock.Anything).Return(&types.QueryModelsAllResponse{
-		Model: []types.Model{{Id: "test-model"}},
-	}, nil)
-
-	suite.mockQueryClient.On("Params", mock.Anything, mock.Anything).Return(&types.QueryParamsResponse{
-		Params: types.Params{},
-	}, nil)
-
-	// Create a real in-memory keyring with a test key
-	testKeyring, testExecutorAddress := createTestKeyring(t)
-	suite.executorAddress = testExecutorAddress
-
-	suite.mockQueryClient.On("GetRandomExecutor", mock.Anything, mock.Anything).Return(&types.QueryGetRandomExecutorResponse{
-		Executor: types.Participant{
-			Address:      testExecutorAddress,
-			InferenceUrl: "http://localhost:8080",
-		},
-	}, nil)
-
-	// Return TA's pubkey for grantee validation
-	suite.mockQueryClient.On("GranteesByMessageType", mock.Anything, mock.Anything).Return(&types.QueryGranteesByMessageTypeResponse{
-		Grantees: []*types.Grantee{
-			{
-				Address: testExecutorAddress,
-				PubKey:  suite.taKey.GetPubKeyBase64(),
-			},
-		},
-	}, nil)
-
-	// Return account pubkey for authz cache
-	suite.mockQueryClient.On("AccountByAddress", mock.Anything, mock.Anything).Return(&types.QueryAccountByAddressResponse{
-		Pubkey: suite.devKey.GetPubKeyBase64(),
-	}, nil)
-
-	suite.mockQueryClient.On("GetModelPerTokenPrice", mock.Anything, mock.Anything).Return(&types.QueryGetModelPerTokenPriceResponse{
-		Price: 1,
-		Found: true,
-	}, nil)
-
-	parentGroupResp := &types.QueryGetEpochGroupDataResponse{
-		EpochGroupData: types.EpochGroupData{
-			PocStartBlockHeight: 100,
-			EpochIndex:          100,
-			SubGroupModels:      []string{"test-model"},
-		},
-	}
-	suite.mockQueryClient.On("EpochGroupData", mock.Anything, &types.QueryGetEpochGroupDataRequest{
-		EpochIndex: 100,
-		ModelId:    "",
-	}).Return(parentGroupResp, nil)
-
-	modelEpochData := &types.QueryGetEpochGroupDataResponse{
-		EpochGroupData: types.EpochGroupData{
-			PocStartBlockHeight: 100,
-			EpochIndex:          100,
-			ModelSnapshot:       &types.Model{Id: "test-model"},
-		},
-	}
-	suite.mockQueryClient.On("EpochGroupData", mock.Anything, &types.QueryGetEpochGroupDataRequest{
-		EpochIndex: 100,
-		ModelId:    "test-model",
-	}).Return(modelEpochData, nil)
-
-	suite.mockRecorder.On("NewInferenceQueryClient").Return(suite.mockQueryClient)
-	suite.mockRecorder.On("GetContext").Return(context.Background())
-	suite.mockRecorder.On("GetAccountAddress").Return(testExecutorAddress)
-	suite.mockRecorder.On("GetSignerAddress").Return(testExecutorAddress)
-	suite.mockRecorder.On("SignBytes", mock.Anything).Return([]byte("mock-signature"), nil)
-	suite.mockRecorder.On("GetKeyring").Return(testKeyring)
-
-	// Track FinishInference calls - THIS IS THE KEY MOCK
-	suite.mockRecorder.On("FinishInference", mock.Anything).Run(func(args mock.Arguments) {
-		msg := args.Get(0).(*inference.MsgFinishInference)
-		suite.mu.Lock()
-		suite.finishInferenceCalls = append(suite.finishInferenceCalls, msg)
-		suite.mu.Unlock()
-		t.Logf("FinishInference CALLED: id=%s, promptTokens=%d, completionTokens=%d",
-			msg.InferenceId, msg.PromptTokenCount, msg.CompletionTokenCount)
-	}).Return(nil)
-
-	suite.mockRecorder.On("StartInference", mock.Anything).Return(nil)
-
-	suite.mockRecorder.On("Status", mock.Anything).Return(&ctypes.ResultStatus{
-		SyncInfo: ctypes.SyncInfo{
-			LatestBlockHeight: 100,
-			LatestBlockTime:   time.Now(),
-			LatestBlockHash:   cmtbytes.HexBytes("abc123"),
-		},
-	}, nil)
-
-	// 4. Create phase tracker
-	suite.phaseTracker = &chainphase.ChainPhaseTracker{}
-	suite.phaseTracker.Update(
-		chainphase.BlockInfo{Height: 150, Hash: "hash-150"},
-		&types.Epoch{Index: 100, PocStartBlockHeight: 100},
-		&types.EpochParams{EpochLength: 200, PocStageDuration: 50},
-		true,
-		nil,
-	)
-
-	// 5. Create broker with mock ML node client factory
-	mockParticipant := &mockInterruptionParticipantInfo{}
-	mockParticipant.On("GetAddress").Return(testExecutorAddress)
-	mockParticipant.On("GetPubKey").Return(suite.taKey.GetPubKeyBase64())
-
-	bridge := broker.NewBrokerChainBridgeImpl(suite.mockRecorder, "")
-	suite.mockClientFactory = mlnodeclient.NewMockClientFactory()
-
-	suite.nodeBroker = broker.NewBroker(bridge, suite.phaseTracker, mockParticipant, "", suite.mockClientFactory, suite.configManager)
-
-	// 6. Register a node pointing to mock ML server
-	mlServerURL := suite.mockMLServer.URL
-	mlServerURL = strings.TrimPrefix(mlServerURL, "http://")
-	parts := strings.Split(mlServerURL, ":")
-	host := parts[0]
-	port := 80
-	if len(parts) > 1 {
-		fmt.Sscanf(parts[1], "%d", &port)
-	}
-
-	nodeConfig := apiconfig.InferenceNodeConfig{
-		Id:               "test-node",
-		Host:             host,
-		InferencePort:    port,
-		InferenceSegment: "",
-		PoCPort:          port + 1,
-		PoCSegment:       "",
-		MaxConcurrent:    10,
-		Models:           map[string]apiconfig.ModelConfig{"test-model": {Args: []string{}}},
-	}
-
-	cmd := broker.NewRegisterNodeCommand(nodeConfig)
-	err = suite.nodeBroker.QueueMessage(cmd)
-	require.NoError(t, err)
-	resp := <-cmd.Response
-	require.NoError(t, resp.Error)
-
-	mlNode := types.MLNodeInfo{
-		NodeId:             nodeConfig.Id,
-		Throughput:         0,
-		PocWeight:          10,
-		TimeslotAllocation: []bool{true, false},
-	}
-	model := types.Model{Id: "test-model"}
-	suite.nodeBroker.UpdateNodeEpochData([]*types.MLNodeInfo{&mlNode}, "test-model", model)
-
-	pocURL := fmt.Sprintf("http://%s:%d", host, port+1)
-	mockClient := suite.mockClientFactory.CreateClient(pocURL, fmt.Sprintf("http://%s:%d", host, port)).(*mlnodeclient.MockClient)
-	mockClient.Mu.Lock()
-	mockClient.CurrentState = mlnodeclient.MlNodeState_INFERENCE
-	mockClient.InferenceIsHealthy = true
-	mockClient.Mu.Unlock()
-
-	inferenceUpCmd := broker.NewInferenceUpAllCommand()
-	err = suite.nodeBroker.QueueMessage(inferenceUpCmd)
-	require.NoError(t, err)
-	require.True(t, <-inferenceUpCmd.Response)
-	suite.waitForInferenceNodeReady(t, nodeConfig.Id)
-
-	// 7. Create the public server
-	payloadStorage := newMockPayloadStorage()
-
-	suite.server = NewServer(
-		suite.nodeBroker,
-		suite.configManager,
-		suite.mockRecorder,
-		nil,
-		suite.phaseTracker,
-		payloadStorage,
-	)
-
-	return suite
-}
-
-// ============================================================================
-// Create Properly Signed Request
-// ============================================================================
-
-func (s *interruptionTestSuite) createSignedExecutorRequest(inferenceId string, model string, stream bool) *http.Request {
-	body := map[string]interface{}{
-		"model":    model,
-		"messages": []map[string]string{{"role": "user", "content": "Hello"}},
-		"stream":   stream,
-	}
-	bodyBytes, _ := json.Marshal(body)
-	modifiedRequest, err := completionapi.ModifyRequestBodyWithLogprobsMode(bodyBytes, 12345, types.DefaultLogprobsMode)
-	require.NoError(s.t, err)
-	modifiedPromptHash, _, err := getModifiedPromptHash(modifiedRequest.NewBody)
-	require.NoError(s.t, err)
-
-	timestamp := time.Now().UnixNano()
-	// Use the address from the test suite's generated keyring
-	transferAddress := s.executorAddress
-	executorAddress := s.executorAddress
-
-	// Dev signs: hash(original_prompt) + timestamp + ta_address
-	originalPromptHash := utils.GenerateSHA256Hash(string(bodyBytes))
-	devComponents := calculations.SignatureComponents{
-		Payload:         originalPromptHash,
-		Timestamp:       timestamp,
-		TransferAddress: transferAddress,
-		ExecutorAddress: "",
-	}
-	devSignature, _ := calculations.Sign(s.devKey, devComponents, calculations.Developer)
-
-	// TA signs: prompt_hash + timestamp + ta_address + executor_address
-	taComponents := calculations.SignatureComponents{
-		Payload:         modifiedPromptHash,
-		Timestamp:       timestamp,
-		TransferAddress: transferAddress,
-		ExecutorAddress: executorAddress,
-	}
-	taSignature, _ := calculations.Sign(s.taKey, taComponents, calculations.TransferAgent)
-
-	req := httptest.NewRequest(http.MethodPost, "/v1/chat/completions", bytes.NewReader(bodyBytes))
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", devSignature)
-	req.Header.Set("X-Inference-Id", inferenceId)
-	req.Header.Set("X-Seed", "12345")
-	req.Header.Set("X-Timestamp", fmt.Sprintf("%d", timestamp))
-	req.Header.Set("X-Transfer-Address", transferAddress)
-	req.Header.Set("X-Requester-Address", "test-requester-address")
-	req.Header.Set("X-TA-Signature", taSignature)
-	req.Header.Set(utils.XPromptHashHeader, modifiedPromptHash)
-
-	return req
-}
-
-// ============================================================================
-// ACTUAL TESTS - Verify FinishInference is called or not
-// ============================================================================
-
-func TestInterruption_S1_MLNodeClosesStream_VerifyFinishInference(t *testing.T) {
-	// S1: MLNode closes connection mid-stream (vLLM crash, OOM)
-	// HYPOTHESIS: FinishInference should NOT be called
-	// ACTUAL: Let's find out!
-
-	chunks := generateStreamingChunks("inf-s1", "test-model", 5)
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType:     "streaming",
-		chunks:           chunks,
-		abortAfterChunks: 2, // Send only 2 chunks then abort
-		statusCode:       200,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-s1", "test-model", true)
-	rec := httptest.NewRecorder()
-
-	suite.server.e.ServeHTTP(rec, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("S1 RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("S1 RESULT: HTTP status = %d", rec.Code)
-
-	if len(calls) > 0 {
-		t.Logf("S1 ACTUAL: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-		t.Logf("S1 BUG CONFIRMED: Partial stream results in FinishInference with potentially wrong data!")
-	} else {
-		t.Logf("S1 ACTUAL: FinishInference was NOT called")
-	}
-}
-
-func TestInterruption_S4_StreamSuccess_VerifyFinishInference(t *testing.T) {
-	// S4: Successful streaming response (baseline)
-	// EXPECTED: FinishInference IS called
-
-	chunks := generateStreamingChunks("inf-s4", "test-model", 5)
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType:     "streaming",
-		chunks:           chunks,
-		abortAfterChunks: -1, // Complete all chunks
-		statusCode:       200,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-s4", "test-model", true)
-	rec := httptest.NewRecorder()
-
-	suite.server.e.ServeHTTP(rec, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("S4 RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("S4 RESULT: HTTP status = %d", rec.Code)
-
-	if len(calls) > 0 {
-		t.Logf("S4 ACTUAL: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-	} else {
-		t.Logf("S4 ACTUAL: FinishInference was NOT called - THIS IS UNEXPECTED!")
-	}
-}
-
-func TestInterruption_J1_MLNodeClosesJSON_VerifyFinishInference(t *testing.T) {
-	// J1: MLNode closes connection mid-JSON response
-	// HYPOTHESIS: FinishInference should NOT be called (partial JSON fails parse)
-
-	// Create a mock server that sends partial JSON then closes
-	partialJSON := `{"id": "inf-j1", "object": "chat.completion", "created": 12345`
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(partialJSON))
-	}))
-	defer mockServer.Close()
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType: "json",
-		responseBody: generateJSONResponse("inf-j1", "test-model", 10, 20),
-		statusCode:   200,
-	})
-	// Replace the ML server with our partial JSON server
-	suite.mockMLServer.Close()
-	suite.mockMLServer = mockServer
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-j1", "test-model", false)
-	rec := httptest.NewRecorder()
-
-	suite.server.e.ServeHTTP(rec, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("J1 RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("J1 RESULT: HTTP status = %d", rec.Code)
-
-	if len(calls) == 0 {
-		t.Logf("J1 ACTUAL: FinishInference was NOT called (correct for partial JSON)")
-	} else {
-		t.Logf("J1 ACTUAL: FinishInference WAS called - UNEXPECTED!")
-	}
-}
-
-func TestInterruption_J4_JSONSuccess_VerifyFinishInference(t *testing.T) {
-	// J4: Successful JSON response (baseline)
-	// EXPECTED: FinishInference IS called
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType: "json",
-		responseBody: generateJSONResponse("inf-j4", "test-model", 10, 20),
-		statusCode:   200,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-j4", "test-model", false)
-	rec := httptest.NewRecorder()
-
-	suite.server.e.ServeHTTP(rec, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("J4 RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("J4 RESULT: HTTP status = %d", rec.Code)
-
-	if len(calls) > 0 {
-		t.Logf("J4 ACTUAL: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-	} else {
-		t.Logf("J4 ACTUAL: FinishInference was NOT called - THIS IS UNEXPECTED!")
-	}
-}
-
-func TestInterruption_E1_MLNode400_VerifyFinishInference(t *testing.T) {
-	// E1: MLNode returns 400 Bad Request
-	// EXPECTED: FinishInference IS called (with synthetic response)
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType: "json",
-		responseBody: `{"error": {"message": "Invalid request", "type": "invalid_request_error"}}`,
-		statusCode:   400,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-e1", "test-model", false)
-	rec := httptest.NewRecorder()
-
-	suite.server.e.ServeHTTP(rec, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("E1 RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("E1 RESULT: HTTP status = %d", rec.Code)
-
-	if len(calls) > 0 {
-		t.Logf("E1 ACTUAL: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-	} else {
-		t.Logf("E1 ACTUAL: FinishInference was NOT called")
-	}
-}
-
-func TestInterruption_E3_MLNode500_VerifyFinishInference(t *testing.T) {
-	// E3: MLNode returns 500 Internal Server Error
-	// EXPECTED: FinishInference should NOT be called
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType: "json",
-		responseBody: `{"error": {"message": "Internal server error", "type": "server_error"}}`,
-		statusCode:   500,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-e3", "test-model", false)
-	rec := httptest.NewRecorder()
-
-	suite.server.e.ServeHTTP(rec, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("E3 RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("E3 RESULT: HTTP status = %d", rec.Code)
-
-	if len(calls) == 0 {
-		t.Logf("E3 ACTUAL: FinishInference was NOT called (expected for 500 error)")
-	} else {
-		t.Logf("E3 ACTUAL: FinishInference WAS called - UNEXPECTED!")
-	}
-}
-
-// ============================================================================
-// CLIENT/TA DISCONNECT TESTS - The critical scenarios
-// ============================================================================
-
-// disconnectingResponseWriter simulates a client that disconnects mid-response
-type disconnectingResponseWriter struct {
-	header       http.Header
-	writtenBytes int
-	disconnectAt int // disconnect after this many bytes
-	statusCode   int
-	err          error
-}
-
-func newDisconnectingResponseWriter(disconnectAfterBytes int) *disconnectingResponseWriter {
-	return &disconnectingResponseWriter{
-		header:       make(http.Header),
-		disconnectAt: disconnectAfterBytes,
-		err:          &net.OpError{Op: "write", Net: "tcp", Err: fmt.Errorf("broken pipe")},
-	}
-}
-
-func (w *disconnectingResponseWriter) Header() http.Header {
-	return w.header
-}
-
-func (w *disconnectingResponseWriter) Write(data []byte) (int, error) {
-	if w.disconnectAt >= 0 && w.writtenBytes >= w.disconnectAt {
-		return 0, w.err
-	}
-	remaining := len(data)
-	if w.disconnectAt >= 0 && w.writtenBytes+len(data) > w.disconnectAt {
-		remaining = w.disconnectAt - w.writtenBytes
-	}
-	w.writtenBytes += remaining
-	if remaining < len(data) {
-		return remaining, w.err
-	}
-	return len(data), nil
-}
-
-func (w *disconnectingResponseWriter) WriteHeader(statusCode int) {
-	w.statusCode = statusCode
-}
-
-func (w *disconnectingResponseWriter) Flush() {
-	// No-op for testing
-}
-
-func TestInterruption_ClientDisconnect_StreamingComplete_VerifyFinishInference(t *testing.T) {
-	// CRITICAL SCENARIO: MLNode completes the full response, but client disconnects
-	// while Executor is streaming back to client/TA
-	//
-	// Pipeline: Client -> TA -> Executor -> MLNode
-	// What happens: MLNode finishes, Executor has full response, but write to TA/Client fails
-	//
-	// EXPECTED: FinishInference SHOULD be called (work was completed)
-
-	chunks := generateStreamingChunks("inf-cd1", "test-model", 5)
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType:     "streaming",
-		chunks:           chunks,
-		abortAfterChunks: -1, // MLNode completes fully
-		statusCode:       200,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-cd1", "test-model", true)
-
-	// Use disconnecting writer - disconnect after receiving some bytes
-	// This simulates TA/Client disconnecting while Executor streams response back
-	disconnectWriter := newDisconnectingResponseWriter(100) // Disconnect after 100 bytes
-
-	suite.server.e.ServeHTTP(disconnectWriter, req)
-
-	calls := suite.waitForFinishInferenceCallsAtLeast(1, finishInferenceAsyncMaxWait)
-	t.Logf("CLIENT_DISCONNECT_STREAM RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("CLIENT_DISCONNECT_STREAM: Written bytes before disconnect = %d", disconnectWriter.writtenBytes)
-
-	require.Len(t, calls, 1, "executor should record FinishInference from partial response data after client disconnect")
-	require.Equal(t, "inf-cd1", calls[0].InferenceId)
-	require.Equal(t, uint64(1), calls[0].CompletionTokenCount)
-	require.NotEmpty(t, calls[0].ResponseHash)
-}
-
-func TestInterruption_ClientDisconnect_JSONComplete_VerifyFinishInference(t *testing.T) {
-	// CRITICAL SCENARIO: MLNode returns complete JSON, but client disconnects
-	// while Executor writes JSON response back
-	//
-	// EXPECTED: FinishInference SHOULD be called (work was completed)
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType: "json",
-		responseBody: generateJSONResponse("inf-cd2", "test-model", 10, 20),
-		statusCode:   200,
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-cd2", "test-model", false)
-
-	// Disconnect after first 50 bytes of JSON response
-	disconnectWriter := newDisconnectingResponseWriter(50)
-
-	suite.server.e.ServeHTTP(disconnectWriter, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("CLIENT_DISCONNECT_JSON RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("CLIENT_DISCONNECT_JSON: Written bytes before disconnect = %d", disconnectWriter.writtenBytes)
-
-	if len(calls) > 0 {
-		t.Logf("CLIENT_DISCONNECT_JSON: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-		t.Logf("CLIENT_DISCONNECT_JSON: GOOD - Executor recorded the inference despite client disconnect")
-	} else {
-		t.Logf("CLIENT_DISCONNECT_JSON: FinishInference was NOT called")
-		t.Logf("CLIENT_DISCONNECT_JSON: BUG! Executor did NOT record inference when client disconnected!")
-	}
-}
-
-func TestInterruption_ClientDisconnect_BeforeMLNodeResponse_VerifyFinishInference(t *testing.T) {
-	// SCENARIO: Client disconnects BEFORE MLNode even starts responding
-	// MLNode has a delay, client disconnects during that delay
-	//
-	// This tests if the Executor still completes and records when client is gone
-
-	chunks := generateStreamingChunks("inf-cd3", "test-model", 5)
-
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType:     "streaming",
-		chunks:           chunks,
-		abortAfterChunks: -1,
-		statusCode:       200,
-		initialDelay:     100 * time.Millisecond, // MLNode takes 100ms to start
-	})
-	defer suite.cleanup()
-
-	req := suite.createSignedExecutorRequest("inf-cd3", "test-model", true)
-
-	// Disconnect immediately (0 bytes) - client gone before any response
-	disconnectWriter := newDisconnectingResponseWriter(0)
-
-	suite.server.e.ServeHTTP(disconnectWriter, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("CLIENT_DISCONNECT_EARLY RESULT: FinishInference calls count = %d", len(calls))
-
-	if len(calls) > 0 {
-		t.Logf("CLIENT_DISCONNECT_EARLY: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-		t.Logf("CLIENT_DISCONNECT_EARLY: Executor completed work despite early client disconnect")
-	} else {
-		t.Logf("CLIENT_DISCONNECT_EARLY: FinishInference was NOT called")
-		t.Logf("CLIENT_DISCONNECT_EARLY: Need to verify if this is expected behavior")
-	}
-}
-
-// ============================================================================
-// TIMEOUT TESTS - Executor -> MLNode connection timeout
-// ============================================================================
-
-func TestInterruption_MLNodeTimeout_VerifyFinishInference(t *testing.T) {
-	// CRITICAL SCENARIO: MLNode takes too long (timeout)
-	// The HTTP client timeout is triggered, connection is closed
-	//
-	// EXPECTED: FinishInference SHOULD be called with synthetic response
-	// so the inference lifecycle is closed on-chain
-	//
-	// This tests the new isTimeoutOrConnectionError() handling
-
-	// Create a mock MLNode that never responds (simulates timeout)
-	// We use initialDelay to make it block long enough for timeout
-	suite := setupInterruptionTestWithMLServer(t, &mockMLNodeBehavior{
-		responseType: "streaming",
-		chunks:       generateStreamingChunks("inf-timeout1", "test-model", 5),
-		statusCode:   200,
-		initialDelay: 10 * time.Second, // Long delay to trigger timeout
-	})
-	defer suite.cleanup()
-
-	// Create a custom HTTP client with a very short timeout for this test
-	shortTimeoutClient := &http.Client{
-		Timeout: 500 * time.Millisecond, // 500ms timeout - much shorter than initialDelay
-		CheckRedirect: func(req *http.Request, via []*http.Request) error {
-			return http.ErrUseLastResponse
-		},
-	}
-	// Replace the server's HTTP client temporarily
-	originalClient := suite.server.httpClient
-	suite.server.httpClient = shortTimeoutClient
-	defer func() { suite.server.httpClient = originalClient }()
-
-	req := suite.createSignedExecutorRequest("inf-timeout1", "test-model", true)
-
-	// Use a regular recorder since we want to see if the request completes
-	rr := httptest.NewRecorder()
-
-	// This should timeout after 500ms (before the 10s delay completes)
-	suite.server.e.ServeHTTP(rr, req)
-
-	suite.awaitAsyncFinishInferenceSettled()
-
-	calls := suite.getFinishInferenceCalls()
-	t.Logf("TIMEOUT TEST RESULT: FinishInference calls count = %d", len(calls))
-	t.Logf("TIMEOUT TEST: HTTP status = %d", rr.Code)
-
-	if len(calls) > 0 {
-		t.Logf("TIMEOUT TEST: FinishInference WAS called (promptTokens=%d, completionTokens=%d)",
-			calls[0].PromptTokenCount, calls[0].CompletionTokenCount)
-		t.Logf("TIMEOUT TEST: GOOD - Executor recorded FinishInference with synthetic response on timeout")
-	} else {
-		t.Logf("TIMEOUT TEST: FinishInference was NOT called")
-		t.Logf("TIMEOUT TEST: Check if isTimeoutOrConnectionError() is properly detecting the timeout")
-	}
-}
diff --git a/decentralized-api/internal/server/public/server.go b/decentralized-api/internal/server/public/server.go
index 3c60ea6f9b..6abc72f8b6 100644
--- a/decentralized-api/internal/server/public/server.go
+++ b/decentralized-api/internal/server/public/server.go
@@ -11,7 +11,6 @@ import (
 	"decentralized-api/payloadstorage"
 	"decentralized-api/poc/artifacts"
 	"decentralized-api/statsstorage"
-	"devshard"
 	"net/http"
 	"time"
 
@@ -21,7 +20,10 @@ import (
 	echomw "github.com/labstack/echo/v4/middleware"
 )
 
-const httpClientTimeout = 30 * time.Minute
+const (
+	httpClientTimeout          = 30 * time.Minute
+	deprecatedDevshardV1Prefix = "/v1/devshard"
+)
 
 type Server struct {
 	e                   *echo.Echo
@@ -31,6 +33,7 @@ type Server struct {
 	blockQueue          *BridgeQueue
 	bandwidthLimiter    *internal.BandwidthLimiter
 	identityCache       *identityCache
+	versionsCache       *versionsCache
 	payloadStorage      payloadstorage.PayloadStorage
 	phaseTracker        *chainphase.ChainPhaseTracker
 	epochGroupDataCache *internal.EpochGroupDataCache
@@ -66,6 +69,9 @@ func NewServer(
 	opts ...ServerOption) *Server {
 	e := echo.New()
 	e.HTTPErrorHandler = middleware.TransparentErrorHandler
+	// Avoid Echo's legacy RealIP behavior, which trusts the left-most XFF value.
+	// This extracts the nearest untrusted hop from XFF (falling back to RemoteAddr).
+	e.IPExtractor = echo.ExtractIPFromXFFHeader()
 
 	// Set the package-level configManagerRef
 	configManagerRef = configManager
@@ -77,6 +83,7 @@ func NewServer(
 		recorder:            recorder,
 		blockQueue:          blockQueue,
 		identityCache:       newIdentityCache(),
+		versionsCache:       newVersionsCache(),
 		payloadStorage:      payloadStorage,
 		phaseTracker:        phaseTracker,
 		epochGroupDataCache: internal.NewEpochGroupDataCache(recorder),
@@ -97,9 +104,9 @@ func NewServer(
 	g.GET("status", s.getStatus)
 	g.GET("identity", s.getIdentity)
 
-	g.POST("chat/completions", s.postChat)
-	g.POST("completions", s.postCompletions)
-	g.GET("chat/completions", s.getChatById)
+	g.POST("chat/completions", classicInferenceDeprecated)
+	g.POST("completions", classicInferenceDeprecated)
+	g.GET("chat/completions", classicInferenceDeprecated)
 	g.GET("inference/payloads", s.getInferencePayloads)
 
 	g.GET("participants/:address", s.getAccountByAddress)
@@ -110,6 +117,7 @@ func NewServer(
 	g.POST("verify-block", s.postVerifyBlock)
 
 	g.GET("pricing", s.getPricing)
+	g.GET("supply/total", s.getTotalSupply)
 	g.GET("models", s.getModels)
 	g.GET("governance/pricing", s.getGovernancePricing)
 	g.GET("governance/models", s.getGovernanceModels)
@@ -130,6 +138,7 @@ func NewServer(
 
 	g.GET("bridge/status", s.getBridgeStatus)
 	g.GET("bridge/addresses", s.getBridgeAddresses)
+	g.GET("bridge/block/latest", s.getLatestBridgeBlock)
 
 	g.GET("epochs/:epoch", s.getEpochById)
 	g.GET("epochs/:epoch/participants", s.getParticipantsByEpoch)
@@ -145,15 +154,16 @@ func NewServer(
 	g.GET("restrictions/exemptions", s.getRestrictionsExemptions)
 	g.GET("restrictions/exemptions/:id/usage/:account", s.getRestrictionsExemptionUsage)
 
-	// PoC proofs endpoint with IP rate limiting (100 req/min per IP)
+	// PoC proofs endpoint with IP rate limiting (300 req/min per IP)
 	pocProofsRateLimiter := echomw.RateLimiter(echomw.NewRateLimiterMemoryStoreWithConfig(
 		echomw.RateLimiterMemoryStoreConfig{
-			Rate:      300.0 / 60.0, // 100 requests per minute
+			Rate:      300.0 / 60.0, // 300 requests per minute
 			Burst:     30,
 			ExpiresIn: 3 * time.Minute,
 		},
 	))
 	g.POST("poc/proofs", s.postPocProofs, pocProofsRateLimiter)
+	g.POST("poc/proofs/by-nonce", s.postPocProofsByNonce, pocProofsRateLimiter)
 
 	// PoC artifact state endpoint (for testermint/validators to get real count and root_hash)
 	g.GET("poc/artifacts/state", s.getPocArtifactsState)
@@ -161,13 +171,27 @@ func NewServer(
 	v2 := e.Group("/v2/")
 	v2.GET("participants/:address", s.getParticipantByAddress)
 	v2.GET("accounts/:address", s.getAccountByAddress)
+	e.Any(deprecatedDevshardV1Prefix, legacyDevshardDeprecated)
+	e.Any(deprecatedDevshardV1Prefix+"/*", legacyDevshardDeprecated)
 	return s
 }
 
-// DevshardGroup returns an echo group for mounting devshard routes.
-// Mounted under /v1/devshard so nginx's existing /v1/ location proxies it.
-func (s *Server) DevshardGroup() *echo.Group {
-	return s.e.Group(devshard.LegacyRoutePrefix)
+func legacyDevshardDeprecated(c echo.Context) error {
+	c.Response().Header().Set("Deprecation", "true")
+	c.Response().Header().Set("Link", `</devshard/{version}>; rel="successor-version"`)
+	return c.JSON(http.StatusGone, map[string]string{
+		"error":   "deprecated",
+		"message": "/v1/devshard is deprecated; use /devshard/{version}",
+	})
+}
+
+func classicInferenceDeprecated(c echo.Context) error {
+	c.Response().Header().Set("Deprecation", "true")
+	c.Response().Header().Set("Link", `</devshard/{version}>; rel="successor-version"`)
+	return c.JSON(http.StatusGone, map[string]string{
+		"error":   "deprecated",
+		"message": "classic inference is deprecated; use devshard",
+	})
 }
 
 func (s *Server) Start(addr string) {
diff --git a/decentralized-api/internal/server/public/supply_handler.go b/decentralized-api/internal/server/public/supply_handler.go
new file mode 100644
index 0000000000..94a29675dc
--- /dev/null
+++ b/decentralized-api/internal/server/public/supply_handler.go
@@ -0,0 +1,113 @@
+package public
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/big"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/labstack/echo/v4"
+)
+
+const (
+	gonkaBaseDenom    = "ngonka"
+	gonkaDisplayScale = 9
+)
+
+type bankSupplyByDenomResponse struct {
+	Amount struct {
+		Denom  string `json:"denom"`
+		Amount string `json:"amount"`
+	} `json:"amount"`
+}
+
+func (s *Server) getTotalSupply(c echo.Context) error {
+	chainNodeURL := s.configManager.GetChainNodeConfig().Url
+	chainRESTURL, err := chainRESTURLFromRPCURL(chainNodeURL)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
+	}
+
+	client := s.httpClient
+	if client == nil {
+		client = NewNoRedirectClient(httpClientTimeout)
+	}
+
+	supply, err := fetchTotalSupplyGonka(c.Request().Context(), client, chainRESTURL)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadGateway, err.Error())
+	}
+
+	return c.String(http.StatusOK, supply)
+}
+
+func chainRESTURLFromRPCURL(rawURL string) (string, error) {
+	if strings.TrimSpace(rawURL) == "" {
+		return "http://localhost:1317", nil
+	}
+
+	parsed, err := url.Parse(rawURL)
+	if err != nil {
+		return "", fmt.Errorf("parse chain node url: %w", err)
+	}
+
+	parsed.Path = strings.TrimRight(parsed.Path, "/")
+	switch {
+	case strings.HasSuffix(parsed.Path, "/chain-rpc"):
+		parsed.Path = strings.TrimSuffix(parsed.Path, "/chain-rpc") + "/chain-api"
+	case parsed.Port() == "26657":
+		parsed.Host = net.JoinHostPort(parsed.Hostname(), "1317")
+	}
+	parsed.RawQuery = ""
+	parsed.Fragment = ""
+
+	return strings.TrimRight(parsed.String(), "/"), nil
+}
+
+func fetchTotalSupplyGonka(ctx context.Context, client *http.Client, chainRESTURL string) (string, error) {
+	endpoint := strings.TrimRight(chainRESTURL, "/") + "/cosmos/bank/v1beta1/supply/by_denom?denom=" + gonkaBaseDenom
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return "", fmt.Errorf("create total supply request: %w", err)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("query total supply: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return "", fmt.Errorf("read total supply response: %w", err)
+	}
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		return "", fmt.Errorf("chain total supply query failed: status=%d", resp.StatusCode)
+	}
+
+	var parsed bankSupplyByDenomResponse
+	if err := json.Unmarshal(body, &parsed); err != nil {
+		return "", fmt.Errorf("decode total supply response: %w", err)
+	}
+	if parsed.Amount.Denom != gonkaBaseDenom {
+		return "", fmt.Errorf("unexpected total supply denom %q", parsed.Amount.Denom)
+	}
+
+	return formatNgonkaAsGonka(parsed.Amount.Amount)
+}
+
+func formatNgonkaAsGonka(amount string) (string, error) {
+	ngonka, ok := new(big.Int).SetString(amount, 10)
+	if !ok || ngonka.Sign() < 0 {
+		return "", fmt.Errorf("invalid ngonka amount %q", amount)
+	}
+
+	scale := new(big.Int).Exp(big.NewInt(10), big.NewInt(gonkaDisplayScale), nil)
+	whole, fraction := new(big.Int).QuoRem(ngonka, scale, new(big.Int))
+	return fmt.Sprintf("%s.%0*s", whole.String(), gonkaDisplayScale, fraction.String()), nil
+}
diff --git a/decentralized-api/internal/server/public/supply_handler_test.go b/decentralized-api/internal/server/public/supply_handler_test.go
new file mode 100644
index 0000000000..9635dbbc9f
--- /dev/null
+++ b/decentralized-api/internal/server/public/supply_handler_test.go
@@ -0,0 +1,66 @@
+package public
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestChainRESTURLFromRPCURL(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "local rpc port",
+			in:   "http://node:26657",
+			want: "http://node:1317",
+		},
+		{
+			name: "public chain rpc path",
+			in:   "http://node1.gonka.ai:8000/chain-rpc/",
+			want: "http://node1.gonka.ai:8000/chain-api",
+		},
+		{
+			name: "empty defaults local rest",
+			in:   "",
+			want: "http://localhost:1317",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := chainRESTURLFromRPCURL(tt.in)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestFormatNgonkaAsGonka(t *testing.T) {
+	got, err := formatNgonkaAsGonka("90284028887366231")
+	require.NoError(t, err)
+	require.Equal(t, "90284028.887366231", got)
+
+	got, err = formatNgonkaAsGonka("1000000000")
+	require.NoError(t, err)
+	require.Equal(t, "1.000000000", got)
+}
+
+func TestFetchTotalSupplyGonka(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		require.Equal(t, "/cosmos/bank/v1beta1/supply/by_denom", r.URL.Path)
+		require.Equal(t, "ngonka", r.URL.Query().Get("denom"))
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"amount":{"denom":"ngonka","amount":"474030050545505610"}}`))
+	}))
+	defer server.Close()
+
+	got, err := fetchTotalSupplyGonka(context.Background(), server.Client(), server.URL)
+	require.NoError(t, err)
+	require.Equal(t, "474030050.545505610", got)
+}
diff --git a/decentralized-api/internal/startup/reward_recovery.go b/decentralized-api/internal/startup/reward_recovery.go
index 9c7ffe7f43..b2821bd79e 100644
--- a/decentralized-api/internal/startup/reward_recovery.go
+++ b/decentralized-api/internal/startup/reward_recovery.go
@@ -8,6 +8,8 @@ import (
 	"decentralized-api/internal/seed"
 	"decentralized-api/internal/validation"
 	"decentralized-api/logging"
+	"math"
+	"math/bits"
 	"sync/atomic"
 	"time"
 
@@ -137,7 +139,11 @@ func (c *RewardRecoveryChecker) AutoRewardRecovery() {
 	}
 
 	settleAmount := settleAmountResp.SettleAmount
-	totalAmount := settleAmount.RewardCoins + settleAmount.WorkCoins
+	sum, carry := bits.Add64(settleAmount.RewardCoins, settleAmount.WorkCoins, 0)
+	totalAmount := sum
+	if carry != 0 {
+		totalAmount = math.MaxUint64
+	}
 	logging.Info("[AutoRewardRecovery] Found settle amount for participant", types.Claims,
 		"address", address,
 		"rewardCoins", settleAmount.RewardCoins,
@@ -146,7 +152,7 @@ func (c *RewardRecoveryChecker) AutoRewardRecovery() {
 		"epochIndex", settleAmount.EpochIndex)
 
 	// Check if we have unclaimed rewards (totalAmount > 0 indicates pending rewards)
-	if totalAmount <= 0 {
+	if totalAmount == 0 {
 		logging.Info("[AutoRewardRecovery] No unclaimed rewards found", types.Claims, "address", address, "totalAmount", totalAmount)
 		return
 	}
diff --git a/decentralized-api/internal/validation/inference_validation.go b/decentralized-api/internal/validation/inference_validation.go
index 01ca691fe9..f021dadd16 100644
--- a/decentralized-api/internal/validation/inference_validation.go
+++ b/decentralized-api/internal/validation/inference_validation.go
@@ -107,9 +107,9 @@ func (s *InferenceValidator) shouldValidateInference(
 	shouldValidate, message := calculations.ShouldValidate(
 		seed,
 		inferenceDetails,
-		uint32(inferenceDetails.TotalPower),
-		uint32(validatorPower),
-		uint32(inferenceDetails.ExecutorPower),
+		inferenceDetails.TotalPower,
+		validatorPower,
+		inferenceDetails.ExecutorPower,
 		validationParams,
 		false)
 
diff --git a/decentralized-api/internal/validation/payload_retrieval_test.go b/decentralized-api/internal/validation/payload_retrieval_test.go
index 8a4365e558..036b258155 100644
--- a/decentralized-api/internal/validation/payload_retrieval_test.go
+++ b/decentralized-api/internal/validation/payload_retrieval_test.go
@@ -11,18 +11,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestBuildPayloadRequestURL_DevshardPath(t *testing.T) {
-	// Test with devshard session-specific path
-	url, err := BuildPayloadRequestURL("https://executor.example.com", devshardpkg.LegacySessionPayloadPath("escrow-123"), "456")
-	require.NoError(t, err)
-	assert.Contains(t, url, devshardpkg.LegacySessionPayloadPath("escrow-123"))
-	assert.Contains(t, url, "inference_id=456")
-}
-
 func TestBuildPayloadRequestURL_VersionedDevshardPath(t *testing.T) {
-	url, err := BuildPayloadRequestURL("https://executor.example.com", devshardpkg.VersionedSessionPayloadPath("v1", "escrow-123"), "456")
+	url, err := BuildPayloadRequestURL("https://executor.example.com", devshardpkg.VersionedSessionPayloadPath("dev", "escrow-123"), "456")
 	require.NoError(t, err)
-	assert.Contains(t, url, devshardpkg.VersionedSessionPayloadPath("v1", "escrow-123"))
+	assert.Contains(t, url, devshardpkg.VersionedSessionPayloadPath("dev", "escrow-123"))
 	assert.Contains(t, url, "inference_id=456")
 }
 
diff --git a/decentralized-api/main.go b/decentralized-api/main.go
index 930988c484..d92b51606e 100644
--- a/decentralized-api/main.go
+++ b/decentralized-api/main.go
@@ -17,6 +17,7 @@ import (
 	"decentralized-api/payloadstorage"
 	"decentralized-api/poc"
 	"decentralized-api/poc/artifacts"
+	"decentralized-api/poc/earlyshare"
 	"decentralized-api/statsstorage"
 	"net"
 
@@ -33,9 +34,7 @@ import (
 	"decentralized-api/participant"
 	devshardlogging "devshard/logging"
 	devshardobservability "devshard/observability"
-	devshardstorage "devshard/storage"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"log"
 	"log/slog"
@@ -45,10 +44,38 @@ import (
 	"time"
 
 	"github.com/productscience/inference/x/inference/types"
-
-	devshardbridge "devshard/bridge"
 )
 
+// buildEarlyShareGuard constructs the DAPI-only early-share guard from config.
+// Returns nil (a valid disabled guard) when disabled or when the local sqlite
+// database is unavailable.
+func buildEarlyShareGuard(configManager *apiconfig.ConfigManager) *poc.EarlyShareGuard {
+	esgCfg := configManager.GetEarlyShareGuardConfig()
+	cfg := earlyshare.Config{
+		Mode:                  earlyshare.Mode(esgCfg.Mode),
+		FirstFraction:         esgCfg.FirstFraction,
+		ThresholdRatio:        esgCfg.ThresholdRatio,
+		RequireInclusionProof: esgCfg.RequireInclusionProof,
+		InclusionSampleSize:   esgCfg.InclusionSampleSize,
+	}.Normalized()
+	if !cfg.Enabled() {
+		return nil
+	}
+
+	sqlDb := configManager.SqlDb()
+	if sqlDb == nil || sqlDb.GetDb() == nil {
+		logging.Warn("Early-share guard enabled but sqlite db unavailable; disabling", types.PoC)
+		return nil
+	}
+
+	store := earlyshare.NewStore(sqlDb.GetDb())
+	if err := store.EnsureSchema(context.Background()); err != nil {
+		logging.Error("Failed to initialize early-share guard schema; disabling", types.PoC, "error", err)
+		return nil
+	}
+	return poc.NewEarlyShareGuard(cfg, store)
+}
+
 func main() {
 	if len(os.Args) >= 2 && os.Args[1] == "status" {
 		logging.WithNoopLogger(func() (interface{}, error) {
@@ -142,6 +169,25 @@ func main() {
 		"address", participantInfo.GetAddress(),
 		"pubkey", participantInfo.GetPubKey())
 
+	// DAPI-only early-share guard (disabled by default). When enabled it reuses
+	// the embedded sqlite db for local persistence. See
+	// proposals/poc/early-share-guard-dapi.md.
+	earlyGuard := buildEarlyShareGuard(configManager)
+
+	// Shared managed artifact store for off-chain PoC (used by the validator,
+	// commit worker, and the mlnode/public servers). Manages per-height
+	// directories with automatic pruning (retains last 10). Created before the
+	// validator so the event listener never observes a partially wired validator.
+	artifactStore := artifacts.NewManagedArtifactStore("/root/.dapi/data/poc-artifacts", 10)
+	defer artifactStore.Close()
+
+	// Prune early-share guard checkpoints on the same stage cadence as artifacts.
+	if earlyGuard.Enabled() {
+		artifactStore.AddPruneHook(func(stage int64) {
+			earlyGuard.DeleteStage(context.Background(), stage)
+		})
+	}
+
 	offChainValidator := poc.NewOffChainValidator(
 		recorder,
 		nodeBroker,
@@ -151,8 +197,10 @@ func main() {
 		participantInfo.GetAddress(),
 		configManager.GetChainNodeConfig().Url,
 		poc.DefaultValidationConfig(),
+		earlyGuard,
+		artifactStore,
 	)
-	logging.Info("PoC off-chain validator initialized", types.PoC)
+	logging.Info("PoC off-chain validator initialized", types.PoC, "earlyShareGuardEnabled", earlyGuard.Enabled())
 
 	// Create a cancellable context for the entire system
 	ctx, cancel := context.WithCancel(context.Background())
@@ -221,7 +269,7 @@ func main() {
 	logging.Info("start public server on addr", types.Server, "addr", addr)
 
 	// Bridge external block queue
-	blockQueue := pserver.NewBlockQueue(recorder)
+	blockQueue := pserver.NewBlockQueue(recorder, configManager.SqlDb().GetDb())
 
 	// Shared payload storage for both public and admin servers
 	// Uses PostgreSQL if PGHOST is set and accessible, otherwise file-based
@@ -232,11 +280,6 @@ func main() {
 		3*time.Minute, // cache TTL
 	)
 
-	// Shared managed artifact store for off-chain PoC (used by both mlnode and public servers)
-	// Manages per-height directories with automatic pruning (retains last 10)
-	artifactStore := artifacts.NewManagedArtifactStore("/root/.dapi/data/poc-artifacts", 10)
-	defer artifactStore.Close()
-
 	// Create commit worker for time-based artifact commits and weight distribution
 	// Worker owns flush lifecycle, commits periodically (not per-request), and handles distribution
 	batchingCfg := configManager.GetTxBatchingConfig()
@@ -244,11 +287,6 @@ func main() {
 	commitWorker := poc.NewCommitWorker(artifactStore, recorder, chainPhaseTracker, participantInfo.GetAddress(), commitInterval)
 	defer commitWorker.Close()
 
-	devshardSigner, devshardSignerErr := internaldevshard.NewSignerFromKeyring(*recorder.GetKeyring(), recorder.GetApiAccount().SignerAccount.Name)
-	if devshardSignerErr != nil {
-		logging.Error("devshard signer init failed", types.System, "error", devshardSignerErr)
-	}
-
 	publicServer := pserver.NewServer(
 		nodeBroker,
 		configManager,
@@ -260,63 +298,6 @@ func main() {
 		pserver.WithStatsStorage(statsStore),
 	)
 
-	if devshardSigner != nil {
-		devshardBridge := internaldevshard.NewChainBridge(recorder)
-		httpClient := pserver.NewNoRedirectClient(internaldevshard.MLNodeHTTPTimeout)
-		chainParams := &configParamsProvider{cm: configManager}
-		devshardEngine := internaldevshard.NewEngineAdapter(nodeBroker, configManager.GetCurrentNodeVersion(), payloadStore, chainPhaseTracker, httpClient, chainParams)
-		devshardValidator := internaldevshard.NewValidationAdapter(nodeBroker, configManager.GetCurrentNodeVersion(), chainPhaseTracker, httpClient, devshardBridge, recorder, chainParams)
-
-		// Per-epoch SQLite under /root/.dapi/data/devshard/, or shared Postgres
-		// (same PG vars as payloadstorage) when PGHOST is set. ManagedStorage
-		// runs the background pruner with N=3 retention.
-		// TODO: move to DevshardConfig when config consolidation happens.
-		const devshardDir = "/root/.dapi/data/devshard"
-		const devshardLegacyDB = "/root/.dapi/data/devshard.db"
-		devshardInner, storeErr := devshardstorage.NewStorage(ctx, devshardDir)
-		if storeErr != nil {
-			logging.Error("devshard storage init failed", types.System, "error", storeErr)
-		} else {
-			devshardStore := devshardstorage.NewManagedStorage(devshardInner, 3, &chainPhaseEpochProvider{tracker: chainPhaseTracker})
-			defer devshardStore.Close()
-
-			configManager.SetEpochChangeHandler(func(_, _ uint64) {
-				devshardStore.PruneOnceAsync(ctx)
-			})
-
-			hostManager := internaldevshard.NewHostManager(devshardStore, devshardSigner, devshardEngine, devshardValidator, "v1", devshardBridge, payloadStore, recorder)
-			hostManager.SetAvailabilityProvider(internaldevshard.NewConfigManagerAvailability(configManager, chainPhaseTracker))
-			hostManager.SetMaxNonceProvider(internaldevshard.ConfigManagerMaxNonce(configManager))
-			hostManager.SetRuntimeParamsProvider(internaldevshard.ConfigManagerRuntimeParams(configManager))
-			hostManager.Register(publicServer.DevshardGroup())
-			go func() {
-				migrated, mErr := devshardstorage.MigrateLegacySQLite(devshardLegacyDB, devshardInner, func(escrowID string) (uint64, error) {
-					info, err := devshardBridge.GetEscrow(escrowID)
-					if err != nil {
-						if errors.Is(err, devshardbridge.ErrEscrowNotFound) {
-							return 0, devshardstorage.ErrSkipLegacySession
-						}
-						return 0, err
-					}
-					return info.EpochID, nil
-				})
-				if mErr != nil {
-					logging.Error("devshard legacy migration failed", types.System, "error", mErr)
-					hostManager.SetUnavailable(mErr)
-					return
-				}
-				if migrated > 0 {
-					logging.Info("devshard legacy migration complete", types.System, "sessions_migrated", migrated)
-				}
-
-				devshardStore.Start()
-				hostManager.SetReady()
-				if err := hostManager.RecoverSessions(); err != nil {
-					logging.Error("devshard recovery failed", types.System, "error", err)
-				}
-			}()
-		}
-	}
 	publicServer.Start(addr)
 
 	addr = fmt.Sprintf(":%v", configManager.GetApiConfig().MLServerPort)
@@ -404,35 +385,3 @@ func getParams(ctx context.Context, transactionRecorder cosmosclient.InferenceCo
 	logging.Error("Exhausted all retries to get chain params", types.System, "error", err)
 	return nil, err
 }
-
-// configParamsProvider implements internaldevshard.ChainParamsProvider by
-// reading from dapi's ConfigManager, which syncs chain params every block.
-type configParamsProvider struct {
-	cm *apiconfig.ConfigManager
-}
-
-func (p *configParamsProvider) LogprobsMode() string {
-	mode := p.cm.GetValidationParams().LogprobsMode
-	if mode == "" {
-		return types.DefaultLogprobsMode
-	}
-	return mode
-}
-
-// chainPhaseEpochProvider exposes the current chain epoch to ManagedStorage
-// so the pruner advances the retention horizon even when the host has no
-// CreateSession activity to bump max_observed_epoch from.
-type chainPhaseEpochProvider struct {
-	tracker *chainphase.ChainPhaseTracker
-}
-
-func (p *chainPhaseEpochProvider) CurrentEpochID() uint64 {
-	if p.tracker == nil {
-		return 0
-	}
-	st := p.tracker.GetCurrentEpochState()
-	if st == nil {
-		return 0
-	}
-	return st.LatestEpoch.EpochIndex
-}
diff --git a/decentralized-api/mlnodeclient/client.go b/decentralized-api/mlnodeclient/client.go
index 29372fb240..196e56b2a5 100644
--- a/decentralized-api/mlnodeclient/client.go
+++ b/decentralized-api/mlnodeclient/client.go
@@ -61,8 +61,9 @@ const (
 )
 
 type StateResponse struct {
-	State   MLNodeState `json:"state"`
-	Version string      `json:"version"`
+	State                  MLNodeState `json:"state"`
+	Version                string      `json:"version"`
+	PoCValidationInference bool        `json:"poc_validation_inference"`
 }
 
 func (api *Client) NodeState(ctx context.Context) (*StateResponse, error) {
diff --git a/decentralized-api/mlnodeclient/mock.go b/decentralized-api/mlnodeclient/mock.go
index b854b1261c..e00e77c38e 100644
--- a/decentralized-api/mlnodeclient/mock.go
+++ b/decentralized-api/mlnodeclient/mock.go
@@ -59,16 +59,17 @@ type MockClient struct {
 	StopPowV2Called      int
 
 	// PoC v2 state
-	PowStatusV2 string // "IDLE", "GENERATING", etc.
+	PowStatusV2            string // "IDLE", "GENERATING", etc.
+	PoCValidationInference bool
 
 	// Capture parameters
 	LastInferenceModel    string
 	LastInferenceArgs     []string
 	LastInitGenerateV2Req *PoCInitGenerateRequestV2
 	LastGenerateV2Req     *PoCGenerateRequestV2
-	LastModelStatusCheck *Model
-	LastModelDownload    *Model
-	LastModelDelete      *Model
+	LastModelStatusCheck  *Model
+	LastModelDownload     *Model
+	LastModelDelete       *Model
 }
 
 // NewMockClient creates a new mock client with default values
@@ -173,6 +174,7 @@ func (m *MockClient) Reset() {
 	m.LastModelDownload = nil
 	m.LastModelDelete = nil
 	m.PowStatusV2 = ""
+	m.PoCValidationInference = false
 }
 
 func (m *MockClient) Stop(ctx context.Context) error {
@@ -196,7 +198,10 @@ func (m *MockClient) NodeState(ctx context.Context) (*StateResponse, error) {
 	if m.NodeStateError != nil {
 		return nil, m.NodeStateError
 	}
-	return &StateResponse{State: m.CurrentState}, nil
+	return &StateResponse{
+		State:                  m.CurrentState,
+		PoCValidationInference: m.PoCValidationInference,
+	}, nil
 }
 
 func (m *MockClient) InferenceHealth(ctx context.Context) (bool, error) {
diff --git a/decentralized-api/mlnodeclient/node_state_test.go b/decentralized-api/mlnodeclient/node_state_test.go
new file mode 100644
index 0000000000..b7ea21ba5e
--- /dev/null
+++ b/decentralized-api/mlnodeclient/node_state_test.go
@@ -0,0 +1,44 @@
+package mlnodeclient
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestNodeState_ParsesPocValidationInference(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/v1/state" {
+			http.Error(w, "bad path", http.StatusNotFound)
+			return
+		}
+		w.Write([]byte(`{"state":"INFERENCE","version":"0.2.0","poc_validation_inference":true}`))
+	}))
+	defer srv.Close()
+
+	c := NewNodeClient(srv.URL, srv.URL)
+	resp, err := c.NodeState(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if !resp.PoCValidationInference {
+		t.Fatalf("expected poc_validation_inference=true: %+v", resp)
+	}
+}
+
+func TestNodeState_MissingPocValidationInferenceFailsClosed(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte(`{"state":"INFERENCE","version":"0.2.0"}`))
+	}))
+	defer srv.Close()
+
+	c := NewNodeClient(srv.URL, srv.URL)
+	resp, err := c.NodeState(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if resp.PoCValidationInference {
+		t.Fatalf("expected missing poc_validation_inference to decode false: %+v", resp)
+	}
+}
diff --git a/decentralized-api/poc/artifacts/interface.go b/decentralized-api/poc/artifacts/interface.go
new file mode 100644
index 0000000000..ca99ac10e2
--- /dev/null
+++ b/decentralized-api/poc/artifacts/interface.go
@@ -0,0 +1,69 @@
+package artifacts
+
+// ProofEntry is a snapshot-consistent artifact plus its SMST proof.
+type ProofEntry struct {
+	DenseIndex uint32
+	Nonce      int32
+	Vector     []byte
+	Proof      [][]byte
+}
+
+// ArtifactStore defines the interface for PoC artifact storage with Merkle commitments.
+// Implementations must be safe for concurrent use.
+//
+// All read operations that return artifacts or proofs require a snapshot count parameter.
+// This is critical for SMST correctness: the dense index to nonce mapping depends on tree state.
+// Unlike MMR where leaf positions were stable, SMST dense indices change as leaves are added.
+type ArtifactStore interface {
+	// AddWithNode appends an artifact and tracks which node contributed it.
+	// Returns ErrDuplicateNonce if nonce already exists.
+	AddWithNode(nonce int32, vector []byte, nodeId string) error
+
+	// GetRootAt returns the root hash at a specific snapshot count.
+	// Returns nil if snapshotCount is 0, error if snapshotCount exceeds current count.
+	GetRootAt(snapshotCount uint32) ([]byte, error)
+
+	// GetFlushedRoot returns the root and count of ONLY persisted artifacts.
+	// Safe to report externally - survives process crashes.
+	GetFlushedRoot() (count uint32, root []byte)
+
+	// GetNodeDistributionAt returns node distribution at a specific count.
+	// Returns exact=true if found in history, exact=false if simulated.
+	// Simulated distribution is scaled proportionally and sums to count.
+	GetNodeDistributionAt(count uint32) (distribution map[string]uint32, exact bool, err error)
+
+	// GetNodeCounts returns current (unflushed) node distribution.
+	GetNodeCounts() map[string]uint32
+
+	// Count returns the total number of artifacts (including unflushed).
+	Count() uint32
+
+	// GetArtifactAndProof retrieves artifact and proof for a dense index at a specific snapshot.
+	// This is the ONLY way to retrieve artifacts - snapshot awareness is mandatory for SMST.
+	// Dense index is the sequential position [0, snapshotCount) computed from sibling counts.
+	GetArtifactAndProof(denseIndex uint32, snapshotCount uint32) (nonce int32, vector []byte, proof [][]byte, err error)
+
+	// GetArtifactsAndProofs retrieves artifacts and proofs for dense indices at a specific snapshot.
+	GetArtifactsAndProofs(denseIndices []uint32, snapshotCount uint32) ([]ProofEntry, error)
+
+	// GetArtifactAndProofByNonce retrieves artifact and proof for a nonce at a specific snapshot.
+	// It returns the nonce's dense index in that snapshot, computed from sibling counts.
+	GetArtifactAndProofByNonce(nonce int32, snapshotCount uint32) (denseIndex uint32, vector []byte, proof [][]byte, err error)
+
+	// GetArtifactsAndProofsByNonce retrieves artifacts and proofs for nonces at a specific snapshot.
+	// Nonces absent from the snapshot are omitted from the result.
+	GetArtifactsAndProofsByNonce(nonces []int32, snapshotCount uint32) ([]ProofEntry, error)
+
+	// Flush persists buffered artifacts to disk.
+	Flush() error
+
+	// Close flushes and releases resources.
+	Close() error
+
+	// PrebuildSnapshot builds and caches tree state at specified count for fast proofs.
+	PrebuildSnapshot(count uint32) error
+
+	// WarmSnapshot builds and pins the snapshot tree for count so later proof
+	// requests hit the cache. Blocking; callers run it in the background.
+	WarmSnapshot(count uint32)
+}
diff --git a/decentralized-api/poc/artifacts/managed_store.go b/decentralized-api/poc/artifacts/managed_store.go
index 0d73fc6f9e..eaafdeeb94 100644
--- a/decentralized-api/poc/artifacts/managed_store.go
+++ b/decentralized-api/poc/artifacts/managed_store.go
@@ -22,10 +22,43 @@ import (
 type ManagedArtifactStore struct {
 	mu          sync.RWMutex
 	baseDir     string
-	stores      map[storeKey]*ArtifactStore
+	stores      map[storeKey]ArtifactStore
 	retainCount int
 	cancel      context.CancelFunc
 	flushCancel context.CancelFunc
+	// pruneHooks are invoked (best-effort) with the stage height whenever a
+	// stage is pruned. Used to ride other DAPI-local stage data (e.g. the
+	// early-share guard's checkpoints) on the same retention cadence.
+	pruneHooks []func(stageHeight int64)
+}
+
+// AddPruneHook registers a callback invoked with the stage height each time a
+// stage is pruned. Hooks must be added before pruning begins (i.e. at wiring
+// time) and should not block.
+func (m *ManagedArtifactStore) AddPruneHook(fn func(stageHeight int64)) {
+	if fn == nil {
+		return
+	}
+	m.withWriteLock(func() {
+		m.pruneHooks = append(m.pruneHooks, fn)
+	})
+}
+
+func (m *ManagedArtifactStore) runPruneHooks(stageHeight int64) {
+	var hooks []func(stageHeight int64)
+	m.withReadLock(func() {
+		hooks = append(hooks, m.pruneHooks...)
+	})
+	for _, fn := range hooks {
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					logging.Warn("ManagedArtifactStore: prune hook panicked", types.PoC, "stage", stageHeight, "panic", r)
+				}
+			}()
+			fn(stageHeight)
+		}()
+	}
 }
 
 type storeKey struct {
@@ -35,7 +68,7 @@ type storeKey struct {
 
 type StageModelStore struct {
 	ModelID string
-	Store   *ArtifactStore
+	Store   ArtifactStore
 }
 
 func (m *ManagedArtifactStore) withReadLock(fn func()) {
@@ -50,9 +83,9 @@ func (m *ManagedArtifactStore) withWriteLock(fn func()) {
 	fn()
 }
 
-func (m *ManagedArtifactStore) getCachedStore(key storeKey) (*ArtifactStore, bool) {
+func (m *ManagedArtifactStore) getCachedStore(key storeKey) (ArtifactStore, bool) {
 	var (
-		store *ArtifactStore
+		store ArtifactStore
 		ok    bool
 	)
 	m.withReadLock(func() {
@@ -61,9 +94,9 @@ func (m *ManagedArtifactStore) getCachedStore(key storeKey) (*ArtifactStore, boo
 	return store, ok
 }
 
-func (m *ManagedArtifactStore) putStoreIfAbsent(key storeKey, store *ArtifactStore) (*ArtifactStore, bool) {
+func (m *ManagedArtifactStore) putStoreIfAbsent(key storeKey, store ArtifactStore) (ArtifactStore, bool) {
 	var (
-		existing *ArtifactStore
+		existing ArtifactStore
 		loaded   bool
 	)
 	m.withWriteLock(func() {
@@ -76,10 +109,10 @@ func (m *ManagedArtifactStore) putStoreIfAbsent(key storeKey, store *ArtifactSto
 	return existing, loaded
 }
 
-func (m *ManagedArtifactStore) snapshotStores() []*ArtifactStore {
-	var stores []*ArtifactStore
+func (m *ManagedArtifactStore) snapshotStores() []ArtifactStore {
+	var stores []ArtifactStore
 	m.withReadLock(func() {
-		stores = make([]*ArtifactStore, 0, len(m.stores))
+		stores = make([]ArtifactStore, 0, len(m.stores))
 		for _, store := range m.stores {
 			stores = append(stores, store)
 		}
@@ -104,8 +137,8 @@ func (m *ManagedArtifactStore) snapshotStageModelIDs(pocStageStartHeight int64)
 	return modelIDs
 }
 
-func (m *ManagedArtifactStore) removeStageStores(pocStageStartHeight int64) []*ArtifactStore {
-	var stores []*ArtifactStore
+func (m *ManagedArtifactStore) removeStageStores(pocStageStartHeight int64) []ArtifactStore {
+	var stores []ArtifactStore
 	m.withWriteLock(func() {
 		for key, store := range m.stores {
 			if key.stage != pocStageStartHeight {
@@ -120,24 +153,24 @@ func (m *ManagedArtifactStore) removeStageStores(pocStageStartHeight int64) []*A
 
 func (m *ManagedArtifactStore) drainStores() []struct {
 	key   storeKey
-	store *ArtifactStore
+	store ArtifactStore
 } {
 	var stores []struct {
 		key   storeKey
-		store *ArtifactStore
+		store ArtifactStore
 	}
 	m.withWriteLock(func() {
 		stores = make([]struct {
 			key   storeKey
-			store *ArtifactStore
+			store ArtifactStore
 		}, 0, len(m.stores))
 		for key, store := range m.stores {
 			stores = append(stores, struct {
 				key   storeKey
-				store *ArtifactStore
+				store ArtifactStore
 			}{key: key, store: store})
 		}
-		m.stores = make(map[storeKey]*ArtifactStore)
+		m.stores = make(map[storeKey]ArtifactStore)
 	})
 	return stores
 }
@@ -148,7 +181,7 @@ func NewManagedArtifactStore(baseDir string, retainCount int) *ManagedArtifactSt
 	ctx, cancel := context.WithCancel(context.Background())
 	m := &ManagedArtifactStore{
 		baseDir:     baseDir,
-		stores:      make(map[storeKey]*ArtifactStore),
+		stores:      make(map[storeKey]ArtifactStore),
 		retainCount: retainCount,
 		cancel:      cancel,
 	}
@@ -187,7 +220,7 @@ func decodeModelID(encoded string) (string, error) {
 }
 
 // GetOrCreateStore returns the store for the given PoC stage/model, creating it if needed.
-func (m *ManagedArtifactStore) GetOrCreateStore(pocStageStartHeight int64, modelID string) (*ArtifactStore, error) {
+func (m *ManagedArtifactStore) GetOrCreateStore(pocStageStartHeight int64, modelID string) (ArtifactStore, error) {
 	key, err := m.storeKey(pocStageStartHeight, modelID)
 	if err != nil {
 		return nil, err
@@ -198,7 +231,7 @@ func (m *ManagedArtifactStore) GetOrCreateStore(pocStageStartHeight int64, model
 	}
 
 	storeDir := m.modelDir(pocStageStartHeight, modelID)
-	store, err := Open(storeDir)
+	store, err := OpenSMST(storeDir)
 	if err != nil {
 		return nil, fmt.Errorf("open store for stage %d model %q: %w", pocStageStartHeight, modelID, err)
 	}
@@ -214,7 +247,7 @@ func (m *ManagedArtifactStore) GetOrCreateStore(pocStageStartHeight int64, model
 
 // GetStore returns the store for the given PoC stage/model, or an error if it doesn't exist.
 // Does not create new stores (for proof requests).
-func (m *ManagedArtifactStore) GetStore(pocStageStartHeight int64, modelID string) (*ArtifactStore, error) {
+func (m *ManagedArtifactStore) GetStore(pocStageStartHeight int64, modelID string) (ArtifactStore, error) {
 	key, err := m.storeKey(pocStageStartHeight, modelID)
 	if err != nil {
 		return nil, err
@@ -231,7 +264,7 @@ func (m *ManagedArtifactStore) GetStore(pocStageStartHeight int64, modelID strin
 		return nil, fmt.Errorf("store for stage %d model %q not found", pocStageStartHeight, modelID)
 	}
 
-	store, err = Open(storeDir)
+	store, err = OpenSMST(storeDir)
 	if err != nil {
 		return nil, fmt.Errorf("open store for stage %d model %q: %w", pocStageStartHeight, modelID, err)
 	}
@@ -311,6 +344,8 @@ func (m *ManagedArtifactStore) PruneStore(pocStageStartHeight int64) error {
 		errs = append(errs, fmt.Errorf("remove store dir: %w", err))
 	}
 
+	m.runPruneHooks(pocStageStartHeight)
+
 	logging.Info("Pruned artifact store", types.PoC, "height", pocStageStartHeight)
 	if len(errs) > 0 {
 		return fmt.Errorf("prune store errors: %v", errs)
diff --git a/decentralized-api/poc/artifacts/managed_store_test.go b/decentralized-api/poc/artifacts/managed_store_test.go
index 3309de70f7..dbff13c787 100644
--- a/decentralized-api/poc/artifacts/managed_store_test.go
+++ b/decentralized-api/poc/artifacts/managed_store_test.go
@@ -68,7 +68,7 @@ func TestManagedArtifactStore_GetStore_ExistingDir(t *testing.T) {
 	if err != nil {
 		t.Fatalf("GetOrCreateStore failed: %v", err)
 	}
-	if err := store.Add(1, []byte("test")); err != nil {
+	if err := store.AddWithNode(1, []byte("test"), ""); err != nil {
 		t.Fatalf("Add failed: %v", err)
 	}
 	if err := m1.Flush(); err != nil {
@@ -99,7 +99,7 @@ func TestManagedArtifactStore_GetStoresForStage(t *testing.T) {
 		if err != nil {
 			t.Fatalf("GetOrCreateStore(%q) failed: %v", modelID, err)
 		}
-		if err := store.Add(1, []byte(modelID)); err != nil {
+		if err := store.AddWithNode(1, []byte(modelID), ""); err != nil {
 			t.Fatalf("Add failed for %q: %v", modelID, err)
 		}
 	}
@@ -239,7 +239,7 @@ func TestManagedArtifactStore_Flush(t *testing.T) {
 		t.Fatalf("GetOrCreateStore failed: %v", err)
 	}
 
-	if err := store.Add(1, []byte("test")); err != nil {
+	if err := store.AddWithNode(1, []byte("test"), ""); err != nil {
 		t.Fatalf("Add failed: %v", err)
 	}
 
@@ -335,7 +335,7 @@ func TestManagedArtifactStore_ParallelModelStores(t *testing.T) {
 				return
 			}
 
-			nodeCounts := store.GetNodeDistribution()
+			nodeCounts := store.GetNodeCounts()
 			expectedNodeID := fmt.Sprintf("node-%02d", modelIdx)
 			if nodeCounts[expectedNodeID] != writesPerModel {
 				readErrs <- fmt.Errorf("GetNodeDistribution(%s): expected %d for %s, got %d", modelID, writesPerModel, expectedNodeID, nodeCounts[expectedNodeID])
@@ -343,7 +343,7 @@ func TestManagedArtifactStore_ParallelModelStores(t *testing.T) {
 			}
 
 			for _, offset := range []uint32{0, writesPerModel / 2, writesPerModel - 1} {
-				nonce, vector, err := store.GetArtifact(offset)
+				nonce, vector, _, err := store.GetArtifactAndProof(offset, writesPerModel)
 				if err != nil {
 					readErrs <- fmt.Errorf("GetArtifact(%s, %d): %w", modelID, offset, err)
 					return
diff --git a/decentralized-api/poc/artifacts/mmr.go b/decentralized-api/poc/artifacts/mmr.go
deleted file mode 100644
index 4fe36bb1aa..0000000000
--- a/decentralized-api/poc/artifacts/mmr.go
+++ /dev/null
@@ -1,378 +0,0 @@
-package artifacts
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"math/bits"
-)
-
-const (
-	leafPrefix     = 0x00
-	internalPrefix = 0x01
-)
-
-func hashLeaf(data []byte) []byte {
-	h := sha256.New()
-	h.Write([]byte{leafPrefix})
-	h.Write(data)
-	return h.Sum(nil)
-}
-
-func hashNode(left, right []byte) []byte {
-	h := sha256.New()
-	h.Write([]byte{internalPrefix})
-	h.Write(left)
-	h.Write(right)
-	return h.Sum(nil)
-}
-
-// appendToMMR appends a leaf hash to the MMR nodes slice.
-// leafIndex is the 0-based index of the leaf being added.
-func appendToMMR(nodes *[][]byte, leafHash []byte, leafIndex uint32) {
-	*nodes = append(*nodes, leafHash)
-	currentHash := leafHash
-
-	// Number of merges = trailing zeros in (leafIndex + 1)
-	newLeafCount := leafIndex + 1
-	merges := bits.TrailingZeros32(newLeafCount)
-
-	for i := 0; i < merges; i++ {
-		siblingOffset := (1 << (i + 1)) - 1
-		siblingPos := len(*nodes) - 1 - siblingOffset
-
-		if siblingPos < 0 {
-			break
-		}
-
-		siblingHash := (*nodes)[siblingPos]
-		parentHash := hashNode(siblingHash, currentHash)
-		*nodes = append(*nodes, parentHash)
-		currentHash = parentHash
-	}
-}
-
-// mmrSizeForLeaves returns the total number of MMR nodes for n leaves.
-// Formula: 2n - popcount(n)
-func mmrSizeForLeaves(n uint32) int {
-	if n == 0 {
-		return 0
-	}
-	return int(2*n) - bits.OnesCount32(n)
-}
-
-// bagPeaks computes the root hash by bagging peaks from right to left.
-func bagPeaks(nodes [][]byte, leafCount uint32) []byte {
-	if leafCount == 0 {
-		return nil
-	}
-
-	peaks := getPeaks(nodes, leafCount)
-	if len(peaks) == 0 {
-		return nil
-	}
-
-	root := peaks[len(peaks)-1]
-	for i := len(peaks) - 2; i >= 0; i-- {
-		root = hashNode(peaks[i], root)
-	}
-	return root
-}
-
-// getPeaks returns the peak hashes for an MMR with the given leaf count.
-func getPeaks(nodes [][]byte, leafCount uint32) [][]byte {
-	if leafCount == 0 {
-		return nil
-	}
-
-	peaks := make([][]byte, 0, bits.OnesCount32(leafCount))
-	peakPositions := getPeakPositions(leafCount)
-
-	for _, pos := range peakPositions {
-		if pos < len(nodes) {
-			peaks = append(peaks, nodes[pos])
-		}
-	}
-
-	return peaks
-}
-
-// getPeakPositions returns the positions of peaks for the given leaf count.
-func getPeakPositions(leafCount uint32) []int {
-	if leafCount == 0 {
-		return nil
-	}
-
-	positions := make([]int, 0, bits.OnesCount32(leafCount))
-	pos := 0
-	remaining := leafCount
-
-	for remaining > 0 {
-		height := bits.Len32(remaining) - 1
-		treeLeaves := uint32(1) << height
-		treeSize := mmrSizeForLeaves(treeLeaves)
-		peakPos := pos + treeSize - 1
-		positions = append(positions, peakPos)
-		pos += treeSize
-		remaining -= treeLeaves
-	}
-
-	return positions
-}
-
-// leafPositionInMMR converts a 0-based leaf index to its position in the MMR array.
-func leafPositionInMMR(leafIndex uint32) int {
-	if leafIndex == 0 {
-		return 0
-	}
-	return mmrSizeForLeaves(leafIndex)
-}
-
-// generateProof generates a merkle proof for leafIndex at the given snapshot count.
-func generateProof(nodes [][]byte, leafIndex uint32, snapshotCount uint32) ([][]byte, error) {
-	if snapshotCount == 0 || leafIndex >= snapshotCount {
-		return nil, ErrLeafIndexOutOfRange
-	}
-
-	maxNodes := mmrSizeForLeaves(snapshotCount)
-	if maxNodes > len(nodes) {
-		return nil, ErrLeafIndexOutOfRange
-	}
-
-	proof := make([][]byte, 0, 32)
-
-	// Find which mountain contains this leaf and collect siblings
-	mountainStart := 0
-	remaining := snapshotCount
-	localLeafIdx := leafIndex
-
-	for remaining > 0 {
-		height := bits.Len32(remaining) - 1
-		mountainLeaves := uint32(1) << height
-		mountainSize := mmrSizeForLeaves(mountainLeaves)
-
-		if localLeafIdx < mountainLeaves {
-			// Leaf is in this mountain - collect path siblings
-			siblings := collectSiblingsInMountain(nodes, mountainStart, height, localLeafIdx)
-			proof = append(proof, siblings...)
-			break
-		}
-
-		mountainStart += mountainSize
-		localLeafIdx -= mountainLeaves
-		remaining -= mountainLeaves
-	}
-
-	// Add other peak hashes for bagging
-	peakPositions := getPeakPositions(snapshotCount)
-	leafPeakPos := peakPositionForLeaf(leafIndex, snapshotCount)
-
-	for _, pos := range peakPositions {
-		if pos != leafPeakPos && pos < maxNodes {
-			proof = append(proof, nodes[pos])
-		}
-	}
-
-	return proof, nil
-}
-
-// collectSiblingsInMountain collects sibling hashes from leaf to peak within a perfect subtree.
-func collectSiblingsInMountain(nodes [][]byte, mountainStart int, mountainHeight int, localLeafIdx uint32) [][]byte {
-	siblings := make([][]byte, 0, mountainHeight)
-
-	// In a perfect binary tree stored in MMR layout:
-	// Navigate from leaf to root, collecting siblings at each level
-
-	// Current position starts at the leaf
-	pos := mountainStart + leafOffsetInMountain(mountainHeight, localLeafIdx)
-	idx := localLeafIdx
-
-	for level := 0; level < mountainHeight; level++ {
-		// Determine if current node is left (idx even) or right (idx odd) child
-		isLeft := (idx & 1) == 0
-
-		// Calculate sibling position
-		var siblingPos int
-		if isLeft {
-			// Sibling is to the right: next leaf position at this level
-			siblingPos = pos + leafSpacing(level)
-		} else {
-			// Sibling is to the left
-			siblingPos = pos - leafSpacing(level)
-		}
-
-		if siblingPos >= 0 && siblingPos < len(nodes) {
-			siblings = append(siblings, nodes[siblingPos])
-		}
-
-		// Move to parent: position is after the rightmost of the pair + 1 for internal node
-		if isLeft {
-			pos = siblingPos + 1
-		} else {
-			pos = pos + 1
-		}
-
-		// Move to parent index
-		idx = idx >> 1
-	}
-
-	return siblings
-}
-
-// leafOffsetInMountain returns the offset of a leaf within a perfect subtree in MMR layout.
-func leafOffsetInMountain(mountainHeight int, localLeafIdx uint32) int {
-	// In MMR layout, each leaf at index i within a perfect tree is at position:
-	// 2*i - popcount(i)
-	// But relative to the mountain start
-	return mmrSizeForLeaves(localLeafIdx)
-}
-
-// leafSpacing returns the distance to sibling at a given level.
-// At level 0 (leaves), spacing is 1.
-// At level 1, spacing is 3 (size of subtree at level 0 + 1).
-// At level l, spacing is 2^(l+1) - 1.
-func leafSpacing(level int) int {
-	return (1 << (level + 1)) - 1
-}
-
-// peakPositionForLeaf returns the peak position for a given leaf.
-func peakPositionForLeaf(leafIndex, snapshotCount uint32) int {
-	pos := 0
-	remaining := snapshotCount
-	targetLeaf := leafIndex
-
-	for remaining > 0 {
-		height := bits.Len32(remaining) - 1
-		mountainLeaves := uint32(1) << height
-		mountainSize := mmrSizeForLeaves(mountainLeaves)
-
-		if targetLeaf < mountainLeaves {
-			return pos + mountainSize - 1
-		}
-
-		pos += mountainSize
-		targetLeaf -= mountainLeaves
-		remaining -= mountainLeaves
-	}
-
-	return pos
-}
-
-// VerifyProof verifies a merkle proof for a leaf.
-func VerifyProof(rootHash []byte, snapshotCount uint32, leafIndex uint32, leafData []byte, proof [][]byte) bool {
-	if leafIndex >= snapshotCount {
-		return false
-	}
-
-	peakPositions := getPeakPositions(snapshotCount)
-	numPeaks := len(peakPositions)
-
-	// Calculate path length (height of the mountain containing this leaf)
-	pathLen := mountainHeightForLeaf(leafIndex, snapshotCount)
-
-	if len(proof) < pathLen {
-		return false
-	}
-
-	// Compute hash from leaf to peak using path siblings
-	currentHash := hashLeaf(leafData)
-
-	// Navigate the path using the same logic as proof generation
-	remaining := snapshotCount
-	localLeafIdx := leafIndex
-	for remaining > 0 {
-		height := bits.Len32(remaining) - 1
-		mountainLeaves := uint32(1) << height
-
-		if localLeafIdx < mountainLeaves {
-			// Found the mountain - traverse it
-			idx := localLeafIdx
-			for level := 0; level < height; level++ {
-				if level >= len(proof) {
-					return false
-				}
-				isLeft := (idx & 1) == 0
-				if isLeft {
-					currentHash = hashNode(currentHash, proof[level])
-				} else {
-					currentHash = hashNode(proof[level], currentHash)
-				}
-				idx = idx >> 1
-			}
-			break
-		}
-
-		localLeafIdx -= mountainLeaves
-		remaining -= mountainLeaves
-	}
-
-	// Now currentHash is the peak hash for this leaf's mountain
-	// Remaining proof elements are other peaks (for multi-peak trees)
-	otherPeaks := proof[pathLen:]
-
-	// Build all peaks in order for bagging
-	allPeaks := make([][]byte, 0, numPeaks)
-	leafPeakIdx := peakIndexForLeaf(leafIndex, snapshotCount)
-	otherIdx := 0
-
-	for i := 0; i < numPeaks; i++ {
-		if i == leafPeakIdx {
-			allPeaks = append(allPeaks, currentHash)
-		} else {
-			if otherIdx >= len(otherPeaks) {
-				return false
-			}
-			allPeaks = append(allPeaks, otherPeaks[otherIdx])
-			otherIdx++
-		}
-	}
-
-	// Bag peaks from right to left
-	computed := allPeaks[len(allPeaks)-1]
-	for i := len(allPeaks) - 2; i >= 0; i-- {
-		computed = hashNode(allPeaks[i], computed)
-	}
-
-	return bytes.Equal(computed, rootHash)
-}
-
-// mountainHeightForLeaf returns the height of the mountain containing the leaf.
-func mountainHeightForLeaf(leafIndex, snapshotCount uint32) int {
-	remaining := snapshotCount
-	targetLeaf := leafIndex
-
-	for remaining > 0 {
-		height := bits.Len32(remaining) - 1
-		mountainLeaves := uint32(1) << height
-
-		if targetLeaf < mountainLeaves {
-			return height
-		}
-
-		targetLeaf -= mountainLeaves
-		remaining -= mountainLeaves
-	}
-
-	return 0
-}
-
-// peakIndexForLeaf returns which peak (0-based index) contains the leaf.
-func peakIndexForLeaf(leafIndex, snapshotCount uint32) int {
-	remaining := snapshotCount
-	targetLeaf := leafIndex
-	peakIdx := 0
-
-	for remaining > 0 {
-		height := bits.Len32(remaining) - 1
-		mountainLeaves := uint32(1) << height
-
-		if targetLeaf < mountainLeaves {
-			return peakIdx
-		}
-
-		targetLeaf -= mountainLeaves
-		remaining -= mountainLeaves
-		peakIdx++
-	}
-
-	return peakIdx
-}
diff --git a/decentralized-api/poc/artifacts/smst.go b/decentralized-api/poc/artifacts/smst.go
new file mode 100644
index 0000000000..59d50f47e1
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst.go
@@ -0,0 +1,433 @@
+package artifacts
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"runtime"
+	"sync"
+)
+
+const (
+	smstLeafPrefix     = 0x00
+	smstInternalPrefix = 0x01
+	// smstDefaultDepth is the starting depth for both live trees and snapshot
+	// rebuilds, so it participates in root reproducibility: changing it changes
+	// committed roots and must only happen at a coordinated protocol upgrade.
+	smstDefaultDepth = 24
+	smstMaxDepth     = 32
+	// smstParallelHashMinCount: only fan out ensureHashed work when both
+	// children need hashing and the subtree has at least this many leaves.
+	smstParallelHashMinCount = 256
+)
+
+type smstNode struct {
+	hash  []byte
+	count uint32
+	left  *smstNode
+	right *smstNode
+}
+
+// SMST is a Sparse Merkle Sum Tree where nonce determines the path.
+// Sum property: each node stores count = left.count + right.count.
+// Enables dense index navigation in sparse tree.
+type SMST struct {
+	root      *smstNode
+	depth     int
+	emptyHash [][]byte
+	leafCount uint32
+	hasNonce  map[int32]bool // tracks which nonces exist (for duplicate detection)
+
+	// navExistence makes HasNonce walk the tree instead of the hasNonce map.
+	// Snapshot views share nodes with the live tree but carry no map, so nonce
+	// existence must be read from the retained structure at that count.
+	navExistence bool
+
+	// deferredHash invalidates node.hash on insert and fills via ensureHashed
+	// (default). When false, hashes are computed on every insert (upgrade-v0.2.14).
+	deferredHash bool
+
+	// parallelHash fans out ensureHashed across GOMAXPROCS when both children
+	// need hashing (default on). Eager per-insert path hashing stays serial
+	// (parent depends on child); this flag mainly accelerates deferred fill.
+	parallelHash bool
+}
+
+// NewSMST creates a new sparse merkle sum tree.
+// Depth determines max nonce: 2^depth - 1. Default is 24 (16.7M nonces).
+func NewSMST(depth int) *SMST {
+	if depth <= 0 {
+		depth = smstDefaultDepth
+	}
+	if depth > smstMaxDepth {
+		depth = smstMaxDepth
+	}
+
+	s := &SMST{
+		depth:         depth,
+		emptyHash:     make([][]byte, depth+1),
+		hasNonce:      make(map[int32]bool),
+		deferredHash:  true,
+		parallelHash:  true,
+	}
+
+	s.emptyHash[0] = smstHashEmpty()
+	for i := 1; i <= depth; i++ {
+		s.emptyHash[i] = smstHashNode(s.emptyHash[i-1], s.emptyHash[i-1], 0)
+	}
+
+	return s
+}
+
+// Insert adds a leaf at the position determined by nonce.
+// Returns the new leaf count after insertion.
+// Returns error if nonce already exists.
+func (s *SMST) Insert(nonce int32, leafHash []byte) (uint32, error) {
+	if s.hasNonce[nonce] {
+		return 0, ErrDuplicateNonce
+	}
+
+	requiredDepth := s.requiredDepth(nonce)
+	if requiredDepth > s.depth {
+		s.expandDepth(requiredDepth)
+	}
+
+	path := s.noncePath(nonce)
+	s.root = s.insertAt(s.root, path, 0, leafHash)
+
+	s.hasNonce[nonce] = true
+	s.leafCount++
+
+	return s.leafCount, nil
+}
+
+func (s *SMST) insertAt(node *smstNode, path []bool, level int, leafHash []byte) *smstNode {
+	if level == s.depth {
+		return &smstNode{
+			hash:  leafHash,
+			count: 1,
+		}
+	}
+
+	if node == nil {
+		node = &smstNode{}
+	}
+
+	goRight := path[level]
+	if goRight {
+		node.right = s.insertAt(node.right, path, level+1, leafHash)
+	} else {
+		node.left = s.insertAt(node.left, path, level+1, leafHash)
+	}
+
+	node.count = s.nodeCount(node.left) + s.nodeCount(node.right)
+	if s.deferredHash {
+		node.hash = nil // invalidated; recomputed lazily by ensureHashed
+	} else {
+		node.hash = s.computeHash(node, level)
+	}
+
+	return node
+}
+
+func (s *SMST) nodeCount(node *smstNode) uint32 {
+	if node == nil {
+		return 0
+	}
+	return node.count
+}
+
+func (s *SMST) nodeHash(node *smstNode, level int) []byte {
+	if node == nil {
+		return s.emptyHash[s.depth-level]
+	}
+	return node.hash
+}
+
+func (s *SMST) computeHash(node *smstNode, level int) []byte {
+	leftHash := s.nodeHash(node.left, level+1)
+	rightHash := s.nodeHash(node.right, level+1)
+	return smstHashNode(leftHash, rightHash, node.count)
+}
+
+// GetRoot returns the root hash and total count.
+func (s *SMST) GetRoot() ([]byte, uint32) {
+	if s.root == nil {
+		return s.emptyHash[s.depth], 0
+	}
+	s.ensureHashed()
+	return s.root.hash, s.root.count
+}
+
+// ensureHashed fills node hashes left nil by insertAt. Each node is hashed once
+// here rather than on every insert that passes through it, so a shared upper
+// node is not re-hashed for each descendant insert. Idempotent: a node whose
+// hash is already set stops the recursion. When parallelHash is on, independent
+// subtrees are hashed concurrently (bounded by GOMAXPROCS).
+func (s *SMST) ensureHashed() {
+	if s.root == nil {
+		return
+	}
+	if !s.parallelHash {
+		s.hashNode(s.root, 0)
+		return
+	}
+	workers := runtime.GOMAXPROCS(0)
+	if workers < 2 {
+		s.hashNode(s.root, 0)
+		return
+	}
+	// Main goroutine counts as one worker; sem holds the remaining slots.
+	sem := make(chan struct{}, workers-1)
+	s.hashNodeParallel(s.root, 0, sem)
+}
+
+func (s *SMST) hashNode(node *smstNode, level int) {
+	if node == nil || node.hash != nil {
+		return
+	}
+	s.hashNode(node.left, level+1)
+	s.hashNode(node.right, level+1)
+	node.hash = s.computeHash(node, level)
+}
+
+func (s *SMST) hashNodeParallel(node *smstNode, level int, sem chan struct{}) {
+	if node == nil || node.hash != nil {
+		return
+	}
+	left, right := node.left, node.right
+	canFanOut := left != nil && left.hash == nil &&
+		right != nil && right.hash == nil &&
+		node.count >= smstParallelHashMinCount
+	if canFanOut {
+		select {
+		case sem <- struct{}{}:
+			var wg sync.WaitGroup
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				defer func() { <-sem }()
+				s.hashNodeParallel(left, level+1, sem)
+			}()
+			s.hashNodeParallel(right, level+1, sem)
+			wg.Wait()
+			node.hash = s.computeHash(node, level)
+			return
+		default:
+			// All worker slots busy; finish this subtree on the current goroutine.
+		}
+	}
+	s.hashNodeParallel(left, level+1, sem)
+	s.hashNodeParallel(right, level+1, sem)
+	node.hash = s.computeHash(node, level)
+}
+
+// GetLeafByDenseIndex navigates to a leaf using sum-based dense indexing.
+// Returns the nonce and proof (sibling hashes from root to leaf).
+func (s *SMST) GetLeafByDenseIndex(denseIndex uint32) (int32, [][]byte, error) {
+	if s.root == nil || denseIndex >= s.root.count {
+		return 0, nil, ErrLeafIndexOutOfRange
+	}
+
+	proof := make([][]byte, 0, s.depth)
+	path := make([]bool, 0, s.depth)
+	err := s.navigateToLeaf(s.root, denseIndex, 0, &proof, &path)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	nonce := s.pathToNonce(path)
+	return nonce, proof, nil
+}
+
+func (s *SMST) navigateToLeaf(node *smstNode, index uint32, level int, proof *[][]byte, path *[]bool) error {
+	if level == s.depth {
+		return nil
+	}
+
+	if node == nil {
+		return ErrLeafIndexOutOfRange
+	}
+
+	leftCount := s.nodeCount(node.left)
+
+	if index < leftCount {
+		*proof = append(*proof, s.nodeHash(node.right, level+1))
+		*path = append(*path, false)
+		return s.navigateToLeaf(node.left, index, level+1, proof, path)
+	}
+
+	*proof = append(*proof, s.nodeHash(node.left, level+1))
+	*path = append(*path, true)
+	return s.navigateToLeaf(node.right, index-leftCount, level+1, proof, path)
+}
+
+func (s *SMST) pathToNonce(path []bool) int32 {
+	var n uint32
+	for i := 0; i < len(path); i++ {
+		if path[i] {
+			n |= 1 << (s.depth - 1 - i)
+		}
+	}
+	return int32(n)
+}
+
+// Count returns the number of leaves in the tree.
+func (s *SMST) Count() uint32 {
+	return s.leafCount
+}
+
+// Depth returns the current tree depth.
+func (s *SMST) Depth() int {
+	return s.depth
+}
+
+// HasNonce checks if a nonce exists in the tree.
+func (s *SMST) HasNonce(nonce int32) bool {
+	if s.navExistence {
+		return s.hasNonceInTree(nonce)
+	}
+	return s.hasNonce[nonce]
+}
+
+func (s *SMST) hasNonceInTree(nonce int32) bool {
+	if s.root == nil {
+		return false
+	}
+	// A nonce needing more depth than this tree has could never have been
+	// inserted without expanding it, so it is absent. Below the depth the path
+	// bits are injective, making the walk exact — matching the hasNonce map.
+	if s.requiredDepth(nonce) > s.depth {
+		return false
+	}
+	node := s.root
+	for _, goRight := range s.noncePath(nonce) {
+		if node == nil {
+			return false
+		}
+		if goRight {
+			node = node.right
+		} else {
+			node = node.left
+		}
+	}
+	return node != nil
+}
+
+func (s *SMST) denseIndexForNonce(nonce int32) (uint32, error) {
+	if s.root == nil || !s.HasNonce(nonce) {
+		return 0, ErrNonceNotFound
+	}
+
+	path := s.noncePath(nonce)
+	node := s.root
+	var denseIndex uint32
+	for _, goRight := range path {
+		if node == nil {
+			return 0, ErrNonceNotFound
+		}
+		if goRight {
+			denseIndex += s.nodeCount(node.left)
+			node = node.right
+		} else {
+			node = node.left
+		}
+	}
+	if node == nil {
+		return 0, ErrNonceNotFound
+	}
+
+	return denseIndex, nil
+}
+
+func (s *SMST) noncePath(nonce int32) []bool {
+	path := make([]bool, s.depth)
+	n := uint32(nonce)
+	for i := 0; i < s.depth; i++ {
+		bit := (n >> (s.depth - 1 - i)) & 1
+		path[i] = bit == 1
+	}
+	return path
+}
+
+func (s *SMST) requiredDepth(nonce int32) int {
+	n := uint32(nonce)
+	if n == 0 {
+		return 1
+	}
+	bits := 0
+	for n > 0 {
+		bits++
+		n >>= 1
+	}
+	return bits
+}
+
+func (s *SMST) expandDepth(newDepth int) {
+	if newDepth > smstMaxDepth {
+		newDepth = smstMaxDepth
+	}
+	if newDepth <= s.depth {
+		return
+	}
+
+	// Precompute empty hashes for new depths
+	for i := s.depth + 1; i <= newDepth; i++ {
+		s.emptyHash = append(s.emptyHash, smstHashNode(s.emptyHash[i-1], s.emptyHash[i-1], 0))
+	}
+
+	// Update depth first so nodeHash uses correct empty hash indices
+	oldDepth := s.depth
+	s.depth = newDepth
+
+	// Wrap existing tree: old root becomes left child at each level.
+	// Right sibling at each wrapper level is empty with height = (newDepth - level).
+	// We wrap from inside out: first wrapper is at level (newDepth - oldDepth - 1),
+	// last wrapper is at level 0.
+	diff := newDepth - oldDepth
+	for i := 0; i < diff; i++ {
+		if s.root != nil {
+			if s.deferredHash {
+				// Wrapper hash is deferred; ensureHashed fills it from the wrapped
+				// subtree and the empty sibling, identical to eager computation.
+				s.root = &smstNode{
+					left:  s.root,
+					count: s.root.count,
+				}
+			} else {
+				// This wrapper will be at level (diff - 1 - i) in final tree
+				level := diff - 1 - i
+				siblingHeight := newDepth - level - 1
+				newRoot := &smstNode{
+					left:  s.root,
+					count: s.root.count,
+				}
+				newRoot.hash = smstHashNode(s.root.hash, s.emptyHash[siblingHeight], newRoot.count)
+				s.root = newRoot
+			}
+		}
+	}
+}
+
+func smstHashLeaf(data []byte) []byte {
+	h := sha256.New()
+	h.Write([]byte{smstLeafPrefix})
+	h.Write(data)
+	return h.Sum(nil)
+}
+
+func smstHashNode(left, right []byte, count uint32) []byte {
+	h := sha256.New()
+	h.Write([]byte{smstInternalPrefix})
+	h.Write(left)
+	h.Write(right)
+	countBytes := make([]byte, 4)
+	binary.LittleEndian.PutUint32(countBytes, count)
+	h.Write(countBytes)
+	return h.Sum(nil)
+}
+
+func smstHashEmpty() []byte {
+	h := sha256.New()
+	h.Write([]byte{smstLeafPrefix})
+	return h.Sum(nil)
+}
diff --git a/decentralized-api/poc/artifacts/smst_cow.go b/decentralized-api/poc/artifacts/smst_cow.go
new file mode 100644
index 0000000000..493b3713d8
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_cow.go
@@ -0,0 +1,165 @@
+package artifacts
+
+import (
+	"os"
+	"strconv"
+	"strings"
+)
+
+// SMST_COW / SMST_DEFERRED_HASH / SMST_SNAPSHOT_IN_MEMORY_CLONE /
+// SMST_PARALLEL_HASH default on when unset.
+// Profiling overrides:
+//
+//	SMST_COW=0             — in-place Insert (no path-copy)
+//	SMST_DEFERRED_HASH=0   — hash on every insert (upgrade-v0.2.14 baseline)
+//	SMST_SNAPSHOT_IN_MEMORY_CLONE=0  — tip Prebuild rebuilds from artifacts without holding
+//	                         the write lock (upgrade-v0.2.14 Warm/Prebuild path);
+//	                         default 1 = deep in-memory clone under write lock
+//	SMST_PARALLEL_HASH=0   — serial ensureHashed; default 1 = multicore fill
+const envSMSTCOW = "SMST_COW"
+const envSMSTDeferredHash = "SMST_DEFERRED_HASH"
+const envSMSTSnapshotInMemoryClone = "SMST_SNAPSHOT_IN_MEMORY_CLONE"
+const envSMSTParallelHash = "SMST_PARALLEL_HASH"
+
+func smstEnvBool(key string, def bool) bool {
+	v := strings.TrimSpace(os.Getenv(key))
+	if v == "" {
+		return def
+	}
+	switch strings.ToLower(v) {
+	case "0", "false", "off", "no":
+		return false
+	case "1", "true", "on", "yes":
+		return true
+	}
+	b, err := strconv.ParseBool(v)
+	if err != nil {
+		return def
+	}
+	return b
+}
+
+// smstCOWEnabledFromEnv reports COW inserts; default true.
+func smstCOWEnabledFromEnv() bool {
+	return smstEnvBool(envSMSTCOW, true)
+}
+
+// smstDeferredHashFromEnv reports deferred Merkle hashing; default true.
+func smstDeferredHashFromEnv() bool {
+	return smstEnvBool(envSMSTDeferredHash, true)
+}
+
+// smstSnapshotInMemoryCloneFromEnv reports tip-snapshot strategy when COW is off:
+// true = deep clone under write lock; false = artifact rebuild without write lock.
+// Default true. Ignored when COW retains O(1) at flush.
+func smstSnapshotInMemoryCloneFromEnv() bool {
+	return smstEnvBool(envSMSTSnapshotInMemoryClone, true)
+}
+
+// smstParallelHashFromEnv reports multicore ensureHashed; default true.
+func smstParallelHashFromEnv() bool {
+	return smstEnvBool(envSMSTParallelHash, true)
+}
+
+// smstSnapshot is an immutable capture of the tree at a specific leaf count.
+// insertCOW never mutates existing nodes, so a captured root stays valid for the
+// life of the tree and serves proofs without any rebuild. It is captured after a
+// GetRoot (flush/recover), so its nodes are already hashed.
+type smstSnapshot struct {
+	root  *smstNode
+	depth int
+	count uint32
+}
+
+// insertCOW is a copy-on-write Insert: it rewrites only the nodes on the
+// root->leaf path and shares every untouched sibling subtree, so prior roots are
+// never clobbered — which is what makes snapshots free. Roots and counts are
+// byte-identical to Insert; hashing is deferred identically (filled by
+// ensureHashed at GetRoot).
+func (s *SMST) insertCOW(nonce int32, leafHash []byte) (uint32, error) {
+	if s.hasNonce[nonce] {
+		return 0, ErrDuplicateNonce
+	}
+
+	requiredDepth := s.requiredDepth(nonce)
+	if requiredDepth > s.depth {
+		s.expandDepth(requiredDepth)
+	}
+
+	path := s.noncePath(nonce)
+	s.root = s.insertAtCOW(s.root, path, 0, leafHash)
+
+	s.hasNonce[nonce] = true
+	s.leafCount++
+
+	return s.leafCount, nil
+}
+
+func (s *SMST) insertAtCOW(node *smstNode, path []bool, level int, leafHash []byte) *smstNode {
+	if level == s.depth {
+		return &smstNode{hash: leafHash, count: 1}
+	}
+
+	newNode := &smstNode{}
+	if node != nil {
+		newNode.left = node.left
+		newNode.right = node.right
+	}
+
+	if path[level] {
+		newNode.right = s.insertAtCOW(newNode.right, path, level+1, leafHash)
+	} else {
+		newNode.left = s.insertAtCOW(newNode.left, path, level+1, leafHash)
+	}
+
+	newNode.count = s.nodeCount(newNode.left) + s.nodeCount(newNode.right)
+	if s.deferredHash {
+		newNode.hash = nil // deferred; filled by ensureHashed, identical to insertAt
+	} else {
+		newNode.hash = s.computeHash(newNode, level)
+	}
+
+	return newNode
+}
+
+// snapshot captures the current tree. O(1): it retains the root pointer and the
+// depth in force at this count (the depth a historical proof must use). Callers
+// capture after GetRoot, so the retained nodes are already hashed.
+func (s *SMST) snapshot() smstSnapshot {
+	return smstSnapshot{root: s.root, depth: s.depth, count: s.leafCount}
+}
+
+// cloneSnapshot deep-copies the live tree into an independent snapshot. Used when
+// COW is disabled so later in-place inserts cannot mutate historical nodes.
+// Callers must hold the store write lock and have already ensureHashed.
+func (s *SMST) cloneSnapshot() smstSnapshot {
+	return smstSnapshot{root: cloneSMSTNode(s.root), depth: s.depth, count: s.leafCount}
+}
+
+func cloneSMSTNode(n *smstNode) *smstNode {
+	if n == nil {
+		return nil
+	}
+	out := &smstNode{count: n.count}
+	if n.hash != nil {
+		out.hash = append([]byte(nil), n.hash...)
+	}
+	out.left = cloneSMSTNode(n.left)
+	out.right = cloneSMSTNode(n.right)
+	return out
+}
+
+// snapshotView returns a read-only SMST bound to a captured snapshot so proof
+// serving uses the depth that was in force at that count, not the live depth.
+// emptyHash indices 0..depth are stable across expansion (append-only), so the
+// live table is safe to share. Existence is read from the retained structure
+// (navExistence) since a snapshot carries no per-count nonce map.
+func (s *SMST) snapshotView(snap smstSnapshot) *SMST {
+	return &SMST{
+		root:         snap.root,
+		depth:        snap.depth,
+		emptyHash:    s.emptyHash,
+		leafCount:    snap.count,
+		navExistence: true,
+	}
+}
diff --git a/decentralized-api/poc/artifacts/smst_cow_store_test.go b/decentralized-api/poc/artifacts/smst_cow_store_test.go
new file mode 100644
index 0000000000..ea69d59a5c
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_cow_store_test.go
@@ -0,0 +1,505 @@
+package artifacts
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// TestCOWStoreProofPaths verifies proofs served through the copy-on-write store
+// across the three paths: the live tip, a historical committed count served from
+// a retained snapshot (O(depth), no rebuild), and the same historical count
+// after a restart (retained is in-memory, so recovery re-captures only the tip
+// and older counts fall back to the exact rebuild). All must verify against the
+// count's root.
+func TestCOWStoreProofPaths(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+
+	// Fill and flush in blocks so several committed counts exist.
+	const block = 2000
+	const blocks = 4
+	var earlyCount uint32
+	for b := 0; b < blocks; b++ {
+		for i := b * block; i < (b+1)*block; i++ {
+			if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+				t.Fatalf("add %d: %v", i, err)
+			}
+		}
+		if err := store.Flush(); err != nil {
+			t.Fatalf("flush: %v", err)
+		}
+		if b == 0 {
+			earlyCount = store.Count() // first committed count
+		}
+	}
+
+	if len(store.retained) == 0 {
+		t.Fatalf("no retained snapshots captured")
+	}
+
+	verifyAt := func(tag string, count uint32) {
+		root, err := store.GetRootAt(count)
+		if err != nil {
+			t.Fatalf("%s GetRootAt(%d): %v", tag, count, err)
+		}
+		entries, err := store.GetArtifactsAndProofs([]uint32{count / 2}, count)
+		if err != nil {
+			t.Fatalf("%s proof@%d: %v", tag, count, err)
+		}
+		e := entries[0]
+		if !VerifySMSTProofSlice(root, count, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+			t.Fatalf("%s proof did not verify at count %d", tag, count)
+		}
+	}
+
+	// Live tip and a historical committed count (retained snapshot path).
+	verifyAt("live", store.Count())
+	verifyAt("retained-historical", earlyCount)
+
+	if err := store.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+
+	// Restart: recovery rebuilds the live tree and re-captures the tip; an older
+	// committed count falls back to the exact rebuild and must still verify.
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	defer store2.Close()
+	if store2.Count() != uint32(block*blocks) {
+		t.Fatalf("recovered count %d, want %d", store2.Count(), block*blocks)
+	}
+	// Recovery must re-capture retained snapshots at every committed count, not
+	// just the tip, so historical proofs are served in O(depth) after a restart.
+	if len(store2.retained) < blocks {
+		t.Fatalf("post-restart retained=%d, want >= %d committed counts", len(store2.retained), blocks)
+	}
+	if _, ok := store2.retained[earlyCount]; !ok {
+		t.Fatalf("early committed count %d not re-captured after restart", earlyCount)
+	}
+
+	root, err := store2.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("post-restart GetRootAt(%d): %v", earlyCount, err)
+	}
+	entries, err := store2.GetArtifactsAndProofs([]uint32{earlyCount / 2}, earlyCount)
+	if err != nil {
+		t.Fatalf("post-restart proof@%d: %v", earlyCount, err)
+	}
+	e := entries[0]
+	if !VerifySMSTProofSlice(root, earlyCount, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("post-restart historical proof did not verify")
+	}
+}
+
+// TestCOWRetainedProofsDoNotHoldWriteLock checks that historical retained proofs
+// release the write lock before artifact I/O: concurrent proof readers at an
+// early committed count must not serialize ingest. Under -race this also guards
+// the unlock→RLock handoff in acquireSnapshotTree.
+func TestCOWRetainedProofsDoNotHoldWriteLock(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	const early = 2000
+	for i := 0; i < early; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush: %v", err)
+	}
+	earlyCount := store.Count()
+	earlyRoot, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("GetRootAt(%d): %v", earlyCount, err)
+	}
+	if _, ok := store.retained[earlyCount]; !ok {
+		t.Fatalf("expected retained snapshot at %d", earlyCount)
+	}
+
+	var (
+		wg           sync.WaitGroup
+		proofOK      int64
+		proofErr     int64
+		writesOK     int64
+		readerDone   = make(chan struct{})
+		nextNonce    = int32(early)
+	)
+
+	const readers = 8
+	for g := 0; g < readers; g++ {
+		wg.Add(1)
+		go func(gid int) {
+			defer wg.Done()
+			idx := uint32(gid) % earlyCount
+			for {
+				select {
+				case <-readerDone:
+					return
+				default:
+				}
+				entries, err := store.GetArtifactsAndProofs([]uint32{idx}, earlyCount)
+				if err != nil || len(entries) != 1 {
+					atomic.AddInt64(&proofErr, 1)
+					continue
+				}
+				e := entries[0]
+				if !VerifySMSTProofSlice(earlyRoot, earlyCount, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+					atomic.AddInt64(&proofErr, 1)
+					continue
+				}
+				atomic.AddInt64(&proofOK, 1)
+			}
+		}(g)
+	}
+
+	// Writer must make progress while retained proofs are in flight. If proofs
+	// still held the write lock across I/O, Adds would stall behind every batch.
+	deadline := time.After(500 * time.Millisecond)
+	for {
+		select {
+		case <-deadline:
+			close(readerDone)
+			wg.Wait()
+			if atomic.LoadInt64(&proofOK) == 0 {
+				t.Fatalf("no successful retained proofs")
+			}
+			if atomic.LoadInt64(&proofErr) != 0 {
+				t.Fatalf("retained proof errors: %d", proofErr)
+			}
+			if atomic.LoadInt64(&writesOK) == 0 {
+				t.Fatalf("ingest made no progress while retained proofs ran (write lock held across I/O?)")
+			}
+			return
+		default:
+			n := atomic.AddInt32(&nextNonce, 1) - 1
+			if err := store.AddWithNode(n, testVector(int(n)), "n"); err != nil {
+				t.Fatalf("concurrent add %d: %v", n, err)
+			}
+			if n%200 == 0 {
+				if err := store.Flush(); err != nil {
+					t.Fatalf("concurrent flush: %v", err)
+				}
+			}
+			atomic.AddInt64(&writesOK, 1)
+		}
+	}
+}
+
+// TestFlushedRootsSurviveLostDistributionHistory checks that a flush count
+// remains provable after restart even when distributions.jsonl lost that entry
+// (the warn-only appendDistributionSnapshot failure mode). flushed_roots.jsonl
+// is the durable commit journal used to re-capture retained snapshots.
+func TestFlushedRootsSurviveLostDistributionHistory(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+
+	const early = 500
+	for i := 0; i < early; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush early: %v", err)
+	}
+	earlyCount := store.Count()
+	earlyRoot, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("GetRootAt(%d): %v", earlyCount, err)
+	}
+	earlyRoot = bytes.Clone(earlyRoot)
+
+	for i := early; i < early*2; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush final: %v", err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+
+	// Simulate distribution append failure / loss: wipe distributions.jsonl but
+	// keep flushed_roots.jsonl (and artifacts.data).
+	if err := os.Truncate(filepath.Join(dir, "distributions.jsonl"), 0); err != nil {
+		t.Fatalf("truncate distributions: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "flushed_roots.jsonl")); err != nil {
+		t.Fatalf("flushed_roots.jsonl missing after flush: %v", err)
+	}
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	defer store2.Close()
+
+	if _, ok := store2.distributionHistory[earlyCount]; ok {
+		t.Fatalf("expected distributionHistory to lack %d after truncate", earlyCount)
+	}
+	if _, ok := store2.retained[earlyCount]; !ok {
+		t.Fatalf("expected retained snapshot at %d after restart without dist history", earlyCount)
+	}
+	root2, err := store2.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("post-restart GetRootAt(%d): %v", earlyCount, err)
+	}
+	if !bytes.Equal(earlyRoot, root2) {
+		t.Fatalf("early root changed across restart without dist history")
+	}
+	entries, err := store2.GetArtifactsAndProofs([]uint32{earlyCount / 2}, earlyCount)
+	if err != nil {
+		t.Fatalf("post-restart proof@%d: %v", earlyCount, err)
+	}
+	e := entries[0]
+	if !VerifySMSTProofSlice(root2, earlyCount, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("post-restart early proof did not verify")
+	}
+}
+
+// TestSMSTCOWEnvDisabled uses in-place Insert (deferred hashing only): no
+// retained snapshots, roots still match the COW path.
+func TestSMSTCOWEnvDisabled(t *testing.T) {
+	t.Setenv(envSMSTCOW, "0")
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+	if store.cowEnabled {
+		t.Fatalf("expected cowEnabled=false with %s=0", envSMSTCOW)
+	}
+
+	const n = 500
+	for i := 0; i < n; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush: %v", err)
+	}
+	if len(store.retained) != 0 {
+		t.Fatalf("retained=%d, want 0 when COW disabled", len(store.retained))
+	}
+	root := store.GetRoot()
+	if root == nil {
+		t.Fatal("nil root")
+	}
+
+	// Same workload with COW on must produce the same tip root.
+	t.Setenv(envSMSTCOW, "1")
+	dir2 := t.TempDir()
+	store2, err := OpenSMST(dir2)
+	if err != nil {
+		t.Fatalf("OpenSMST cow: %v", err)
+	}
+	defer store2.Close()
+	if !store2.cowEnabled {
+		t.Fatal("expected cowEnabled=true")
+	}
+	for i := 0; i < n; i++ {
+		if err := store2.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("cow add %d: %v", i, err)
+		}
+	}
+	if err := store2.Flush(); err != nil {
+		t.Fatalf("cow flush: %v", err)
+	}
+	root2 := store2.GetRoot()
+	if !bytes.Equal(root, root2) {
+		t.Fatalf("root mismatch COW off vs on:\n off=%x\n on= %x", root, root2)
+	}
+}
+
+// TestSMSTCOWDisabledEarlyDeepClone checks that with SMST_COW=0 and
+// SMST_SNAPSHOT_IN_MEMORY_CLONE=1 (default), PrebuildSnapshot deep-clones the live tip
+// under the write lock into retained so proofs stay valid after the tip advances.
+func TestSMSTCOWDisabledEarlyDeepClone(t *testing.T) {
+	t.Setenv(envSMSTCOW, "0")
+	t.Setenv(envSMSTSnapshotInMemoryClone, "1")
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+	if !store.snapshotInMemoryClone {
+		t.Fatal("expected snapshotInMemoryClone=true")
+	}
+
+	const early = 300
+	for i := 0; i < early; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush early: %v", err)
+	}
+	earlyCount := store.Count()
+	earlyRoot, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("GetRootAt(%d): %v", earlyCount, err)
+	}
+	earlyRoot = bytes.Clone(earlyRoot)
+
+	// Commit-worker style: deep clone while tip still equals early count.
+	if err := store.PrebuildSnapshot(earlyCount); err != nil {
+		t.Fatalf("PrebuildSnapshot(%d): %v", earlyCount, err)
+	}
+	if _, ok := store.retained[earlyCount]; !ok {
+		t.Fatalf("expected deep-cloned retained snapshot at %d", earlyCount)
+	}
+	globalSnapshotCache.mu.Lock()
+	_, cacheHit := globalSnapshotCache.entries[snapshotCacheKey{store: store, count: earlyCount}]
+	globalSnapshotCache.mu.Unlock()
+	if cacheHit {
+		t.Fatalf("tip Prebuild must not rebuild into snapshot cache when deep-cloning")
+	}
+
+	// Advance tip past the early commit (in-place Insert mutates live nodes).
+	for i := early; i < early*2; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush final: %v", err)
+	}
+
+	root2, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("post-advance GetRootAt(%d): %v", earlyCount, err)
+	}
+	if !bytes.Equal(earlyRoot, root2) {
+		t.Fatalf("early root changed after tip advanced")
+	}
+	entries, err := store.GetArtifactsAndProofs([]uint32{earlyCount / 2}, earlyCount)
+	if err != nil {
+		t.Fatalf("early proof after tip advanced: %v", err)
+	}
+	e := entries[0]
+	if !VerifySMSTProofSlice(root2, earlyCount, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("early proof did not verify after tip advanced")
+	}
+}
+
+// TestSMSTCOWDisabledEarlyArtifactRebuild checks SMST_SNAPSHOT_IN_MEMORY_CLONE=0:
+// tip Prebuild rebuilds from artifacts into the process cache without retaining
+// a deep clone (upgrade-v0.2.14 path).
+func TestSMSTCOWDisabledEarlyArtifactRebuild(t *testing.T) {
+	t.Setenv(envSMSTCOW, "0")
+	t.Setenv(envSMSTSnapshotInMemoryClone, "0")
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+	if store.snapshotInMemoryClone {
+		t.Fatal("expected snapshotInMemoryClone=false")
+	}
+
+	const early = 300
+	for i := 0; i < early; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush early: %v", err)
+	}
+	earlyCount := store.Count()
+	earlyRoot, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("GetRootAt(%d): %v", earlyCount, err)
+	}
+	earlyRoot = bytes.Clone(earlyRoot)
+
+	if err := store.PrebuildSnapshot(earlyCount); err != nil {
+		t.Fatalf("PrebuildSnapshot(%d): %v", earlyCount, err)
+	}
+	if len(store.retained) != 0 {
+		t.Fatalf("retained must stay empty with snapshot clone off, got %d", len(store.retained))
+	}
+	globalSnapshotCache.mu.Lock()
+	entry, ok := globalSnapshotCache.entries[snapshotCacheKey{store: store, count: earlyCount}]
+	globalSnapshotCache.mu.Unlock()
+	if !ok || entry == nil || !entry.pinned {
+		t.Fatalf("expected pinned snapshot-cache rebuild at %d", earlyCount)
+	}
+
+	for i := early; i < early*2; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush final: %v", err)
+	}
+
+	root2, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("post-advance GetRootAt(%d): %v", earlyCount, err)
+	}
+	if !bytes.Equal(earlyRoot, root2) {
+		t.Fatalf("early root changed after tip advanced")
+	}
+	entries, err := store.GetArtifactsAndProofs([]uint32{earlyCount / 2}, earlyCount)
+	if err != nil {
+		t.Fatalf("early proof after tip advanced: %v", err)
+	}
+	e := entries[0]
+	if !VerifySMSTProofSlice(root2, earlyCount, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("early proof did not verify after tip advanced")
+	}
+}
+
+// TestSMSTDefaultsDeferredAndCOW ensures unset env keeps production defaults:
+// deferred hashing on, COW on, tip snapshot clone on, parallel hash on.
+func TestSMSTDefaultsDeferredAndCOW(t *testing.T) {
+	t.Setenv(envSMSTCOW, "")
+	t.Setenv(envSMSTDeferredHash, "")
+	t.Setenv(envSMSTSnapshotInMemoryClone, "")
+	t.Setenv(envSMSTParallelHash, "")
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+	if !store.cowEnabled {
+		t.Fatal("cowEnabled default want true")
+	}
+	if !store.smst.deferredHash {
+		t.Fatal("deferredHash default want true")
+	}
+	if !store.snapshotInMemoryClone {
+		t.Fatal("snapshotInMemoryClone default want true")
+	}
+	if !store.smst.parallelHash {
+		t.Fatal("parallelHash default want true")
+	}
+}
diff --git a/decentralized-api/poc/artifacts/smst_deferred_test.go b/decentralized-api/poc/artifacts/smst_deferred_test.go
new file mode 100644
index 0000000000..fcff4678b0
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_deferred_test.go
@@ -0,0 +1,379 @@
+package artifacts
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"os"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+)
+
+func testVector(i int) []byte {
+	v := make([]byte, 24)
+	binary.LittleEndian.PutUint64(v[0:8], uint64(i))
+	binary.LittleEndian.PutUint64(v[8:16], uint64(i*2654435761))
+	return v
+}
+
+func perfN(def int) int {
+	if v := os.Getenv("SMST_PERF_N"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			return n
+		}
+	}
+	return def
+}
+
+// deferredDataset returns a deterministic nonce sequence that forces early depth
+// expansion (nonces >= 2^25), includes negatives (path via uint32, depth 32),
+// then a long sequential run — exercising every hashing path a flush touches.
+func deferredDataset(n int) []int32 {
+	out := make([]int32, 0, n+8)
+	out = append(out, 1<<25, (1<<25)+1, 1<<28, -1, -2, -1000000)
+	for i := 0; i < n; i++ {
+		out = append(out, int32(i))
+	}
+	return out
+}
+
+// TestDeferredHashFingerprint builds a large store with periodic flushes,
+// verifies every sampled proof against its flush-count root, and folds all
+// roots plus sampled proofs into a single deterministic SHA-256 fingerprint.
+// The fingerprint is stable across runs; each proof is verified independently
+// against its root, so a matching fingerprint means deferred hashing reproduces
+// the same roots and proofs the tree commits to.
+func TestDeferredHashFingerprint(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	nonces := deferredDataset(200000)
+	fp := sha256.New()
+	const flushEvery = 20000
+	added := 0
+
+	for _, nonce := range nonces {
+		if err := store.AddWithNode(nonce, testVector(int(nonce)), "n"); err != nil {
+			t.Fatalf("add %d: %v", nonce, err)
+		}
+		added++
+		if added%flushEvery != 0 {
+			continue
+		}
+		if err := store.Flush(); err != nil {
+			t.Fatalf("flush: %v", err)
+		}
+		count := store.Count()
+		root, err := store.GetRootAt(count)
+		if err != nil {
+			t.Fatalf("GetRootAt(%d): %v", count, err)
+		}
+		var cb [4]byte
+		binary.LittleEndian.PutUint32(cb[:], count)
+		fp.Write(cb[:])
+		fp.Write(root)
+
+		for _, idx := range []uint32{0, count / 3, count / 2, count - 1} {
+			entries, err := store.GetArtifactsAndProofs([]uint32{idx}, count)
+			if err != nil {
+				t.Fatalf("proof idx=%d count=%d: %v", idx, count, err)
+			}
+			e := entries[0]
+			leaf := encodeLeaf(e.Nonce, e.Vector)
+			if !VerifySMSTProofSlice(root, count, e.Nonce, leaf, e.Proof) {
+				t.Fatalf("proof failed idx=%d count=%d nonce=%d", idx, count, e.Nonce)
+			}
+			for _, p := range e.Proof {
+				fp.Write(p)
+			}
+		}
+	}
+
+	t.Logf("SMST FINGERPRINT (200k + specials, flush 20k): %x", fp.Sum(nil))
+}
+
+// TestDeferredGetRootStableAndIdempotent checks the deferred-hash lifecycle in
+// isolation: GetRoot on an empty tree returns the empty root, and after inserts
+// two consecutive GetRoot calls (fill-then-reuse) return the identical hash.
+func TestDeferredGetRootStableAndIdempotent(t *testing.T) {
+	tree := NewSMST(0)
+	empty, count := tree.GetRoot()
+	if count != 0 || len(empty) == 0 {
+		t.Fatalf("empty tree: count=%d rootLen=%d", count, len(empty))
+	}
+
+	for i := 0; i < 5000; i++ {
+		if _, err := tree.Insert(int32(i), smstHashLeaf(testVector(i))); err != nil {
+			t.Fatalf("insert %d: %v", i, err)
+		}
+	}
+	first, c1 := tree.GetRoot()
+	second, c2 := tree.GetRoot() // no new inserts: ensureHashed must be a no-op
+	if c1 != c2 || c1 != 5000 {
+		t.Fatalf("count drift: %d vs %d", c1, c2)
+	}
+	if string(first) != string(second) {
+		t.Fatalf("root not stable across GetRoot calls")
+	}
+}
+
+// TestParallelHashMatchesSerial checks multicore ensureHashed produces the same
+// root as serial fill (and as eager inserts).
+func TestParallelHashMatchesSerial(t *testing.T) {
+	const n = 20_000
+	const stride = 100
+
+	build := func(deferred, parallel bool) []byte {
+		tree := NewSMST(0)
+		tree.deferredHash = deferred
+		tree.parallelHash = parallel
+		for i := 0; i < n; i++ {
+			if _, err := tree.Insert(int32(i*stride), smstHashLeaf(testVector(i))); err != nil {
+				t.Fatalf("insert %d: %v", i, err)
+			}
+		}
+		root, count := tree.GetRoot()
+		if count != n {
+			t.Fatalf("count=%d want %d", count, n)
+		}
+		return root
+	}
+
+	serial := build(true, false)
+	parallel := build(true, true)
+	eager := build(false, false)
+	eagerPar := build(false, true) // parallel unused on eager path fill; root must still match
+	if !bytes.Equal(serial, parallel) {
+		t.Fatalf("deferred serial vs parallel root mismatch:\n serial=%x\n paral=%x", serial, parallel)
+	}
+	if !bytes.Equal(serial, eager) {
+		t.Fatalf("deferred vs eager root mismatch:\n def=%x\n eager=%x", serial, eager)
+	}
+	if !bytes.Equal(eager, eagerPar) {
+		t.Fatalf("eager serial vs parallel-flag root mismatch:\n a=%x\n b=%x", eager, eagerPar)
+	}
+}
+
+// TestDeferredLiveTipProofSlowThenFast exercises both live-tip proof paths in
+// acquireSnapshotTree: a proof requested before any GetRoot must fill hashes
+// under the write lock, then retry onto the RLock fast path; a later proof at
+// the same count is served entirely under RLock. Both must verify.
+func TestDeferredLiveTipProofSlowThenFast(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	const n = 3000
+	for i := 0; i < n; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	count := store.Count()
+
+	// Slow path: no GetRoot yet, so the live tip still carries deferred hashes.
+	slow, err := store.GetArtifactsAndProofs([]uint32{count / 2}, count)
+	if err != nil {
+		t.Fatalf("slow-path proof: %v", err)
+	}
+	root, err := store.GetRootAt(count)
+	if err != nil {
+		t.Fatalf("GetRootAt: %v", err)
+	}
+	e := slow[0]
+	if !VerifySMSTProofSlice(root, count, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("slow-path proof did not verify")
+	}
+
+	// Fast path: hashes now filled, same live count served under the read lock.
+	fast, err := store.GetArtifactsAndProofs([]uint32{count / 2}, count)
+	if err != nil {
+		t.Fatalf("fast-path proof: %v", err)
+	}
+	f := fast[0]
+	if !VerifySMSTProofSlice(root, count, f.Nonce, encodeLeaf(f.Nonce, f.Vector), f.Proof) {
+		t.Fatalf("fast-path proof did not verify")
+	}
+}
+
+// TestDeferredLiveTipConcurrentProofsBeforeHashFill hammers the live tip with
+// concurrent proofs before any GetRoot. Hash fill must run once under Lock;
+// proof I/O must not hold the write lock, so readers finish without serializing
+// the whole batch on Lock. Under -race this also covers the ensureHashed→retry
+// handoff.
+func TestDeferredLiveTipConcurrentProofsBeforeHashFill(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	const n = 4000
+	for i := 0; i < n; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	count := store.Count()
+
+	const readers = 16
+	var wg sync.WaitGroup
+	errCh := make(chan error, readers)
+	for g := 0; g < readers; g++ {
+		wg.Add(1)
+		go func(gid int) {
+			defer wg.Done()
+			idx := uint32(gid) % count
+			entries, err := store.GetArtifactsAndProofs([]uint32{idx}, count)
+			if err != nil {
+				errCh <- err
+				return
+			}
+			root, err := store.GetRootAt(count)
+			if err != nil {
+				errCh <- err
+				return
+			}
+			e := entries[0]
+			if !VerifySMSTProofSlice(root, count, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+				errCh <- fmt.Errorf("proof verify failed for goroutine %d", gid)
+			}
+		}(g)
+	}
+	wg.Wait()
+	close(errCh)
+	for err := range errCh {
+		t.Fatalf("concurrent tip proof: %v", err)
+	}
+}
+
+// TestDeferredHistoricalRebuildProof forces the O(N) rebuild path: a proof at a
+// past flush count is reconstructed from the log by rebuildTreeFromInputs, which
+// must hash the fresh tree (ensureHashed) before serving. The proof must verify
+// against the historical root.
+func TestDeferredHistoricalRebuildProof(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for i := 0; i < 4000; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	if err := store.Flush(); err != nil {
+		t.Fatalf("flush: %v", err)
+	}
+	historical := store.Count()
+	histRoot, err := store.GetRootAt(historical)
+	if err != nil {
+		t.Fatalf("GetRootAt(historical): %v", err)
+	}
+
+	// Advance past the flush so `historical` is no longer the live tip.
+	for i := 4000; i < 6000; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+
+	entries, err := store.GetArtifactsAndProofs([]uint32{historical / 2}, historical)
+	if err != nil {
+		t.Fatalf("historical proof: %v", err)
+	}
+	e := entries[0]
+	if !VerifySMSTProofSlice(histRoot, historical, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("historical (rebuilt) proof did not verify")
+	}
+}
+
+// TestDeferredStoreEdgeCases covers the error and empty-tree branches of the
+// deferred-hash read paths: an empty store roots to nil, out-of-range and
+// zero counts are rejected, and a closed store returns ErrStoreClosed rather
+// than touching the tree.
+func TestDeferredStoreEdgeCases(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+
+	if r := store.GetRoot(); r != nil {
+		t.Fatalf("empty store root = %x, want nil", r)
+	}
+	if r, err := store.GetRootAt(0); err != nil || r != nil {
+		t.Fatalf("GetRootAt(0) = (%x, %v), want (nil, nil)", r, err)
+	}
+
+	for i := 0; i < 500; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+	}
+	count := store.Count()
+
+	if _, err := store.GetRootAt(count + 1); err == nil {
+		t.Fatalf("GetRootAt(count+1) should error")
+	}
+	// Proof beyond the live count reaches acquireSnapshotTree's range check.
+	if _, err := store.GetArtifactsAndProofs([]uint32{0}, count+1); err == nil {
+		t.Fatalf("proof at count+1 should error")
+	}
+
+	// Directly exercise acquireSnapshotTree's slow-path range check: an
+	// over-count that is not the live tip falls through to the write-locked
+	// branch and must report the mismatch.
+	if _, _, err := store.acquireSnapshotTree(count + 2); err == nil {
+		t.Fatalf("acquireSnapshotTree(count+2) should error")
+	}
+
+	if err := store.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+	if _, err := store.GetRootAt(count); err != ErrStoreClosed {
+		t.Fatalf("closed GetRootAt err = %v, want ErrStoreClosed", err)
+	}
+	if _, _, err := store.acquireSnapshotTree(count); err != ErrStoreClosed {
+		t.Fatalf("closed acquireSnapshotTree err = %v, want ErrStoreClosed", err)
+	}
+}
+
+// TestIngestPerfPortable times building an N-leaf tree via Insert plus one
+// GetRoot (which fills deferred hashes). It reports the ingest cost that
+// deferred hashing reduces by hashing shared upper nodes once at GetRoot rather
+// than on every insert that passes through them.
+func TestIngestPerfPortable(t *testing.T) {
+	n := perfN(200000)
+	nonces := make([]int32, n)
+	leaves := make([][]byte, n)
+	for i := 0; i < n; i++ {
+		nonces[i] = int32(i)
+		leaves[i] = smstHashLeaf(testVector(i))
+	}
+
+	t0 := time.Now()
+	tree := NewSMST(0)
+	for i := 0; i < n; i++ {
+		if _, err := tree.Insert(nonces[i], leaves[i]); err != nil {
+			t.Fatalf("insert: %v", err)
+		}
+	}
+	root, _ := tree.GetRoot()
+	elapsed := time.Since(t0)
+
+	t.Logf("INGEST N=%d: %v  root=%x", n, elapsed, root[:8])
+}
diff --git a/decentralized-api/poc/artifacts/smst_findings_verification_test.go b/decentralized-api/poc/artifacts/smst_findings_verification_test.go
new file mode 100644
index 0000000000..f80d85f3b6
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_findings_verification_test.go
@@ -0,0 +1,287 @@
+package artifacts
+
+// Verification of Dmytro's PoC-proof-serving load-test findings against the
+// #1432 changes (copy-on-write retained snapshots + deferred hashing). Each test
+// emits a machine-parseable "RESULT ..." line consumed by the before/after
+// comparison. The mirror file smst_findings_base_test.go runs the same drivers
+// on the base (upgrade-v0.2.14) tree.
+//
+// Env knobs (defaults keep `go test` fast; the reported numbers use the large
+// values): SMST_FIND_N (leaves), SMST_FIND_FLUSH (flush interval), SMST_FIND_K
+// (distinct attack counts).
+
+import (
+	"bytes"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func findEnvInt(key string, def int) int {
+	if v := os.Getenv(key); v != "" {
+		if n, err := strconv.Atoi(v); err == nil {
+			return n
+		}
+	}
+	return def
+}
+
+// buildFlushedStore fills a store with n leaves, flushing every `flush` leaves,
+// and returns the store plus the ordered list of committed (flush) counts.
+func buildFlushedStore(t *testing.T, n, flush int) (*SMSTArtifactStore, []uint32) {
+	t.Helper()
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	var committed []uint32
+	for i := 0; i < n; i++ {
+		if err := store.AddWithNode(int32(i), testVector(i), "n"); err != nil {
+			t.Fatalf("add %d: %v", i, err)
+		}
+		if (i+1)%flush == 0 {
+			if err := store.Flush(); err != nil {
+				t.Fatalf("flush at %d: %v", i+1, err)
+			}
+			committed = append(committed, store.Count())
+		}
+	}
+	return store, committed
+}
+
+// ---------------------------------------------------------------------------
+// Differential byte-identity: Insert (eager, base semantics) vs insertCOW
+// (deferred, #1432 live path) vs rebuildTreeFromInputs (fallback path).
+// Closes the coverage gap: nothing previously asserted these produce
+// byte-identical roots AND proofs. A divergence would false-strip an honest
+// node if a base-version and a #1432 node ever coexisted in one network.
+// ---------------------------------------------------------------------------
+func TestDiff_ByteIdentity_InsertVsCOWVsRebuild(t *testing.T) {
+	// Ns chosen to cross several depth-expansion boundaries.
+	ns := []int{1, 2, 100, 999, 1000, 4096, 10000}
+	if !testing.Short() {
+		ns = append(ns, 50000, 100000)
+	}
+	maxN := ns[len(ns)-1]
+
+	// Precompute the shared (nonce, leafHash) sequence once.
+	type leaf struct {
+		nonce    int32
+		leafHash []byte
+	}
+	leaves := make([]leaf, maxN)
+	for i := 0; i < maxN; i++ {
+		nonce := int32(i)
+		leaves[i] = leaf{nonce: nonce, leafHash: smstHashLeaf(encodeLeaf(nonce, testVector(i)))}
+	}
+
+	for _, n := range ns {
+		// Eager Insert tree (base semantics).
+		eager := NewSMST(smstDefaultDepth)
+		for i := 0; i < n; i++ {
+			if _, err := eager.Insert(leaves[i].nonce, leaves[i].leafHash); err != nil {
+				t.Fatalf("eager Insert %d: %v", i, err)
+			}
+		}
+		eagerRoot, _ := eager.GetRoot()
+
+		// Copy-on-write tree (deferred hashing, #1432 live insert path).
+		cow := NewSMST(smstDefaultDepth)
+		for i := 0; i < n; i++ {
+			if _, err := cow.insertCOW(leaves[i].nonce, leaves[i].leafHash); err != nil {
+				t.Fatalf("insertCOW %d: %v", i, err)
+			}
+		}
+		cowRoot, _ := cow.GetRoot()
+
+		if !bytes.Equal(eagerRoot, cowRoot) {
+			t.Fatalf("N=%d root mismatch Insert vs insertCOW:\n eager=%x\n cow=  %x", n, eagerRoot, cowRoot)
+		}
+
+		// Rebuild-from-log path (the #1432 cold-start fallback): drive
+		// rebuildTreeFromInputs directly and compare its root to eager Insert.
+		store, _ := buildFlushedStore(t, n, maxInt(1, n)) // flush at n
+		offsets, buffered, err := store.snapshotRebuildInputs(uint32(n))
+		if err != nil {
+			t.Fatalf("N=%d snapshotRebuildInputs: %v", n, err)
+		}
+		rebuilt := rebuildTreeFromInputs(store.dataFile, offsets, buffered, uint32(n))
+		rebuiltRoot, _ := rebuilt.GetRoot()
+		if !bytes.Equal(eagerRoot, rebuiltRoot) {
+			t.Fatalf("N=%d root mismatch Insert vs rebuildTreeFromInputs:\n eager=  %x\n rebuilt=%x", n, eagerRoot, rebuiltRoot)
+		}
+
+		// Proof byte-identity at sampled dense indices, RAW form (sibling hashes)
+		// across all three trees via GetLeafByDenseIndex — same format, so a
+		// direct byte comparison is the true divergence check. (The store's
+		// transport proof adds count-encoding, so it is verified semantically
+		// against the root instead — done in the COW/finding tests.)
+		if n >= 2 {
+			for _, di := range []uint32{0, uint32(n / 2), uint32(n - 1)} {
+				eNonce, eProof, err := eager.GetLeafByDenseIndex(di)
+				if err != nil {
+					t.Fatalf("N=%d eager proof di=%d: %v", n, di, err)
+				}
+				cNonce, cProof, err := cow.GetLeafByDenseIndex(di)
+				if err != nil {
+					t.Fatalf("N=%d cow proof di=%d: %v", n, di, err)
+				}
+				rNonce, rProof, err := rebuilt.GetLeafByDenseIndex(di)
+				if err != nil {
+					t.Fatalf("N=%d rebuild proof di=%d: %v", n, di, err)
+				}
+				if eNonce != cNonce || eNonce != rNonce {
+					t.Fatalf("N=%d di=%d nonce mismatch: eager=%d cow=%d rebuild=%d", n, di, eNonce, cNonce, rNonce)
+				}
+				if len(eProof) != len(cProof) || len(eProof) != len(rProof) {
+					t.Fatalf("N=%d di=%d proof len mismatch: eager=%d cow=%d rebuild=%d", n, di, len(eProof), len(cProof), len(rProof))
+				}
+				for k := range eProof {
+					if !bytes.Equal(eProof[k], cProof[k]) || !bytes.Equal(eProof[k], rProof[k]) {
+						t.Fatalf("N=%d di=%d raw proof elem %d differs across Insert/COW/rebuild", n, di, k)
+					}
+				}
+				// The served transport proof must still verify against the root.
+				entries, err := store.GetArtifactsAndProofs([]uint32{di}, uint32(n))
+				if err != nil {
+					t.Fatalf("N=%d store proof di=%d: %v", n, di, err)
+				}
+				se := entries[0]
+				if !VerifySMSTProofSlice(eagerRoot, uint32(n), se.Nonce, encodeLeaf(se.Nonce, se.Vector), se.Proof) {
+					t.Fatalf("N=%d di=%d served transport proof did not verify against eager root", n, di)
+				}
+			}
+		}
+		store.Close()
+		t.Logf("RESULT diff impl=1432 N=%d insert_eq_cow=1 insert_eq_rebuild=1 proofs_eq=1", n)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Finding 2: distinct-count recompute flood. On #1432 a proof request at a
+// non-committed count is REJECTED (no rebuild); committed counts are served from
+// retained snapshots in O(depth). Emits served/rejected/rebuild counts + wall
+// time for the same attack pattern the base test replays.
+// ---------------------------------------------------------------------------
+func TestFinding2_RecomputeFlood_1432(t *testing.T) {
+	n := findEnvInt("SMST_FIND_N", 20000)
+	flush := findEnvInt("SMST_FIND_FLUSH", 2000)
+	k := findEnvInt("SMST_FIND_K", 30)
+
+	store, committed := buildFlushedStore(t, n, flush)
+	defer store.Close()
+
+	// Attack pattern: K distinct historical counts, mostly NON-committed
+	// (partial leaf counts, exactly what Dmytro forced) plus a few committed.
+	// Non-committed picks are (flushBoundary - 1), which are < flushedLeafCount
+	// and never on a flush boundary.
+	var attack []uint32
+	for i := 0; i < k; i++ {
+		c := committed[i%len(committed)]
+		if i%3 == 0 {
+			attack = append(attack, c) // committed
+		} else {
+			attack = append(attack, c-1) // non-committed partial count
+		}
+	}
+
+	served, rejected := 0, 0
+	start := time.Now()
+	for _, c := range attack {
+		_, err := store.GetArtifactsAndProofs([]uint32{c / 2}, c)
+		if err != nil {
+			rejected++
+		} else {
+			served++
+		}
+	}
+	elapsed := time.Since(start)
+
+	// Functional gate: every non-committed count must be rejected outright.
+	nonCommitted := committed[0] - 1
+	if _, _, err := store.acquireSnapshotTree(nonCommitted); err == nil {
+		t.Fatalf("finding2: non-committed count %d was NOT rejected on #1432", nonCommitted)
+	}
+	// #1432 never rebuilds for the attack pattern: non-committed rejected,
+	// committed served from retained.
+	rebuilds := 0
+	t.Logf("RESULT finding2 impl=1432 N=%d flush=%d K=%d served=%d rejected=%d rebuilds=%d ms=%.2f",
+		n, flush, k, served, rejected, rebuilds, float64(elapsed.Microseconds())/1000.0)
+}
+
+// ---------------------------------------------------------------------------
+// Finding 4: early-share guard false strip. The guard asks the node for an
+// inclusion proof at an EARLY committed count after a restart. On #1432 that
+// count is served from a re-captured retained snapshot in O(depth) with no
+// rebuild; the early root is byte-identical to the pre-restart committed root.
+// Removing the O(N) rebuild under the guard's proof window is what removes the
+// transient-false-strip surface (a slow/failed rebuild under load = the strip).
+// ---------------------------------------------------------------------------
+func TestFinding4_EarlyRootAfterRestart_1432(t *testing.T) {
+	n := findEnvInt("SMST_FIND_N", 20000)
+	flush := findEnvInt("SMST_FIND_FLUSH", 2000)
+
+	store, committed := buildFlushedStore(t, n, flush)
+	dir := store.dir
+	earlyCount := committed[0]
+	earlyRoot, err := store.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("pre-restart GetRootAt(%d): %v", earlyCount, err)
+	}
+	earlyRootCopy := bytes.Clone(earlyRoot)
+	if err := store.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+
+	// Restart.
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	defer store2.Close()
+
+	_, retainedHit := store2.retained[earlyCount]
+
+	start := time.Now()
+	root2, err := store2.GetRootAt(earlyCount)
+	if err != nil {
+		t.Fatalf("post-restart GetRootAt(%d): %v", earlyCount, err)
+	}
+	// Serve a real inclusion proof at the early count (the guard's actual op).
+	entries, err := store2.GetArtifactsAndProofs([]uint32{earlyCount / 2}, earlyCount)
+	if err != nil {
+		t.Fatalf("post-restart proof@%d: %v", earlyCount, err)
+	}
+	elapsed := time.Since(start)
+
+	identical := bytes.Equal(earlyRootCopy, root2)
+	if !identical {
+		t.Fatalf("finding4: early root changed across restart on #1432 (would false-strip)")
+	}
+	e := entries[0]
+	if !VerifySMSTProofSlice(root2, earlyCount, e.Nonce, encodeLeaf(e.Nonce, e.Vector), e.Proof) {
+		t.Fatalf("finding4: post-restart early proof did not verify")
+	}
+	hit := 0
+	if retainedHit {
+		hit = 1
+	}
+	t.Logf("RESULT finding4 impl=1432 N=%d flush=%d earlyCount=%d retained_hit=%d root_identical=1 served_via=%s us=%d",
+		n, flush, earlyCount, hit, servedVia(retainedHit), elapsed.Microseconds())
+}
+
+func servedVia(retained bool) string {
+	if retained {
+		return "retained_snapshot_O(depth)"
+	}
+	return "rebuild_O(N)"
+}
+
+func maxInt(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
diff --git a/decentralized-api/poc/artifacts/smst_profile_test.go b/decentralized-api/poc/artifacts/smst_profile_test.go
new file mode 100644
index 0000000000..1f799e1536
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_profile_test.go
@@ -0,0 +1,170 @@
+package artifacts
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// TestSMSTBuildProfile measures ingest wall-time and resident heap for a live
+// SMST built from N monotonic nonces (stride 100 = the worst porosity the chain
+// allows, matching real PoC assignment). Leaf hashes are generated inline so
+// only the tree stays resident, isolating the tree's own cost. Env-gated: set
+// SMST_PROF_N to the leaf count to run a single scale, e.g.
+//
+//	SMST_PROF_N=1000000 SMST_DEFERRED_HASH=1 SMST_PARALLEL_HASH=1 \
+//	  go test ./poc/artifacts/ -run TestSMSTBuildProfile -v -timeout 30m
+//
+// Run once per scale in its own process so heap is released between runs.
+// Reports insert time vs GetRoot/ensureHashed time separately so deferred
+// multicore fill is visible.
+func TestSMSTBuildProfile(t *testing.T) {
+	v := os.Getenv("SMST_PROF_N")
+	if v == "" {
+		t.Skip("set SMST_PROF_N to run the build profile")
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil || n <= 0 {
+		t.Fatalf("invalid SMST_PROF_N=%q", v)
+	}
+	const stride = 100
+
+	var m0, m1 runtime.MemStats
+	runtime.GC()
+	runtime.ReadMemStats(&m0)
+
+	tree := NewSMST(0)
+	tree.deferredHash = smstDeferredHashFromEnv()
+	tree.parallelHash = smstParallelHashFromEnv()
+
+	tIns := time.Now()
+	for i := 0; i < n; i++ {
+		leaf := smstHashLeaf(testVector(i))
+		if _, err := tree.Insert(int32(i*stride), leaf); err != nil {
+			t.Fatalf("insert %d: %v", i, err)
+		}
+	}
+	insElapsed := time.Since(tIns)
+
+	tRoot := time.Now()
+	root, count := tree.GetRoot()
+	rootElapsed := time.Since(tRoot)
+	elapsed := insElapsed + rootElapsed
+
+	runtime.GC()
+	runtime.ReadMemStats(&m1)
+	runtime.KeepAlive(tree)
+
+	heapBytes := int64(m1.HeapAlloc) - int64(m0.HeapAlloc)
+	mb := float64(heapBytes) / (1024 * 1024)
+	t.Logf("RESULT deferred=%v parallel=%v N=%-9d depth=%d  insert=%-12s  getroot=%-12s  total=%-12s  %6.0f ns/leaf  heap=%8.1f MB  %5.0f B/leaf  root=%x count=%d",
+		tree.deferredHash, tree.parallelHash, n, tree.Depth(),
+		insElapsed.Round(time.Millisecond), rootElapsed.Round(time.Microsecond), elapsed.Round(time.Millisecond),
+		float64(elapsed.Nanoseconds())/float64(n),
+		mb, float64(heapBytes)/float64(n), root[:6], count)
+}
+
+const profFlushCount = 30
+const profEarlyFlush = 10 // 1/3 of 30
+
+// TestSMSTStoreFlush30Profile is the realistic PoC ingest profile:
+// N leaves across 30 equal flushes; at flush #10 (1/3) the early commit is
+// snapshotted via PrebuildSnapshot. Then an early-count proof is timed.
+//
+// Deferred × parallel matrix (COW on so snap cost stays out of the way):
+//
+//	# deferred + multicore ensureHashed (production-like)
+//	SMST_PROF_N=300000 SMST_DEFERRED_HASH=1 SMST_PARALLEL_HASH=1 SMST_COW=1 \
+//	  go test ./poc/artifacts/ -run TestSMSTStoreFlush30Profile -v
+//
+//	# deferred + serial ensureHashed
+//	SMST_PROF_N=300000 SMST_DEFERRED_HASH=1 SMST_PARALLEL_HASH=0 SMST_COW=1 \
+//	  go test ./poc/artifacts/ -run TestSMSTStoreFlush30Profile -v
+//
+//	# eager path hash + parallel flag (parallel unused on per-insert path)
+//	SMST_PROF_N=300000 SMST_DEFERRED_HASH=0 SMST_PARALLEL_HASH=1 SMST_COW=1 \
+//	  go test ./poc/artifacts/ -run TestSMSTStoreFlush30Profile -v
+//
+//	# eager path hash, serial
+//	SMST_PROF_N=300000 SMST_DEFERRED_HASH=0 SMST_PARALLEL_HASH=0 SMST_COW=1 \
+//	  go test ./poc/artifacts/ -run TestSMSTStoreFlush30Profile -v
+func TestSMSTStoreFlush30Profile(t *testing.T) {
+	v := os.Getenv("SMST_PROF_N")
+	if v == "" {
+		t.Skip("set SMST_PROF_N to run the 30-flush profile")
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil || n < profFlushCount {
+		t.Fatalf("invalid SMST_PROF_N=%q (need >= %d)", v, profFlushCount)
+	}
+	if n%profFlushCount != 0 {
+		t.Fatalf("SMST_PROF_N=%d must be divisible by %d", n, profFlushCount)
+	}
+	batch := n / profFlushCount
+
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	var (
+		earlyCount  uint32
+		snapElapsed time.Duration
+		nonce       int32
+	)
+
+	tIngest := time.Now()
+	for f := 1; f <= profFlushCount; f++ {
+		for j := 0; j < batch; j++ {
+			if err := store.AddWithNode(nonce, testVector(int(nonce)), "n"); err != nil {
+				t.Fatalf("add %d: %v", nonce, err)
+			}
+			nonce++
+		}
+		if err := store.Flush(); err != nil {
+			t.Fatalf("flush %d: %v", f, err)
+		}
+		if f == profEarlyFlush {
+			earlyCount = store.Count()
+			tSnap := time.Now()
+			if err := store.PrebuildSnapshot(earlyCount); err != nil {
+				t.Fatalf("PrebuildSnapshot(%d): %v", earlyCount, err)
+			}
+			snapElapsed = time.Since(tSnap)
+		}
+	}
+	ingestElapsed := time.Since(tIngest)
+
+	if earlyCount == 0 {
+		t.Fatal("early count not recorded")
+	}
+
+	tProof := time.Now()
+	entries, err := store.GetArtifactsAndProofs([]uint32{earlyCount / 2}, earlyCount)
+	if err != nil {
+		t.Fatalf("early proof: %v", err)
+	}
+	proofElapsed := time.Since(tProof)
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 proof entry, got %d", len(entries))
+	}
+
+	globalSnapshotCache.mu.Lock()
+	_, cacheHit := globalSnapshotCache.entries[snapshotCacheKey{store: store, count: earlyCount}]
+	globalSnapshotCache.mu.Unlock()
+	_, retainedHit := store.retained[earlyCount]
+
+	mode := fmt.Sprintf("deferred=%v parallel=%v cow=%v", store.smst.deferredHash, store.smst.parallelHash, store.cowEnabled)
+	t.Logf("RESULT mode=%s N=%d flushes=%d early_flush=%d early_count=%d ingest=%s snap=%s early_proof=%s ns/leaf=%.0f retained_hit=%v cache_hit=%v retained_n=%d gomaxprocs=%d",
+		mode, n, profFlushCount, profEarlyFlush, earlyCount,
+		ingestElapsed.Round(time.Millisecond),
+		snapElapsed.Round(time.Microsecond),
+		proofElapsed.Round(time.Microsecond),
+		float64(ingestElapsed.Nanoseconds())/float64(n),
+		retainedHit, cacheHit, len(store.retained), runtime.GOMAXPROCS(0))
+}
diff --git a/decentralized-api/poc/artifacts/smst_security_test.go b/decentralized-api/poc/artifacts/smst_security_test.go
new file mode 100644
index 0000000000..18bb4144b7
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_security_test.go
@@ -0,0 +1,221 @@
+package artifacts
+
+import (
+	"testing"
+)
+
+// TestSMSTAttackerScenarios provides comprehensive security tests simulating
+// various attack vectors to ensure the SMST implementation is robust.
+//
+// Vectors tested:
+// 1. Proof Forgery: Modifying sibling counts to spoof dense index
+// 2. Proof Forgery: Modifying sibling hashes to spoof root
+// 3. Identity Theft: Claiming a proof for Nonce A belongs to Nonce B
+// 4. Index Spoofing: Claiming a proof for Index X belongs to Index Y
+// 5. Count Inflation: Claiming a root represents more items than it does
+func TestSMSTAttackerScenarios(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	// Setup: Insert known artifacts
+	// Use non-sequential nonces to make tree structure interesting
+	nonces := []int32{10, 50, 20, 40, 30}
+	for _, n := range nonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d) failed: %v", n, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()      // Should be 5
+	rootHash := store.GetRoot() // Committed root
+
+	// Helper to get valid proof components for a nonce
+	getComponents := func(targetNonce int32) (uint32, []byte, []SMSTProofElement) {
+		// Find index by iterating
+		var targetIndex uint32
+		var found bool
+		for i := uint32(0); i < count; i++ {
+			n, _, _, _ := store.GetArtifactAndProof(i, count)
+			if n == targetNonce {
+				targetIndex = i
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Fatalf("Setup error: nonce %d not found", targetNonce)
+		}
+
+		// Get valid proof
+		_, vector, proofBytes, _ := store.GetArtifactAndProof(targetIndex, count)
+		elements := DecodeProofElements(proofBytes)
+		leafData := encodeLeaf(targetNonce, vector)
+
+		return targetIndex, leafData, elements
+	}
+
+	// -------------------------------------------------------------------------
+	// Attack 1: Modifying Sibling Counts (Inflation / Index Spoofing)
+	// -------------------------------------------------------------------------
+	// Attacker tries to change a sibling count in the proof to make the
+	// verifier calculate a different dense index, hoping to match a target index.
+	t.Run("Attack_ModifySiblingCount", func(t *testing.T) {
+		targetNonce := int32(50) // Nonce 50 is at index 4 (sorted order: 10, 20, 30, 40, 50)
+		realIndex, leafData, elements := getComponents(targetNonce)
+
+		if realIndex != 4 {
+			t.Fatalf("Setup assumptions wrong: expected index 4 for nonce 50, got %d", realIndex)
+		}
+
+		// Try to spoof index 3 by reducing a sibling count
+		// We copy elements to avoid modifying original
+		spoofedElements := make([]SMSTProofElement, len(elements))
+		copy(spoofedElements, elements)
+
+		// Modify the first non-zero count we find
+		modified := false
+		for i := range spoofedElements {
+			if spoofedElements[i].SiblingCount > 0 {
+				spoofedElements[i].SiblingCount-- // Decrease count
+				modified = true
+				break
+			}
+		}
+
+		if !modified {
+			t.Skip("Could not find suitable element to modify for this test case")
+		}
+
+		// Attempt verification
+		// Expected result: Verification fails because changing count changes the node hash,
+		// which propagates to a different root hash.
+		if VerifySMSTProofWithCounts(rootHash, count, targetNonce, leafData, spoofedElements) {
+			t.Error("Security Breach: Proof with modified sibling count was accepted!")
+		} else {
+			t.Log("Success: Modified sibling count rejected (root hash mismatch)")
+		}
+	})
+
+	// -------------------------------------------------------------------------
+	// Attack 2: Modifying Sibling Hashes
+	// -------------------------------------------------------------------------
+	// Attacker tries to change a sibling hash.
+	t.Run("Attack_ModifySiblingHash", func(t *testing.T) {
+		targetNonce := int32(10)
+		_, leafData, elements := getComponents(targetNonce)
+
+		spoofedElements := make([]SMSTProofElement, len(elements))
+		copy(spoofedElements, elements)
+
+		// Flip a bit in the first sibling hash
+		if len(spoofedElements) > 0 {
+			spoofedElements[0].SiblingHash[0] ^= 0xFF
+		}
+
+		if VerifySMSTProofWithCounts(rootHash, count, targetNonce, leafData, spoofedElements) {
+			t.Error("Security Breach: Proof with modified sibling hash was accepted!")
+		} else {
+			t.Log("Success: Modified sibling hash rejected")
+		}
+	})
+
+	// -------------------------------------------------------------------------
+	// Attack 3: Identity Theft (Swapping Nonce)
+	// -------------------------------------------------------------------------
+	// Attacker takes a valid proof for Nonce A and claims it proves Nonce B.
+	// This tests that the verification path is strictly bound to the nonce.
+	t.Run("Attack_IdentityTheft", func(t *testing.T) {
+		nonceA := int32(10)
+		nonceB := int32(20)
+
+		_, _, elementsA := getComponents(nonceA)
+
+		// Attacker constructs leaf data for B but uses A's proof
+		vectorB := []byte{byte(nonceB)}
+		leafDataB := encodeLeaf(nonceB, vectorB)
+
+		// Verify proof A against Nonce B should fail
+		// The verifier will construct path(B). Since path(A) != path(B), 
+		// the proof elements (siblings of path A) will be wrong for path B.
+		if VerifySMSTProofWithCounts(rootHash, count, nonceB, leafDataB, elementsA) {
+			t.Error("Security Breach: Proof for Nonce A accepted for Nonce B!")
+		} else {
+			t.Log("Success: Identity theft rejected (path mismatch)")
+		}
+	})
+
+	// -------------------------------------------------------------------------
+	// Attack 4: Index Spoofing (Claiming Wrong Index)
+	// -------------------------------------------------------------------------
+	// Attacker has a valid proof for Nonce A at Index X.
+	// Attacker claims this proof satisfies a request for Index Y.
+	t.Run("Attack_IndexSpoofing", func(t *testing.T) {
+		nonce := int32(10)
+		realIndex, leafData, elements := getComponents(nonce)
+
+		targetIndex := realIndex + 1 // Claim it's at the next slot
+		proofSlice := encodeTestProofForTransport(elements)
+
+		if VerifySMSTProofWithDenseIndex(rootHash, count, targetIndex, nonce, leafData, proofSlice) {
+			t.Errorf("Security Breach: Proof for index %d accepted for index %d!", realIndex, targetIndex)
+		} else {
+			t.Logf("Success: Index spoofing rejected (calculated index %d != claimed %d)", realIndex, targetIndex)
+		}
+	})
+
+	// -------------------------------------------------------------------------
+	// Attack 5: Count Inflation (Claiming Higher Total Count)
+	// -------------------------------------------------------------------------
+	// Attacker commits to Root R (which encodes count C).
+	// Attacker claims the count is C+1.
+	// Verifier uses C+1 in the check.
+	t.Run("Attack_CountInflation", func(t *testing.T) {
+		nonce := int32(10)
+		_, leafData, elements := getComponents(nonce)
+
+		inflatedCount := count + 1
+
+		// VerifySMSTProofWithCounts checks: if currentCount != count { return false }
+		// But currentCount is derived from the proof's sibling sums + 1.
+		// If we use the original proof, currentCount will equal 'count'.
+		// So 'count' != 'inflatedCount' will fail.
+
+		if VerifySMSTProofWithCounts(rootHash, inflatedCount, nonce, leafData, elements) {
+			t.Error("Security Breach: Proof accepted against inflated total count!")
+		} else {
+			t.Log("Success: Count inflation rejected")
+		}
+	})
+
+	// -------------------------------------------------------------------------
+	// Attack 6: Tree Substitution
+	// -------------------------------------------------------------------------
+	// Attacker generates a completely different tree (valid structure)
+	// and tries to use proofs from it against the honest root.
+	t.Run("Attack_TreeSubstitution", func(t *testing.T) {
+		// Create a fake store with different data
+		fakeDir := t.TempDir()
+		fakeStore, _ := OpenSMST(fakeDir)
+		defer fakeStore.Close()
+
+		fakeStore.Add(999, []byte{0xFF})
+		fakeStore.Flush()
+
+		// Get valid proof from fake tree
+		_, fakeVector, fakeProofBytes, _ := fakeStore.GetArtifactAndProof(0, 1)
+		fakeLeafData := encodeLeaf(999, fakeVector)
+		fakeElements := DecodeProofElements(fakeProofBytes)
+
+		// Try to verify fake proof against HONEST root
+		if VerifySMSTProofWithCounts(rootHash, count, 999, fakeLeafData, fakeElements) {
+			t.Error("Security Breach: Proof from fake tree accepted against honest root!")
+		} else {
+			t.Log("Success: Tree substitution rejected")
+		}
+	})
+}
diff --git a/decentralized-api/poc/artifacts/smst_store.go b/decentralized-api/poc/artifacts/smst_store.go
new file mode 100644
index 0000000000..34bc548ef5
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_store.go
@@ -0,0 +1,1234 @@
+package artifacts
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"slices"
+	"sync"
+)
+
+const (
+	// MaxLeafCount caps artifacts to prevent overflow in size calculations.
+	MaxLeafCount = (1 << 30) - 1 // 1,073,741,823
+)
+
+var (
+	ErrDuplicateNonce      = errors.New("duplicate nonce")
+	ErrLeafIndexOutOfRange = errors.New("leaf index out of range")
+	ErrNonceNotFound       = errors.New("nonce not found")
+	ErrStoreClosed         = errors.New("store is closed")
+	ErrCapacityExceeded    = errors.New("store capacity exceeded")
+)
+
+type bufferedArtifact struct {
+	nonce  int32
+	vector []byte
+	nodeId string
+}
+
+// distributionEntry is a single line in distributions.jsonl
+type distributionEntry struct {
+	Count uint32            `json:"count"`
+	Dist  map[string]uint32 `json:"dist"`
+}
+
+// flushedRootEntry is a single line in flushed_roots.jsonl. This is the
+// durable record of committed flush counts (and their roots), independent of
+// distributions.jsonl — so a failed distribution append cannot make an
+// on-chain flush count unprovable after restart.
+type flushedRootEntry struct {
+	Count uint32 `json:"count"`
+	Root  string `json:"root"` // hex-encoded SMST root
+}
+
+// SMSTArtifactStore provides artifact storage with SMST commitments.
+// Nonce determines tree position, making duplicates impossible by design.
+type SMSTArtifactStore struct {
+	mu     sync.RWMutex
+	dir    string
+	closed bool
+
+	dataFile *os.File
+
+	buffer        []bufferedArtifact
+	offsets       []uint64         // arrival order -> disk offset
+	nonceToOffset map[int32]uint64 // nonce -> disk offset (for fast lookup)
+	smst          *SMST
+
+	flushedLeafCount  uint32
+	flushedDataOffset uint64
+	flushedRoots      map[uint32][]byte
+
+	// retained holds snapshots at committed counts so historical proofs are
+	// O(depth) instead of an O(N) rebuild. With COW: O(1) shared roots from
+	// flush. Without COW: deep clones from PrebuildSnapshot/WarmSnapshot while
+	// tip still equals that count (under write lock). A miss falls back to the
+	// rebuild path (speed only, never correctness).
+	retained map[uint32]smstSnapshot
+
+	nodeCounts        map[string]uint32
+	flushedNodeCounts map[string]uint32
+
+	distributionHistory map[uint32]map[string]uint32 // count -> distribution snapshot
+	distFile            *os.File                     // distributions.jsonl (append-only)
+	rootsFile           *os.File                     // flushed_roots.jsonl (append-only)
+
+	// cowEnabled selects insertCOW vs in-place Insert. Default true (SMST_COW
+	// unset).
+	cowEnabled bool
+
+	// snapshotInMemoryClone: when COW is off and PrebuildSnapshot is called at
+	// the live tip, true deep-clones under the write lock into retained; false
+	// rebuilds from artifacts into the process cache without holding the write
+	// lock (upgrade-v0.2.14 style). Default true (SMST_SNAPSHOT_IN_MEMORY_CLONE
+	// unset).
+	snapshotInMemoryClone bool
+}
+
+var _ ArtifactStore = (*SMSTArtifactStore)(nil)
+
+// OpenSMST opens or creates an SMST artifact store in the given directory.
+func OpenSMST(dir string) (*SMSTArtifactStore, error) {
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return nil, fmt.Errorf("create dir: %w", err)
+	}
+
+	dataPath := filepath.Join(dir, "artifacts.data")
+	distPath := filepath.Join(dir, "distributions.jsonl")
+	rootsPath := filepath.Join(dir, "flushed_roots.jsonl")
+
+	dataFile, err := os.OpenFile(dataPath, os.O_RDWR|os.O_CREATE, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("open data file: %w", err)
+	}
+
+	distFile, err := os.OpenFile(distPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
+	if err != nil {
+		dataFile.Close()
+		return nil, fmt.Errorf("open distributions file: %w", err)
+	}
+
+	rootsFile, err := os.OpenFile(rootsPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
+	if err != nil {
+		dataFile.Close()
+		distFile.Close()
+		return nil, fmt.Errorf("open flushed roots file: %w", err)
+	}
+
+	s := &SMSTArtifactStore{
+		dir:                 dir,
+		dataFile:            dataFile,
+		distFile:            distFile,
+		rootsFile:           rootsFile,
+		buffer:              make([]bufferedArtifact, 0, 1024),
+		offsets:             make([]uint64, 0, 1024),
+		nonceToOffset:       make(map[int32]uint64),
+		smst:                NewSMST(smstDefaultDepth),
+		flushedRoots:        make(map[uint32][]byte),
+		retained:            make(map[uint32]smstSnapshot),
+		nodeCounts:          make(map[string]uint32),
+		flushedNodeCounts:   make(map[string]uint32),
+		distributionHistory: make(map[uint32]map[string]uint32),
+		// Defaults when env unset: COW on, deferred hashing on, tip clone on.
+		cowEnabled:            smstCOWEnabledFromEnv(),
+		snapshotInMemoryClone: smstSnapshotInMemoryCloneFromEnv(),
+	}
+	s.smst.deferredHash = smstDeferredHashFromEnv()
+	s.smst.parallelHash = smstParallelHashFromEnv()
+
+
+	if err := s.recover(); err != nil {
+		s.dataFile.Close()
+		s.distFile.Close()
+		s.rootsFile.Close()
+		return nil, fmt.Errorf("recover: %w", err)
+	}
+
+	return s, nil
+}
+
+func (s *SMSTArtifactStore) recover() error {
+	info, err := s.dataFile.Stat()
+	if err != nil {
+		return fmt.Errorf("stat data file: %w", err)
+	}
+
+	if info.Size() == 0 {
+		if err := s.recoverFlushedRoots(); err != nil {
+			log.Printf("warning: failed to recover flushed roots: %v", err)
+		}
+		return s.recoverDistributionHistory()
+	}
+
+	// Recover durable committed counts before replaying so mid-replay can
+	// re-capture retained COW snapshots at each. Prefer flushed_roots.jsonl
+	// (authoritative for flush boundaries); also union distributionHistory for
+	// stores that predate the roots file.
+	if err := s.recoverFlushedRoots(); err != nil {
+		log.Printf("warning: failed to recover flushed roots: %v", err)
+	}
+	if err := s.recoverDistributionHistory(); err != nil {
+		log.Printf("warning: failed to recover distribution history: %v", err)
+	}
+	committed := make(map[uint32]struct{}, len(s.flushedRoots)+len(s.distributionHistory))
+	for c := range s.flushedRoots {
+		committed[c] = struct{}{}
+	}
+	for c := range s.distributionHistory {
+		committed[c] = struct{}{}
+	}
+
+	if _, err := s.dataFile.Seek(0, io.SeekStart); err != nil {
+		return fmt.Errorf("seek data file: %w", err)
+	}
+
+	var offset uint64
+	for {
+		nonce, vector, n, err := readArtifact(s.dataFile)
+		if err == io.EOF {
+			break
+		}
+		if errors.Is(err, io.ErrUnexpectedEOF) {
+			if truncErr := s.dataFile.Truncate(int64(offset)); truncErr != nil {
+				return fmt.Errorf("truncate after partial record: %w", truncErr)
+			}
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("read artifact at offset %d: %w", offset, err)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+		leafHash := smstHashLeaf(leafData)
+
+		// COW keeps mid-replay retained snapshots valid; in-place Insert is used
+		// when SMST_COW=0 (deferred hashing only).
+		if _, err := s.insertLeaf(nonce, leafHash); err != nil {
+			return fmt.Errorf("insert nonce %d: %w", nonce, err)
+		}
+
+		s.offsets = append(s.offsets, offset)
+		s.nonceToOffset[nonce] = offset
+		offset += uint64(n)
+
+		if _, ok := committed[s.smst.Count()]; ok {
+			rootHash, _ := s.smst.GetRoot() // hashes the tree before capture
+			if prev, ok := s.flushedRoots[s.smst.Count()]; ok && prev != nil && !bytes.Equal(prev, rootHash) {
+				log.Printf("warning: flushed root mismatch at count %d: persisted=%x recomputed=%x",
+					s.smst.Count(), prev, rootHash)
+			}
+			s.flushedRoots[s.smst.Count()] = rootHash
+			s.captureRetainedLocked()
+		}
+	}
+
+	s.flushedLeafCount = s.smst.Count()
+	s.flushedDataOffset = offset
+
+	rootHash, _ := s.smst.GetRoot()
+	s.flushedRoots[s.flushedLeafCount] = rootHash
+	s.captureRetainedLocked()
+
+	// Backfill flushed_roots.jsonl for stores that only had distributionHistory
+	// (upgrade path), so a later dist-only loss cannot drop those counts.
+	if err := s.backfillFlushedRootsLocked(); err != nil {
+		log.Printf("warning: failed to backfill flushed roots: %v", err)
+	}
+
+	return nil
+}
+
+func (s *SMSTArtifactStore) recoverDistributionHistory() error {
+	if _, err := s.distFile.Seek(0, io.SeekStart); err != nil {
+		return fmt.Errorf("seek distributions file: %w", err)
+	}
+
+	var latestCount uint32
+	var latestDist map[string]uint32
+
+	reader := bufio.NewReader(s.distFile)
+	lineNum := 0
+	for {
+		line, err := reader.ReadBytes('\n')
+		if err != nil && err != io.EOF {
+			return fmt.Errorf("read distributions file: %w", err)
+		}
+		line = bytes.TrimRight(line, "\r\n")
+		if len(line) > 0 {
+			lineNum++
+			var entry distributionEntry
+			if jsonErr := json.Unmarshal(line, &entry); jsonErr != nil {
+				log.Printf("warning: skipping corrupted distribution entry at line %d: %v", lineNum, jsonErr)
+			} else {
+				distCopy := make(map[string]uint32, len(entry.Dist))
+				for k, v := range entry.Dist {
+					distCopy[k] = v
+				}
+				s.distributionHistory[entry.Count] = distCopy
+				if entry.Count >= latestCount {
+					latestCount = entry.Count
+					latestDist = distCopy
+				}
+			}
+		}
+		if err == io.EOF {
+			break
+		}
+	}
+
+	for k, v := range latestDist {
+		s.flushedNodeCounts[k] = v
+		s.nodeCounts[k] = v
+	}
+
+	return nil
+}
+
+func (s *SMSTArtifactStore) recoverFlushedRoots() error {
+	if s.rootsFile == nil {
+		return nil
+	}
+	if _, err := s.rootsFile.Seek(0, io.SeekStart); err != nil {
+		return fmt.Errorf("seek flushed roots file: %w", err)
+	}
+
+	reader := bufio.NewReader(s.rootsFile)
+	lineNum := 0
+	for {
+		line, err := reader.ReadBytes('\n')
+		if err != nil && err != io.EOF {
+			return fmt.Errorf("read flushed roots file: %w", err)
+		}
+		line = bytes.TrimRight(line, "\r\n")
+		if len(line) > 0 {
+			lineNum++
+			var entry flushedRootEntry
+			if jsonErr := json.Unmarshal(line, &entry); jsonErr != nil {
+				log.Printf("warning: skipping corrupted flushed root entry at line %d: %v", lineNum, jsonErr)
+			} else if entry.Count > 0 {
+				root, decErr := hex.DecodeString(entry.Root)
+				if decErr != nil || len(root) == 0 {
+					log.Printf("warning: skipping flushed root entry at line %d: bad root hex: %v", lineNum, decErr)
+				} else {
+					s.flushedRoots[entry.Count] = root
+				}
+			}
+		}
+		if err == io.EOF {
+			break
+		}
+	}
+	return nil
+}
+
+// backfillFlushedRootsLocked appends any in-memory flushedRoots counts that are
+// missing from flushed_roots.jsonl (e.g. upgraded stores that only had
+// distributions.jsonl). Call after recover has recomputed roots.
+func (s *SMSTArtifactStore) backfillFlushedRootsLocked() error {
+	if s.rootsFile == nil {
+		return nil
+	}
+	persisted := make(map[uint32]struct{}, len(s.flushedRoots))
+	// Re-read what is already on disk so we do not duplicate lines.
+	if _, err := s.rootsFile.Seek(0, io.SeekStart); err != nil {
+		return err
+	}
+	reader := bufio.NewReader(s.rootsFile)
+	for {
+		line, err := reader.ReadBytes('\n')
+		if err != nil && err != io.EOF {
+			return err
+		}
+		line = bytes.TrimRight(line, "\r\n")
+		if len(line) > 0 {
+			var entry flushedRootEntry
+			if json.Unmarshal(line, &entry) == nil && entry.Count > 0 {
+				persisted[entry.Count] = struct{}{}
+			}
+		}
+		if err == io.EOF {
+			break
+		}
+	}
+	for count, root := range s.flushedRoots {
+		if count == 0 || root == nil {
+			continue
+		}
+		if _, ok := persisted[count]; ok {
+			continue
+		}
+		if err := s.appendFlushedRootLocked(count, root); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *SMSTArtifactStore) AddWithNode(nonce int32, vector []byte, nodeId string) error {
+	leafData := encodeLeaf(nonce, vector)
+	leafHash := smstHashLeaf(leafData)
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.closed {
+		return ErrStoreClosed
+	}
+
+	if s.smst.Count() >= MaxLeafCount {
+		return ErrCapacityExceeded
+	}
+
+	if _, err := s.insertLeaf(nonce, leafHash); err != nil {
+		return err
+	}
+
+	s.buffer = append(s.buffer, bufferedArtifact{nonce: nonce, vector: vector, nodeId: nodeId})
+
+	if nodeId != "" {
+		s.nodeCounts[nodeId]++
+	}
+
+	return nil
+}
+
+func (s *SMSTArtifactStore) Flush() error {
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		return ErrStoreClosed
+	}
+	err := s.flushLocked()
+	s.mu.Unlock()
+	return err
+}
+
+func (s *SMSTArtifactStore) flushLocked() error {
+	if len(s.buffer) == 0 {
+		return nil
+	}
+
+	if _, err := s.dataFile.Seek(0, io.SeekEnd); err != nil {
+		return fmt.Errorf("seek data file: %w", err)
+	}
+
+	w := bufio.NewWriter(s.dataFile)
+	offset := s.flushedDataOffset
+
+	for _, art := range s.buffer {
+		s.offsets = append(s.offsets, offset)
+		s.nonceToOffset[art.nonce] = offset
+
+		n, err := writeArtifact(w, art.nonce, art.vector)
+		if err != nil {
+			return fmt.Errorf("write artifact: %w", err)
+		}
+		offset += uint64(n)
+	}
+
+	if err := w.Flush(); err != nil {
+		return fmt.Errorf("flush buffer: %w", err)
+	}
+	if err := s.dataFile.Sync(); err != nil {
+		return fmt.Errorf("sync data file: %w", err)
+	}
+
+	for k, v := range s.nodeCounts {
+		s.flushedNodeCounts[k] = v
+	}
+
+	s.flushedLeafCount = s.smst.Count()
+	s.flushedDataOffset = offset
+	s.buffer = s.buffer[:0]
+
+	rootHash, _ := s.smst.GetRoot()
+	s.flushedRoots[s.flushedLeafCount] = rootHash
+	s.captureRetainedLocked()
+
+	// Persist the flush boundary before the (best-effort) distribution snapshot
+	// so a dist-append failure cannot lose the committed count across restart.
+	if err := s.appendFlushedRootLocked(s.flushedLeafCount, rootHash); err != nil {
+		return fmt.Errorf("persist flushed root: %w", err)
+	}
+
+	if err := s.appendDistributionSnapshot(); err != nil {
+		log.Printf("warning: distribution snapshot failed (will use simulation): %v", err)
+	}
+
+	return nil
+}
+
+func (s *SMSTArtifactStore) appendFlushedRootLocked(count uint32, root []byte) error {
+	if s.rootsFile == nil || count == 0 || root == nil {
+		return nil
+	}
+
+	entry := flushedRootEntry{
+		Count: count,
+		Root:  hex.EncodeToString(root),
+	}
+	data, err := json.Marshal(entry)
+	if err != nil {
+		return fmt.Errorf("marshal flushed root entry: %w", err)
+	}
+	data = append(data, '\n')
+	if _, err := s.rootsFile.Write(data); err != nil {
+		return fmt.Errorf("write flushed root entry: %w", err)
+	}
+	if err := s.rootsFile.Sync(); err != nil {
+		return fmt.Errorf("sync flushed roots file: %w", err)
+	}
+	return nil
+}
+
+func (s *SMSTArtifactStore) appendDistributionSnapshot() error {
+	if s.distFile == nil {
+		return nil
+	}
+
+	distCopy := make(map[string]uint32, len(s.flushedNodeCounts))
+	for k, v := range s.flushedNodeCounts {
+		distCopy[k] = v
+	}
+
+	entry := distributionEntry{
+		Count: s.flushedLeafCount,
+		Dist:  distCopy,
+	}
+
+	data, err := json.Marshal(entry)
+	if err != nil {
+		return fmt.Errorf("marshal distribution entry: %w", err)
+	}
+
+	data = append(data, '\n')
+	if _, err := s.distFile.Write(data); err != nil {
+		return fmt.Errorf("write distribution entry: %w", err)
+	}
+
+	if err := s.distFile.Sync(); err != nil {
+		return fmt.Errorf("sync distributions file: %w", err)
+	}
+
+	s.distributionHistory[s.flushedLeafCount] = distCopy
+
+	return nil
+}
+
+func (s *SMSTArtifactStore) getRoot() []byte {
+	s.mu.RLock()
+	if s.smst.Count() == 0 {
+		s.mu.RUnlock()
+		return nil
+	}
+	if s.liveRootHashed() {
+		root, _ := s.smst.GetRoot()
+		s.mu.RUnlock()
+		return root
+	}
+	s.mu.RUnlock()
+
+	// Deferred hashes need a write; GetRoot → ensureHashed.
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	root, _ := s.smst.GetRoot()
+	return root
+}
+
+func (s *SMSTArtifactStore) GetRootAt(snapshotCount uint32) ([]byte, error) {
+	s.mu.RLock()
+	if s.closed {
+		s.mu.RUnlock()
+		return nil, ErrStoreClosed
+	}
+	if snapshotCount == 0 {
+		s.mu.RUnlock()
+		return nil, nil
+	}
+	if snapshotCount > s.smst.Count() {
+		currentCount := s.smst.Count()
+		s.mu.RUnlock()
+		return nil, fmt.Errorf("snapshot count %d exceeds current count %d", snapshotCount, currentCount)
+	}
+	if snapshotCount == s.smst.Count() && s.liveRootHashed() {
+		root, _ := s.smst.GetRoot()
+		s.mu.RUnlock()
+		return root, nil
+	}
+	if root, ok := s.flushedRoots[snapshotCount]; ok {
+		s.mu.RUnlock()
+		return root, nil
+	}
+	s.mu.RUnlock()
+
+	// Live tip still needs ensureHashed, or a cold historical miss.
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		return nil, ErrStoreClosed
+	}
+	if snapshotCount == s.smst.Count() {
+		root, _ := s.smst.GetRoot()
+		s.mu.Unlock()
+		return root, nil
+	}
+	if root, ok := s.flushedRoots[snapshotCount]; ok {
+		s.mu.Unlock()
+		return root, nil
+	}
+	s.mu.Unlock()
+
+	tree, unlock, err := s.acquireSnapshotTree(snapshotCount)
+	if err != nil {
+		return nil, err
+	}
+	defer unlock()
+	root, _ := tree.GetRoot()
+	return root, nil
+}
+
+func (s *SMSTArtifactStore) GetFlushedRoot() (count uint32, root []byte) {
+	s.mu.RLock()
+	if s.flushedLeafCount == 0 {
+		s.mu.RUnlock()
+		return 0, nil
+	}
+	if root, ok := s.flushedRoots[s.flushedLeafCount]; ok {
+		c := s.flushedLeafCount
+		s.mu.RUnlock()
+		return c, root
+	}
+	s.mu.RUnlock()
+
+	// Fallback: map miss (should be rare). May need ensureHashed on the live tree.
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.flushedLeafCount == 0 {
+		return 0, nil
+	}
+	if root, ok := s.flushedRoots[s.flushedLeafCount]; ok {
+		return s.flushedLeafCount, root
+	}
+	r, _ := s.smst.GetRoot()
+	return s.flushedLeafCount, r
+}
+
+func (s *SMSTArtifactStore) Count() uint32 {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.smst.Count()
+}
+
+func (s *SMSTArtifactStore) GetNodeDistribution() map[string]uint32 {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	result := make(map[string]uint32, len(s.flushedNodeCounts))
+	for k, v := range s.flushedNodeCounts {
+		result[k] = v
+	}
+	return result
+}
+
+func (s *SMSTArtifactStore) GetNodeCounts() map[string]uint32 {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	result := make(map[string]uint32, len(s.nodeCounts))
+	for k, v := range s.nodeCounts {
+		result[k] = v
+	}
+	return result
+}
+
+func (s *SMSTArtifactStore) GetNodeDistributionAt(count uint32) (map[string]uint32, bool, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	if count == 0 {
+		return make(map[string]uint32), true, nil
+	}
+
+	if dist, ok := s.distributionHistory[count]; ok {
+		result := make(map[string]uint32, len(dist))
+		for k, v := range dist {
+			result[k] = v
+		}
+		return result, true, nil
+	}
+
+	return s.simulateDistribution(count), false, nil
+}
+
+func (s *SMSTArtifactStore) simulateDistribution(targetCount uint32) map[string]uint32 {
+	if len(s.flushedNodeCounts) == 0 {
+		return make(map[string]uint32)
+	}
+
+	var totalFlushed uint32
+	for _, c := range s.flushedNodeCounts {
+		totalFlushed += c
+	}
+
+	if totalFlushed == 0 {
+		return make(map[string]uint32)
+	}
+
+	result := make(map[string]uint32, len(s.flushedNodeCounts))
+	var allocated uint32
+
+	nodes := make([]string, 0, len(s.flushedNodeCounts))
+	for k := range s.flushedNodeCounts {
+		nodes = append(nodes, k)
+	}
+
+	for _, nodeId := range nodes {
+		proportion := float64(s.flushedNodeCounts[nodeId]) / float64(totalFlushed)
+		scaled := uint32(proportion * float64(targetCount))
+		result[nodeId] = scaled
+		allocated += scaled
+	}
+
+	remainder := targetCount - allocated
+	if remainder > 0 && len(nodes) > 0 {
+		result[nodes[0]] += remainder
+	}
+
+	return result
+}
+
+func (s *SMSTArtifactStore) getArtifactByNonce(targetNonce int32) (int32, []byte, error) {
+	// Check flushed artifacts first (via index)
+	if offset, ok := s.nonceToOffset[targetNonce]; ok {
+		nonce, vector, _, err := readArtifactAt(s.dataFile, int64(offset))
+		if err != nil {
+			return 0, nil, fmt.Errorf("read artifact: %w", err)
+		}
+		return nonce, vector, nil
+	}
+
+	// Search in buffer (not yet flushed)
+	for _, art := range s.buffer {
+		if art.nonce == targetNonce {
+			return art.nonce, art.vector, nil
+		}
+	}
+
+	return 0, nil, ErrLeafIndexOutOfRange
+}
+
+// GetArtifactAndProof retrieves both artifact and proof for a dense index at a specific snapshot.
+// This ensures the nonce/vector and proof are consistent with the same snapshot tree state,
+// preventing the bug where GetArtifact uses current tree but GetProof uses snapshot tree.
+func (s *SMSTArtifactStore) GetArtifactAndProof(denseIndex uint32, snapshotCount uint32) (nonce int32, vector []byte, proof [][]byte, err error) {
+	entries, err := s.GetArtifactsAndProofs([]uint32{denseIndex}, snapshotCount)
+	if err != nil {
+		return 0, nil, nil, err
+	}
+	if len(entries) != 1 {
+		return 0, nil, nil, ErrLeafIndexOutOfRange
+	}
+	entry := entries[0]
+	return entry.Nonce, entry.Vector, entry.Proof, nil
+}
+
+func (s *SMSTArtifactStore) GetArtifactsAndProofs(denseIndices []uint32, snapshotCount uint32) ([]ProofEntry, error) {
+	if len(denseIndices) == 0 {
+		return nil, nil
+	}
+	if snapshotCount == 0 {
+		return nil, ErrLeafIndexOutOfRange
+	}
+	for _, denseIndex := range denseIndices {
+		if denseIndex >= snapshotCount {
+			return nil, ErrLeafIndexOutOfRange
+		}
+	}
+
+	tree, unlock, err := s.acquireSnapshotTree(snapshotCount)
+	if err != nil {
+		return nil, err
+	}
+	defer unlock()
+
+	entries := make([]ProofEntry, 0, len(denseIndices))
+	for _, denseIndex := range denseIndices {
+		nonce, _, err := tree.GetLeafByDenseIndex(denseIndex)
+		if err != nil {
+			return nil, err
+		}
+		entry, err := s.proofEntry(tree, nonce, denseIndex)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, entry)
+	}
+
+	return entries, nil
+}
+
+// GetArtifactAndProofByNonce retrieves artifact data and proof for a nonce at a
+// specific snapshot, returning the nonce's dense index in that snapshot.
+func (s *SMSTArtifactStore) GetArtifactAndProofByNonce(targetNonce int32, snapshotCount uint32) (denseIndex uint32, vector []byte, proof [][]byte, err error) {
+	entries, err := s.GetArtifactsAndProofsByNonce([]int32{targetNonce}, snapshotCount)
+	if err != nil {
+		return 0, nil, nil, err
+	}
+	if len(entries) == 0 {
+		return 0, nil, nil, ErrNonceNotFound
+	}
+	entry := entries[0]
+	return entry.DenseIndex, entry.Vector, entry.Proof, nil
+}
+
+func (s *SMSTArtifactStore) GetArtifactsAndProofsByNonce(nonces []int32, snapshotCount uint32) ([]ProofEntry, error) {
+	if len(nonces) == 0 || snapshotCount == 0 {
+		return nil, nil
+	}
+
+	tree, unlock, err := s.acquireSnapshotTree(snapshotCount)
+	if err != nil {
+		return nil, err
+	}
+	defer unlock()
+
+	entries := make([]ProofEntry, 0, len(nonces))
+	for _, nonce := range nonces {
+		if !tree.HasNonce(nonce) {
+			continue
+		}
+		denseIndex, err := tree.denseIndexForNonce(nonce)
+		if err != nil {
+			return nil, err
+		}
+		entry, err := s.proofEntry(tree, nonce, denseIndex)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, entry)
+	}
+
+	return entries, nil
+}
+
+// acquireSnapshotTree returns the tree for snapshotCount with the store
+// locked for the caller; the caller must call unlock() when done.
+// Live tip (hashes already filled) and retained historical snapshots are
+// served under RLock so concurrent proofs stay parallel. Filling deferred
+// hashes on the live tip takes Lock only for ensureHashed, then retries so
+// proof I/O runs under RLock. Cold-start rebuilds use the process-wide
+// snapshot cache, then RLock for artifact reads.
+func (s *SMSTArtifactStore) acquireSnapshotTree(snapshotCount uint32) (*SMST, func(), error) {
+	// Fast path: if the requested count is the live tip and its hashes are
+	// already filled, serve under a read lock so concurrent proof reads stay
+	// parallel. Writers hold the write lock, so under RLock neither the count
+	// nor the node hashes can change; a filled root implies a fully hashed tree.
+	s.mu.RLock()
+	if s.closed {
+		s.mu.RUnlock()
+		return nil, nil, ErrStoreClosed
+	}
+	if snapshotCount == s.smst.Count() && s.liveRootHashed() {
+		return s.smst, s.mu.RUnlock, nil
+	}
+	s.mu.RUnlock()
+
+	// Slow path: a historical count, or the live tip still needs deferred hashes
+	// filled, which is a mutation and requires the write lock.
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		return nil, nil, ErrStoreClosed
+	}
+	currentCount := s.smst.Count()
+	if snapshotCount > currentCount {
+		s.mu.Unlock()
+		return nil, nil, fmt.Errorf("snapshot count %d exceeds current count %d", snapshotCount, currentCount)
+	}
+	if snapshotCount == currentCount {
+		// Fill hashes under Lock only — do not hold the write lock across proof
+		// I/O. Retry so concurrent tip readers share the RLock fast path.
+		s.smst.ensureHashed()
+		s.mu.Unlock()
+		return s.acquireSnapshotTree(snapshotCount)
+	}
+	// Historical count: serve from the retained copy-on-write snapshot in
+	// O(depth) if one was captured at this committed count. Snapshots are
+	// captured after a GetRoot, so their nodes are already hashed; the shared
+	// nodes are immutable (insertCOW never rewrites them), so the view stays
+	// valid after the write lock is released. Drop Lock before proof I/O so
+	// ingest and concurrent proofs are not serialized behind getArtifactByNonce;
+	// re-take RLock so proofEntry can safely read nonceToOffset / buffer.
+	if view, ok := s.retainedSnapshotViewLocked(snapshotCount); ok {
+		s.mu.Unlock()
+		s.mu.RLock()
+		if s.closed {
+			s.mu.RUnlock()
+			return nil, nil, ErrStoreClosed
+		}
+		return view, s.mu.RUnlock, nil
+	}
+	_, committed := s.flushedRoots[snapshotCount]
+	s.mu.Unlock()
+
+	if !committed {
+		// Not a committed count: its root can never match the on-chain
+		// commitment, so it is never legitimately provable. Rejecting here
+		// instead of rebuilding removes the per-request O(N) rebuild, and with it
+		// the rebuild-DoS surface — so no per-validator snapshot-count quota is
+		// needed. Committed counts are all retained (live capture, or recovery
+		// re-capture after a restart); the rebuild below is a cold-start edge.
+		return nil, nil, fmt.Errorf("snapshot count %d is not a committed count", snapshotCount)
+	}
+
+	tree, err := globalSnapshotCache.getOrBuild(s, snapshotCount, false)
+	if err != nil {
+		return nil, nil, err
+	}
+	s.mu.RLock()
+	if s.closed {
+		s.mu.RUnlock()
+		return nil, nil, ErrStoreClosed
+	}
+	return tree, s.mu.RUnlock, nil
+}
+
+// liveRootHashed reports whether the live tree's deferred hashes are already
+// filled. A nil root (empty tree) is treated as ready. Callers must hold mu.
+func (s *SMSTArtifactStore) liveRootHashed() bool {
+	return s.smst.root == nil || s.smst.root.hash != nil
+}
+
+// insertLeaf adds a leaf via insertCOW (default) or in-place Insert when
+// SMST_COW is disabled. Both paths use deferred hashing.
+func (s *SMSTArtifactStore) insertLeaf(nonce int32, leafHash []byte) (uint32, error) {
+	if s.cowEnabled {
+		return s.smst.insertCOW(nonce, leafHash)
+	}
+	return s.smst.Insert(nonce, leafHash)
+}
+
+// captureRetainedLocked records a copy-on-write snapshot of the tree at the
+// current committed count so its proofs are served in O(depth) without a
+// rebuild. The write lock must be held; call after GetRoot so the retained nodes
+// are already hashed. Bounded by the store's per-stage lifetime. No-op when
+// COW is disabled — in-place inserts would invalidate shared snapshot nodes.
+func (s *SMSTArtifactStore) captureRetainedLocked() {
+	if !s.cowEnabled {
+		return
+	}
+	count := s.smst.Count()
+	if count == 0 {
+		return
+	}
+	if _, ok := s.retained[count]; ok {
+		return
+	}
+	s.retained[count] = s.smst.snapshot()
+}
+
+// retainedSnapshotViewLocked returns an O(depth) read-only view over the
+// retained snapshot at count, or ok=false when none was captured. The lock must
+// be held (it reads the retained map); the returned view shares immutable nodes.
+func (s *SMSTArtifactStore) retainedSnapshotViewLocked(count uint32) (*SMST, bool) {
+	snap, ok := s.retained[count]
+	if !ok {
+		return nil, false
+	}
+	return s.smst.snapshotView(snap), true
+}
+
+// proofEntry builds a ProofEntry for a nonce known to be in tree.
+// Requires the store read lock to be held.
+func (s *SMSTArtifactStore) proofEntry(tree *SMST, nonce int32, denseIndex uint32) (ProofEntry, error) {
+	_, vector, err := s.getArtifactByNonce(nonce)
+	if err != nil {
+		return ProofEntry{}, err
+	}
+	return ProofEntry{
+		DenseIndex: denseIndex,
+		Nonce:      nonce,
+		Vector:     vector,
+		Proof:      encodeProofForTransport(s.buildProofWithCounts(tree, nonce)),
+	}, nil
+}
+
+func (s *SMSTArtifactStore) buildProofWithCounts(tree *SMST, nonce int32) []smstProofElement {
+	path := tree.noncePath(nonce)
+	elements := make([]smstProofElement, 0, tree.depth)
+
+	var collectWithCounts func(node *smstNode, level int)
+	collectWithCounts = func(node *smstNode, level int) {
+		if level == tree.depth || node == nil {
+			return
+		}
+
+		goRight := path[level]
+		if goRight {
+			elements = append(elements, smstProofElement{
+				siblingHash:  tree.nodeHash(node.left, level+1),
+				siblingCount: tree.nodeCount(node.left),
+			})
+			collectWithCounts(node.right, level+1)
+		} else {
+			elements = append(elements, smstProofElement{
+				siblingHash:  tree.nodeHash(node.right, level+1),
+				siblingCount: tree.nodeCount(node.right),
+			})
+			collectWithCounts(node.left, level+1)
+		}
+	}
+
+	collectWithCounts(tree.root, 0)
+	return elements
+}
+
+func encodeProofForTransport(proof []smstProofElement) [][]byte {
+	result := make([][]byte, len(proof))
+	for i, elem := range proof {
+		encoded := make([]byte, 36)
+		copy(encoded[:32], elem.siblingHash)
+		binary.LittleEndian.PutUint32(encoded[32:], elem.siblingCount)
+		result[i] = encoded
+	}
+	return result
+}
+
+func (s *SMSTArtifactStore) snapshotRebuildInputs(count uint32) ([]uint64, []bufferedArtifact, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	if s.closed {
+		return nil, nil, ErrStoreClosed
+	}
+	if count > s.smst.Count() {
+		return nil, nil, fmt.Errorf("snapshot count %d exceeds current count %d", count, s.smst.Count())
+	}
+
+	flushedToRead := count
+	if flushedToRead > s.flushedLeafCount {
+		flushedToRead = s.flushedLeafCount
+	}
+	offsets := slices.Clone(s.offsets[:flushedToRead])
+
+	var buffered []bufferedArtifact
+	if count > s.flushedLeafCount {
+		remaining := count - s.flushedLeafCount
+		bufferedCount := min(int(remaining), len(s.buffer))
+		buffered = slices.Clone(s.buffer[:bufferedCount])
+	}
+
+	return offsets, buffered, nil
+}
+
+func rebuildTreeFromInputs(dataFile *os.File, offsets []uint64, buffered []bufferedArtifact, count uint32) *SMST {
+	// Seed with the default depth, not the live tree's depth: replaying the
+	// first `count` artifacts triggers exactly the depth expansions the tree
+	// had when the root for `count` was committed. Using the live depth would
+	// bake in expansions caused by artifacts inserted after that commit,
+	// producing a root that no longer matches the committed one.
+	tree := NewSMST(smstDefaultDepth)
+	tree.parallelHash = smstParallelHashFromEnv()
+
+	// Read flushed artifacts from disk
+	var skipped uint32
+	for _, offset := range offsets {
+		nonce, vector, _, err := readArtifactAt(dataFile, int64(offset))
+		if err != nil {
+			skipped++
+			continue
+		}
+		leafData := encodeLeaf(nonce, vector)
+		leafHash := smstHashLeaf(leafData)
+		if _, err := tree.Insert(nonce, leafHash); err != nil {
+			log.Printf("[WARN] SMST snapshot rebuild: insert failed for nonce %d: %v (possible data corruption)", nonce, err)
+		}
+	}
+	if skipped > 0 {
+		log.Printf("[WARN] SMST snapshot rebuild: skipped %d/%d artifacts due to read errors", skipped, len(offsets))
+	}
+
+	// Read remaining from buffer if needed
+	for _, art := range buffered {
+		leafData := encodeLeaf(art.nonce, art.vector)
+		leafHash := smstHashLeaf(leafData)
+		tree.Insert(art.nonce, leafHash)
+	}
+
+	if tree.Count() != count {
+		log.Printf("[WARN] SMST snapshot rebuild: rebuilt count %d differs from requested %d", tree.Count(), count)
+	}
+	tree.ensureHashed() // fresh, single-owned tree — hash before it is cached/served
+	return tree
+}
+
+// PrebuildSnapshot pins a historical tree at count for fast proof queries.
+//
+// Live tip (count == leaf count):
+//   - COW on: O(1) retain under write lock (no-op if flush already retained).
+//   - COW off + SMST_SNAPSHOT_IN_MEMORY_CLONE=1 (default): deep clone under
+//     write lock into retained.
+//   - COW off + SMST_SNAPSHOT_IN_MEMORY_CLONE=0: unlock, then rebuild from
+//     artifacts into the process snapshot cache (upgrade-v0.2.14 Warm/Prebuild;
+//     write lock not held during rebuild).
+//
+// Tip already advanced with no retained capture: committed counts rebuild into
+// the cache (cold path); uncommitted counts are rejected.
+func (s *SMSTArtifactStore) PrebuildSnapshot(count uint32) error {
+	if count == 0 {
+		return nil
+	}
+
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		return ErrStoreClosed
+	}
+	if _, ok := s.retained[count]; ok {
+		s.mu.Unlock()
+		return nil
+	}
+	if count == s.smst.Count() {
+		if s.cowEnabled {
+			s.smst.ensureHashed()
+			s.retained[count] = s.smst.snapshot()
+			s.mu.Unlock()
+			return nil
+		}
+		if s.snapshotInMemoryClone {
+			s.smst.ensureHashed()
+			s.retained[count] = s.smst.cloneSnapshot()
+			s.mu.Unlock()
+			return nil
+		}
+		// v0.2.14-style: do not hold the write lock across artifact rebuild.
+		s.mu.Unlock()
+		_, err := globalSnapshotCache.getOrBuild(s, count, true)
+		return err
+	}
+	_, committed := s.flushedRoots[count]
+	s.mu.Unlock()
+
+	if !committed {
+		return fmt.Errorf("snapshot count %d is not a committed count", count)
+	}
+	_, err := globalSnapshotCache.getOrBuild(s, count, true)
+	return err
+}
+
+// WarmSnapshot pins the snapshot tree for count so later proof requests hit
+// retained (tip deep-copy / COW) or the process cache. Blocking; callers may
+// run it in the background.
+func (s *SMSTArtifactStore) WarmSnapshot(count uint32) {
+	if count == 0 {
+		return
+	}
+	if err := s.PrebuildSnapshot(count); err != nil {
+		log.Printf("[WARN] SMST WarmSnapshot(%d) failed: %v", count, err)
+	}
+}
+
+func (s *SMSTArtifactStore) Close() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.closed {
+		return nil
+	}
+
+	s.closed = true
+	globalSnapshotCache.purgeStore(s)
+
+	if err := s.flushLocked(); err != nil {
+		return fmt.Errorf("flush on close: %w", err)
+	}
+
+	if err := s.dataFile.Close(); err != nil {
+		return fmt.Errorf("close data file: %w", err)
+	}
+
+	if s.distFile != nil {
+		if err := s.distFile.Close(); err != nil {
+			return fmt.Errorf("close distributions file: %w", err)
+		}
+	}
+
+	if s.rootsFile != nil {
+		if err := s.rootsFile.Close(); err != nil {
+			return fmt.Errorf("close flushed roots file: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func writeArtifact(w io.Writer, nonce int32, vector []byte) (int, error) {
+	totalLen := 4 + len(vector)
+	header := make([]byte, 8)
+	binary.LittleEndian.PutUint32(header[0:4], uint32(totalLen))
+	binary.LittleEndian.PutUint32(header[4:8], uint32(nonce))
+
+	n1, err := w.Write(header)
+	if err != nil {
+		return n1, err
+	}
+
+	n2, err := w.Write(vector)
+	if err != nil {
+		return n1 + n2, err
+	}
+
+	return n1 + n2, nil
+}
+
+func readArtifact(r io.Reader) (int32, []byte, int, error) {
+	var header [8]byte
+	if _, err := io.ReadFull(r, header[:]); err != nil {
+		return 0, nil, 0, err
+	}
+
+	totalLen := binary.LittleEndian.Uint32(header[0:4])
+	nonce := int32(binary.LittleEndian.Uint32(header[4:8]))
+
+	vectorLen := totalLen - 4
+	vector := make([]byte, vectorLen)
+	if _, err := io.ReadFull(r, vector); err != nil {
+		return 0, nil, 0, err
+	}
+
+	return nonce, vector, 8 + int(vectorLen), nil
+}
+
+func readArtifactAt(r io.ReaderAt, offset int64) (int32, []byte, int, error) {
+	var header [8]byte
+	if _, err := r.ReadAt(header[:], offset); err != nil {
+		return 0, nil, 0, err
+	}
+
+	totalLen := binary.LittleEndian.Uint32(header[0:4])
+	nonce := int32(binary.LittleEndian.Uint32(header[4:8]))
+
+	vectorLen := totalLen - 4
+	vector := make([]byte, vectorLen)
+	if _, err := r.ReadAt(vector, offset+8); err != nil {
+		return 0, nil, 0, err
+	}
+
+	return nonce, vector, 8 + int(vectorLen), nil
+}
+
+func encodeLeaf(nonce int32, vector []byte) []byte {
+	buf := make([]byte, 4+len(vector))
+	binary.LittleEndian.PutUint32(buf[:4], uint32(nonce))
+	copy(buf[4:], vector)
+	return buf
+}
diff --git a/decentralized-api/poc/artifacts/smst_test.go b/decentralized-api/poc/artifacts/smst_test.go
new file mode 100644
index 0000000000..4f8ec7dde3
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_test.go
@@ -0,0 +1,2670 @@
+package artifacts
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"testing"
+)
+
+// Test helpers - these mirror removed production functions for test convenience
+
+type SMSTProofElement struct {
+	SiblingHash  []byte
+	SiblingCount uint32
+}
+
+func DecodeProofElements(proof [][]byte) []SMSTProofElement {
+	elements := make([]SMSTProofElement, len(proof))
+	for i, data := range proof {
+		if len(data) != 36 {
+			return nil
+		}
+		elements[i].SiblingHash = data[:32]
+		elements[i].SiblingCount = binary.LittleEndian.Uint32(data[32:36])
+	}
+	return elements
+}
+
+func VerifySMSTProofWithCounts(rootHash []byte, count uint32, nonce int32, leafData []byte, proof []SMSTProofElement) bool {
+	if len(proof) == 0 {
+		return false
+	}
+
+	depth := len(proof)
+	leafHash := smstHashLeaf(leafData)
+	path := smstNoncePath(nonce, depth)
+
+	currentHash := leafHash
+	currentCount := uint32(1)
+
+	for i := depth - 1; i >= 0; i-- {
+		elem := proof[i]
+		goRight := path[i]
+
+		var leftHash, rightHash []byte
+		var leftCount, rightCount uint32
+
+		if goRight {
+			leftHash = elem.SiblingHash
+			rightHash = currentHash
+			leftCount = elem.SiblingCount
+			rightCount = currentCount
+		} else {
+			leftHash = currentHash
+			rightHash = elem.SiblingHash
+			leftCount = currentCount
+			rightCount = elem.SiblingCount
+		}
+
+		currentCount = leftCount + rightCount
+		currentHash = smstHashNode(leftHash, rightHash, currentCount)
+	}
+
+	if currentCount != count {
+		return false
+	}
+
+	return bytesEqual(currentHash, rootHash)
+}
+
+func VerifySMSTProofSlice(rootHash []byte, count uint32, nonce int32, leafData []byte, proof [][]byte) bool {
+	if len(proof) == 0 {
+		return false
+	}
+	elements := DecodeProofElements(proof)
+	if elements == nil {
+		return false
+	}
+	return VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements)
+}
+
+func EncodeSMSTProof(proof []SMSTProofElement) []byte {
+	if len(proof) == 0 {
+		return nil
+	}
+	buf := make([]byte, 1+len(proof)*36)
+	buf[0] = byte(len(proof))
+	offset := 1
+	for _, elem := range proof {
+		copy(buf[offset:offset+32], elem.SiblingHash)
+		binary.LittleEndian.PutUint32(buf[offset+32:offset+36], elem.SiblingCount)
+		offset += 36
+	}
+	return buf
+}
+
+func DecodeSMSTProof(data []byte) ([]SMSTProofElement, error) {
+	if len(data) < 1 {
+		return nil, ErrLeafIndexOutOfRange
+	}
+	depth := int(data[0])
+	if len(data) != 1+depth*36 {
+		return nil, ErrLeafIndexOutOfRange
+	}
+	proof := make([]SMSTProofElement, depth)
+	offset := 1
+	for i := 0; i < depth; i++ {
+		proof[i].SiblingHash = make([]byte, 32)
+		copy(proof[i].SiblingHash, data[offset:offset+32])
+		proof[i].SiblingCount = binary.LittleEndian.Uint32(data[offset+32 : offset+36])
+		offset += 36
+	}
+	return proof, nil
+}
+
+func encodeTestProofForTransport(proof []SMSTProofElement) [][]byte {
+	result := make([][]byte, len(proof))
+	for i, elem := range proof {
+		encoded := make([]byte, 36)
+		copy(encoded[:32], elem.SiblingHash)
+		binary.LittleEndian.PutUint32(encoded[32:], elem.SiblingCount)
+		result[i] = encoded
+	}
+	return result
+}
+
+func (s *SMSTArtifactStore) Add(nonce int32, vector []byte) error {
+	return s.AddWithNode(nonce, vector, "")
+}
+
+func (s *SMSTArtifactStore) GetRoot() []byte {
+	return s.getRoot()
+}
+
+func TestSMSTEmpty(t *testing.T) {
+	tree := NewSMST(24)
+
+	root, count := tree.GetRoot()
+	if count != 0 {
+		t.Errorf("expected count 0, got %d", count)
+	}
+	if root == nil {
+		t.Error("expected non-nil empty root")
+	}
+}
+
+func TestSMSTInsertAndCount(t *testing.T) {
+	tree := NewSMST(24)
+
+	for i := int32(0); i < 10; i++ {
+		leafHash := smstHashLeaf(encodeLeaf(i, []byte{byte(i)}))
+		_, err := tree.Insert(i, leafHash)
+		if err != nil {
+			t.Fatalf("Insert(%d) failed: %v", i, err)
+		}
+	}
+
+	if tree.Count() != 10 {
+		t.Errorf("expected count 10, got %d", tree.Count())
+	}
+}
+
+func TestSMSTDuplicateRejection(t *testing.T) {
+	tree := NewSMST(24)
+
+	leafHash := smstHashLeaf(encodeLeaf(42, []byte{1, 2, 3}))
+	if _, err := tree.Insert(42, leafHash); err != nil {
+		t.Fatalf("First Insert failed: %v", err)
+	}
+
+	if _, err := tree.Insert(42, leafHash); err != ErrDuplicateNonce {
+		t.Errorf("expected ErrDuplicateNonce, got %v", err)
+	}
+
+	if tree.Count() != 1 {
+		t.Errorf("expected count 1, got %d", tree.Count())
+	}
+}
+
+func TestSMSTDenseIndexNavigation(t *testing.T) {
+	tree := NewSMST(24)
+
+	nonces := []int32{100, 5, 1000, 50, 10}
+	for _, nonce := range nonces {
+		leafHash := smstHashLeaf(encodeLeaf(nonce, []byte{byte(nonce)}))
+		tree.Insert(nonce, leafHash)
+	}
+
+	for i := uint32(0); i < tree.Count(); i++ {
+		_, proof, err := tree.GetLeafByDenseIndex(i)
+		if err != nil {
+			t.Fatalf("GetLeafByDenseIndex(%d) failed: %v", i, err)
+		}
+		if len(proof) == 0 {
+			t.Errorf("expected non-empty proof for index %d", i)
+		}
+	}
+}
+
+func TestSMSTRootConsistency(t *testing.T) {
+	tree1 := NewSMST(24)
+	tree2 := NewSMST(24)
+
+	nonces := []int32{10, 20, 30}
+	for _, n := range nonces {
+		leafHash := smstHashLeaf(encodeLeaf(n, []byte{byte(n)}))
+		tree1.Insert(n, leafHash)
+	}
+
+	for i := len(nonces) - 1; i >= 0; i-- {
+		n := nonces[i]
+		leafHash := smstHashLeaf(encodeLeaf(n, []byte{byte(n)}))
+		tree2.Insert(n, leafHash)
+	}
+
+	root1, _ := tree1.GetRoot()
+	root2, _ := tree2.GetRoot()
+
+	if !bytes.Equal(root1, root2) {
+		t.Error("roots should be equal regardless of insertion order")
+	}
+}
+
+func TestSMSTDepthExpansion(t *testing.T) {
+	tree := NewSMST(4)
+
+	largeNonce := int32(1 << 20)
+	leafHash := smstHashLeaf(encodeLeaf(largeNonce, []byte{1}))
+
+	_, err := tree.Insert(largeNonce, leafHash)
+	if err != nil {
+		t.Fatalf("Insert with large nonce failed: %v", err)
+	}
+
+	if tree.Depth() < 20 {
+		t.Errorf("expected depth >= 20, got %d", tree.Depth())
+	}
+}
+
+func TestSMSTStoreBasics(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	if store.Count() != 0 {
+		t.Errorf("expected count 0, got %d", store.Count())
+	}
+
+	for i := int32(0); i < 10; i++ {
+		if err := store.Add(i, []byte{byte(i)}); err != nil {
+			t.Fatalf("Add(%d) failed: %v", i, err)
+		}
+	}
+
+	if store.Count() != 10 {
+		t.Errorf("expected count 10, got %d", store.Count())
+	}
+}
+
+func TestSMSTStoreDuplicateRejection(t *testing.T) {
+	dir := t.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	if err := store.Add(42, []byte{1}); err != nil {
+		t.Fatalf("First Add failed: %v", err)
+	}
+
+	if err := store.Add(42, []byte{2}); err != ErrDuplicateNonce {
+		t.Errorf("expected ErrDuplicateNonce, got %v", err)
+	}
+}
+
+func TestSMSTStoreRecovery(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, _ := OpenSMST(dir)
+	for i := int32(0); i < 5; i++ {
+		store1.Add(i*10, []byte{byte(i)})
+	}
+	store1.Flush()
+	root1 := store1.GetRoot()
+	count1 := store1.Count()
+	store1.Close()
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("Reopen failed: %v", err)
+	}
+	defer store2.Close()
+
+	if store2.Count() != count1 {
+		t.Errorf("recovered count: expected %d, got %d", count1, store2.Count())
+	}
+
+	root2 := store2.GetRoot()
+	if !bytes.Equal(root1, root2) {
+		t.Error("recovered root mismatch")
+	}
+}
+
+func TestSMSTStoreProof(t *testing.T) {
+	dir := t.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	for i := int32(0); i < 8; i++ {
+		store.Add(i, []byte{byte(i)})
+	}
+
+	root := store.GetRoot()
+	for i := uint32(0); i < 8; i++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(i, 8)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d) failed: %v", i, err)
+		}
+		if len(proof) == 0 {
+			t.Errorf("expected non-empty proof for index %d", i)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+
+		proofElements := decodeProofFromTransport(proof)
+		if !VerifySMSTProofWithCounts(root, 8, nonce, leafData, proofElements) {
+			t.Errorf("proof verification failed for index %d", i)
+		}
+	}
+}
+
+func decodeProofFromTransport(proof [][]byte) []SMSTProofElement {
+	elements := make([]SMSTProofElement, len(proof))
+	for i, data := range proof {
+		elements[i].SiblingHash = data[:32]
+		elements[i].SiblingCount = binary.LittleEndian.Uint32(data[32:])
+	}
+	return elements
+}
+
+func TestSMSTStoreGetArtifact(t *testing.T) {
+	dir := t.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	// Artifacts inserted in random order
+	inputArtifacts := []struct {
+		nonce  int32
+		vector []byte
+	}{
+		{100, []byte{1, 2, 3}},
+		{50, []byte{4, 5, 6}},
+		{200, []byte{7, 8, 9}},
+	}
+
+	for _, a := range inputArtifacts {
+		store.Add(a.nonce, a.vector)
+	}
+
+	// SMST returns artifacts in tree-traversal order (by nonce position)
+	// Smaller nonces go to the left, so order should be: 50, 100, 200
+	expectedOrder := []struct {
+		nonce  int32
+		vector []byte
+	}{
+		{50, []byte{4, 5, 6}},
+		{100, []byte{1, 2, 3}},
+		{200, []byte{7, 8, 9}},
+	}
+
+	count := store.Count()
+	for i, expected := range expectedOrder {
+		nonce, vector, _, err := store.GetArtifactAndProof(uint32(i), count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d) failed: %v", i, err)
+		}
+		if nonce != expected.nonce {
+			t.Errorf("artifact %d: expected nonce %d, got %d", i, expected.nonce, nonce)
+		}
+		if !bytes.Equal(vector, expected.vector) {
+			t.Errorf("artifact %d: vector mismatch", i)
+		}
+	}
+}
+
+func TestSMSTVerifyProof(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	nonces := []int32{10, 20, 30, 40, 50}
+	for _, n := range nonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	count, rootHash := store.GetFlushedRoot()
+
+	for i := uint32(0); i < count; i++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(i, count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d): %v", i, err)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+		if !VerifySMSTProofSlice(rootHash, count, nonce, leafData, proof) {
+			t.Errorf("Proof verification failed for index %d (nonce=%d)", i, nonce)
+		}
+	}
+}
+
+func TestSMSTProofEncoding(t *testing.T) {
+	proof := []SMSTProofElement{
+		{SiblingHash: make([]byte, 32), SiblingCount: 100},
+		{SiblingHash: make([]byte, 32), SiblingCount: 200},
+	}
+
+	for i := range proof[0].SiblingHash {
+		proof[0].SiblingHash[i] = byte(i)
+	}
+	for i := range proof[1].SiblingHash {
+		proof[1].SiblingHash[i] = byte(32 - i)
+	}
+
+	encoded := EncodeSMSTProof(proof)
+	decoded, err := DecodeSMSTProof(encoded)
+	if err != nil {
+		t.Fatalf("DecodeSMSTProof failed: %v", err)
+	}
+
+	if len(decoded) != len(proof) {
+		t.Fatalf("decoded length mismatch: expected %d, got %d", len(proof), len(decoded))
+	}
+
+	for i := range proof {
+		if !bytes.Equal(decoded[i].SiblingHash, proof[i].SiblingHash) {
+			t.Errorf("element %d: hash mismatch", i)
+		}
+		if decoded[i].SiblingCount != proof[i].SiblingCount {
+			t.Errorf("element %d: count mismatch: expected %d, got %d", i, proof[i].SiblingCount, decoded[i].SiblingCount)
+		}
+	}
+}
+
+func BenchmarkSMSTAdd(b *testing.B) {
+	dir := b.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	vector := make([]byte, 24)
+	for i := range vector {
+		vector[i] = byte(i)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		store.Add(int32(i), vector)
+	}
+}
+
+func BenchmarkSMSTAddWithFlush(b *testing.B) {
+	dir := b.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	vector := make([]byte, 24)
+	for i := range vector {
+		vector[i] = byte(i)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		store.Add(int32(i), vector)
+		if (i+1)%1000 == 0 {
+			store.Flush()
+		}
+	}
+	store.Flush()
+}
+
+func BenchmarkSMSTGetProof(b *testing.B) {
+	dir := b.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	const treeSize = 100000
+	vector := make([]byte, 24)
+	for i := 0; i < treeSize; i++ {
+		store.Add(int32(i), vector)
+	}
+	store.Flush()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		leafIdx := uint32(i % treeSize)
+		store.GetArtifactAndProof(leafIdx, treeSize)
+	}
+}
+
+func BenchmarkSMSTVerifyProof(b *testing.B) {
+	dir := b.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	const treeSize = 100000
+	vector := make([]byte, 24)
+	for i := 0; i < treeSize; i++ {
+		store.Add(int32(i), vector)
+	}
+	store.Flush()
+
+	root := store.GetRoot()
+	proofs := make([][][]byte, 100)
+	nonces := make([]int32, 100)
+	for i := 0; i < 100; i++ {
+		nonces[i], _, proofs[i], _ = store.GetArtifactAndProof(uint32(i), treeSize)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		idx := i % 100
+		leafData := encodeLeaf(nonces[idx], vector)
+		elements := decodeProofFromTransport(proofs[idx])
+		VerifySMSTProofWithCounts(root, treeSize, nonces[idx], leafData, elements)
+	}
+}
+
+func BenchmarkSMSTRecovery(b *testing.B) {
+	sizes := []int{10000, 100000, 1000000}
+
+	for _, size := range sizes {
+		b.Run(fmt.Sprintf("size_%d", size), func(b *testing.B) {
+			dir := b.TempDir()
+
+			store, _ := OpenSMST(dir)
+			vector := make([]byte, 24)
+			for i := 0; i < size; i++ {
+				store.Add(int32(i), vector)
+			}
+			store.Flush()
+			store.Close()
+
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				s, _ := OpenSMST(dir)
+				s.Close()
+			}
+		})
+	}
+}
+
+func TestSMSTProofSizes(t *testing.T) {
+	sizes := []int{1000, 10000, 100000}
+
+	for _, size := range sizes {
+		t.Run(fmt.Sprintf("size_%d", size), func(t *testing.T) {
+			dir := t.TempDir()
+			store, _ := OpenSMST(dir)
+			defer store.Close()
+
+			vector := make([]byte, 24)
+			for i := 0; i < size; i++ {
+				store.Add(int32(i), vector)
+			}
+
+			var totalProofBytes int
+			sampleCount := 100
+			if size < sampleCount {
+				sampleCount = size
+			}
+
+			for i := 0; i < sampleCount; i++ {
+				leafIdx := uint32(i * size / sampleCount)
+				_, _, proof, err := store.GetArtifactAndProof(leafIdx, uint32(size))
+				if err != nil {
+					t.Fatalf("GetArtifactAndProof failed: %v", err)
+				}
+				for _, h := range proof {
+					totalProofBytes += len(h)
+				}
+			}
+
+			avgProofBytes := totalProofBytes / sampleCount
+			t.Logf("Tree size: %d, Average proof size: %d bytes (%d elements of 36 bytes)", size, avgProofBytes, avgProofBytes/36)
+		})
+	}
+}
+
+func TestSMSTStoreNodeDistribution(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	store.AddWithNode(1, []byte{1}, "nodeA")
+	store.AddWithNode(2, []byte{2}, "nodeA")
+	store.AddWithNode(3, []byte{3}, "nodeB")
+	store.AddWithNode(4, []byte{4}, "")
+
+	counts := store.GetNodeCounts()
+	if counts["nodeA"] != 2 {
+		t.Errorf("expected nodeA count 2, got %d", counts["nodeA"])
+	}
+	if counts["nodeB"] != 1 {
+		t.Errorf("expected nodeB count 1, got %d", counts["nodeB"])
+	}
+
+	dist := store.GetNodeDistribution()
+	if len(dist) != 0 {
+		t.Errorf("expected empty distribution before flush")
+	}
+
+	store.Flush()
+
+	dist = store.GetNodeDistribution()
+	if dist["nodeA"] != 2 {
+		t.Errorf("expected flushed nodeA count 2, got %d", dist["nodeA"])
+	}
+	if dist["nodeB"] != 1 {
+		t.Errorf("expected flushed nodeB count 1, got %d", dist["nodeB"])
+	}
+}
+
+func TestSMSTStoreNodeDistributionRecovery(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, _ := OpenSMST(dir)
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeB")
+	store1.Flush()
+	store1.Close()
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST reopen failed: %v", err)
+	}
+	defer store2.Close()
+
+	dist := store2.GetNodeDistribution()
+	if dist["nodeA"] != 1 {
+		t.Errorf("expected recovered nodeA count 1, got %d", dist["nodeA"])
+	}
+	if dist["nodeB"] != 1 {
+		t.Errorf("expected recovered nodeB count 1, got %d", dist["nodeB"])
+	}
+
+	counts := store2.GetNodeCounts()
+	if counts["nodeA"] != 1 {
+		t.Errorf("expected recovered nodeA count 1 in current, got %d", counts["nodeA"])
+	}
+}
+
+func TestSMSTStoreGetRootAt(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	root, err := store.GetRootAt(0)
+	if err != nil {
+		t.Errorf("GetRootAt(0) should not error: %v", err)
+	}
+	if root != nil {
+		t.Errorf("GetRootAt(0) should return nil")
+	}
+
+	roots := make([][]byte, 6)
+	for i := int32(1); i <= 5; i++ {
+		store.Add(i, []byte{byte(i)})
+		store.Flush()
+		root, err := store.GetRootAt(uint32(i))
+		if err != nil {
+			t.Fatalf("GetRootAt(%d) failed: %v", i, err)
+		}
+		roots[i] = root
+	}
+
+	for i := uint32(1); i <= 5; i++ {
+		root, err := store.GetRootAt(i)
+		if err != nil {
+			t.Fatalf("GetRootAt(%d) failed: %v", i, err)
+		}
+		if !bytes.Equal(root, roots[i]) {
+			t.Errorf("GetRootAt(%d) returned different root", i)
+		}
+	}
+}
+
+func TestSMSTStoreRootsSurviveReopen(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+
+	boundaryRoots := make(map[uint32][]byte)
+	for i := int32(1); i <= 4; i++ {
+		store.Add(i, []byte{byte(i)})
+		store.Flush()
+		root, err := store.GetRootAt(uint32(i))
+		if err != nil {
+			t.Fatalf("GetRootAt(%d): %v", i, err)
+		}
+		boundaryRoots[uint32(i)] = root
+	}
+	if err := store.Close(); err != nil {
+		t.Fatalf("Close: %v", err)
+	}
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("reopen: %v", err)
+	}
+	defer store2.Close()
+
+	// Historical flush-boundary counts must remain servable after a restart
+	// (rebuilt on demand from the data file).
+	for count, want := range boundaryRoots {
+		got, err := store2.GetRootAt(count)
+		if err != nil {
+			t.Fatalf("GetRootAt(%d) after reopen: %v", count, err)
+		}
+		if !bytes.Equal(got, want) {
+			t.Errorf("GetRootAt(%d) root mismatch after reopen", count)
+		}
+	}
+}
+
+func TestSMSTStoreGetFlushedRoot(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	count, root := store.GetFlushedRoot()
+	if count != 0 {
+		t.Errorf("expected count 0, got %d", count)
+	}
+	if root != nil {
+		t.Errorf("expected nil root for empty store")
+	}
+
+	for i := int32(0); i < 5; i++ {
+		store.Add(i, []byte{byte(i)})
+	}
+
+	count, root = store.GetFlushedRoot()
+	if count != 0 {
+		t.Errorf("expected flushed count 0 before flush, got %d", count)
+	}
+
+	store.Flush()
+	count, root = store.GetFlushedRoot()
+	if count != 5 {
+		t.Errorf("expected flushed count 5 after flush, got %d", count)
+	}
+	if root == nil {
+		t.Error("expected non-nil root after flush")
+	}
+}
+
+func TestSMSTStoreAddAfterClose(t *testing.T) {
+	dir := t.TempDir()
+	store, _ := OpenSMST(dir)
+	store.Add(1, []byte{1})
+	store.Close()
+
+	err := store.Add(2, []byte{2})
+	if err != ErrStoreClosed {
+		t.Errorf("expected ErrStoreClosed, got %v", err)
+	}
+}
+
+func TestSMSTStoreNegativeNonce(t *testing.T) {
+	dir := t.TempDir()
+	store, _ := OpenSMST(dir)
+	defer store.Close()
+
+	store.Add(-1, []byte{1})
+	store.Add(-100, []byte{2})
+	store.Add(-2147483648, []byte{3}) // INT32_MIN
+
+	if store.Count() != 3 {
+		t.Errorf("expected 3, got %d", store.Count())
+	}
+
+	store.Flush()
+
+	// SMST orders by nonce interpreted as uint32
+	// -1 = 0xFFFFFFFF (largest), -100 = 0xFFFFFF9C, -2147483648 = 0x80000000
+	// Tree order (smallest first): 0x80000000, 0xFFFFFF9C, 0xFFFFFFFF
+	// So: -2147483648, -100, -1
+	expectedNonces := []int32{-2147483648, -100, -1}
+
+	count := store.Count()
+	for i, expected := range expectedNonces {
+		nonce, _, _, err := store.GetArtifactAndProof(uint32(i), count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d) failed: %v", i, err)
+		}
+		if nonce != expected {
+			t.Errorf("artifact %d: expected nonce %d, got %d", i, expected, nonce)
+		}
+	}
+}
+
+func TestSMSTStoreTruncatedRecordRecovery(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, _ := OpenSMST(dir)
+	store1.Add(10, []byte{1, 2, 3})
+	store1.Add(20, []byte{4, 5, 6})
+	store1.Flush()
+	root1 := store1.GetRoot()
+	store1.Close()
+
+	dataPath := dir + "/artifacts.data"
+	f, err := os.OpenFile(dataPath, os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		t.Fatalf("open data file: %v", err)
+	}
+	f.Write([]byte{0x10, 0x00, 0x00, 0x00})
+	f.Close()
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("Reopen with truncated record failed: %v", err)
+	}
+	defer store2.Close()
+
+	if store2.Count() != 2 {
+		t.Errorf("expected count 2 after truncation recovery, got %d", store2.Count())
+	}
+
+	root2 := store2.GetRoot()
+	if !bytes.Equal(root1, root2) {
+		t.Errorf("root mismatch after truncation recovery")
+	}
+}
+
+func TestSMSTStoreCapacityExceeded(t *testing.T) {
+	t.Skip("MaxLeafCount is too large to test in unit tests")
+}
+
+func TestSMSTStoreConcurrentGetArtifact(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	const artifactCount = 100
+	const goroutines = 50
+	const readsPerGoroutine = 20
+
+	// Insert artifacts with sequential nonces
+	for i := 0; i < artifactCount; i++ {
+		vector := []byte{byte(i), byte(i + 1), byte(i + 2), byte(i + 3)}
+		if err := store.Add(int32(i), vector); err != nil {
+			t.Fatalf("Add(%d) failed: %v", i, err)
+		}
+	}
+
+	if err := store.Flush(); err != nil {
+		t.Fatalf("Flush failed: %v", err)
+	}
+
+	// Build expected mapping: dense index -> (nonce, vector)
+	// SMST orders by nonce position in tree (sorted order for sequential nonces)
+	count := store.Count()
+	expectedData := make(map[uint32]struct {
+		nonce  int32
+		vector []byte
+	})
+	for i := uint32(0); i < artifactCount; i++ {
+		nonce, vector, _, _ := store.GetArtifactAndProof(i, count)
+		expectedData[i] = struct {
+			nonce  int32
+			vector []byte
+		}{nonce, vector}
+	}
+
+	var wg sync.WaitGroup
+	errChan := make(chan error, goroutines*readsPerGoroutine)
+
+	for g := 0; g < goroutines; g++ {
+		wg.Add(1)
+		go func(goroutineID int) {
+			defer wg.Done()
+			for r := 0; r < readsPerGoroutine; r++ {
+				leafIdx := uint32((goroutineID*readsPerGoroutine + r) % artifactCount)
+				nonce, vector, _, err := store.GetArtifactAndProof(leafIdx, count)
+				if err != nil {
+					errChan <- fmt.Errorf("goroutine %d: GetArtifactAndProof(%d) failed: %v", goroutineID, leafIdx, err)
+					return
+				}
+				expected := expectedData[leafIdx]
+				if nonce != expected.nonce {
+					errChan <- fmt.Errorf("goroutine %d: leafIdx %d: expected nonce %d, got %d", goroutineID, leafIdx, expected.nonce, nonce)
+					return
+				}
+				if !bytes.Equal(vector, expected.vector) {
+					errChan <- fmt.Errorf("goroutine %d: leafIdx %d: vector mismatch", goroutineID, leafIdx)
+					return
+				}
+			}
+		}(g)
+	}
+
+	wg.Wait()
+	close(errChan)
+
+	for err := range errChan {
+		t.Error(err)
+	}
+}
+
+// TestSMSTStoreConcurrentReadsHeavy tests many parallel goroutines doing heavy reads
+func TestSMSTStoreConcurrentReadsHeavy(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	const artifactCount = 1000
+	const goroutines = 100
+	const readsPerGoroutine = 100
+
+	// Insert artifacts
+	for i := 0; i < artifactCount; i++ {
+		vector := make([]byte, 24)
+		binary.LittleEndian.PutUint32(vector, uint32(i))
+		if err := store.Add(int32(i), vector); err != nil {
+			t.Fatalf("Add(%d) failed: %v", i, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	var wg sync.WaitGroup
+	errChan := make(chan error, goroutines)
+
+	// Launch many concurrent readers
+	for g := 0; g < goroutines; g++ {
+		wg.Add(1)
+		go func(goroutineID int) {
+			defer wg.Done()
+			for r := 0; r < readsPerGoroutine; r++ {
+				leafIdx := uint32((goroutineID + r*goroutines) % int(count))
+
+				nonce, vector, proof, err := store.GetArtifactAndProof(leafIdx, count)
+				if err != nil {
+					errChan <- fmt.Errorf("g%d: GetArtifactAndProof(%d) failed: %v", goroutineID, leafIdx, err)
+					return
+				}
+				if len(vector) != 24 {
+					errChan <- fmt.Errorf("g%d: unexpected vector length %d", goroutineID, len(vector))
+					return
+				}
+
+				leafData := encodeLeaf(nonce, vector)
+				elements := DecodeProofElements(proof)
+				if !VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements) {
+					errChan <- fmt.Errorf("g%d: proof verification failed for index %d", goroutineID, leafIdx)
+					return
+				}
+			}
+		}(g)
+	}
+
+	wg.Wait()
+	close(errChan)
+
+	errCount := 0
+	for err := range errChan {
+		t.Error(err)
+		errCount++
+	}
+
+	if errCount == 0 {
+		t.Logf("Success: %d goroutines x %d reads = %d concurrent operations", goroutines, readsPerGoroutine, goroutines*readsPerGoroutine)
+	}
+}
+
+// TestSMSTStoreConcurrentReadsWithProofs tests GetArtifact and GetProof together under load
+func TestSMSTStoreConcurrentReadsWithProofs(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	const artifactCount = 500
+	const goroutines = 50
+	const opsPerGoroutine = 50
+
+	// Insert with random-ish nonces
+	for i := 0; i < artifactCount; i++ {
+		nonce := int32(i*7 + 13) // non-sequential to stress tree navigation
+		vector := make([]byte, 24)
+		binary.LittleEndian.PutUint32(vector, uint32(nonce))
+		if err := store.Add(nonce, vector); err != nil {
+			t.Fatalf("Add failed: %v", err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	var wg sync.WaitGroup
+	var successCount, failCount int64
+
+	for g := 0; g < goroutines; g++ {
+		wg.Add(1)
+		go func(gid int) {
+			defer wg.Done()
+			localSuccess := int64(0)
+			localFail := int64(0)
+
+			for op := 0; op < opsPerGoroutine; op++ {
+				idx := uint32((gid*opsPerGoroutine + op) % int(count))
+
+				nonce, vector, proof, err := store.GetArtifactAndProof(idx, count)
+				if err != nil {
+					localFail++
+					continue
+				}
+
+				leafData := encodeLeaf(nonce, vector)
+				elements := DecodeProofElements(proof)
+				if VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements) {
+					localSuccess++
+				} else {
+					localFail++
+				}
+			}
+
+			atomic.AddInt64(&successCount, localSuccess)
+			atomic.AddInt64(&failCount, localFail)
+		}(g)
+	}
+
+	wg.Wait()
+
+	if failCount > 0 {
+		t.Errorf("Concurrent test had %d failures out of %d operations", failCount, goroutines*opsPerGoroutine)
+	} else {
+		t.Logf("All %d concurrent operations succeeded", successCount)
+	}
+}
+
+// TestSMSTStoreConcurrentReadsWhileWriting tests that reads don't block during writes
+// and data remains consistent when read/write operations interleave.
+func TestSMSTStoreConcurrentReadsWhileWriting(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	// Pre-populate some data
+	for i := 0; i < 100; i++ {
+		vector := make([]byte, 24)
+		binary.LittleEndian.PutUint32(vector, uint32(i))
+		if err := store.Add(int32(i), vector); err != nil {
+			t.Fatalf("Add(%d) failed: %v", i, err)
+		}
+	}
+	store.Flush()
+
+	var wg sync.WaitGroup
+	var readSuccess, readFail, writeSuccess int64
+
+	// Start readers that run continuously
+	readerDone := make(chan struct{})
+	for g := 0; g < 20; g++ {
+		wg.Add(1)
+		go func(gid int) {
+			defer wg.Done()
+			for {
+				select {
+				case <-readerDone:
+					return
+				default:
+					// Prove at the latest committed (flushed) count — the only
+					// count the protocol ever proves. A transient live count is
+					// not a committed root, so it is not a servable snapshot.
+					count, _ := store.GetFlushedRoot()
+					if count == 0 {
+						continue
+					}
+					idx := uint32(gid) % count
+					nonce, vector, _, err := store.GetArtifactAndProof(idx, count)
+					if err != nil {
+						atomic.AddInt64(&readFail, 1)
+						continue
+					}
+					if vector == nil || nonce == 0 && len(vector) == 0 {
+						atomic.AddInt64(&readFail, 1)
+						continue
+					}
+					atomic.AddInt64(&readSuccess, 1)
+				}
+			}
+		}(g)
+	}
+
+	// Writer adds more data while readers are active
+	for i := 100; i < 500; i++ {
+		vector := make([]byte, 24)
+		binary.LittleEndian.PutUint32(vector, uint32(i))
+		if err := store.Add(int32(i), vector); err != nil {
+			t.Fatalf("Add(%d) failed: %v", i, err)
+		}
+		if i%50 == 0 {
+			store.Flush()
+		}
+		atomic.AddInt64(&writeSuccess, 1)
+	}
+
+	// Stop readers
+	close(readerDone)
+	wg.Wait()
+
+	if readFail > 0 {
+		t.Errorf("Had %d read failures during concurrent read/write", readFail)
+	}
+	t.Logf("Concurrent read/write: %d successful reads, %d writes", readSuccess, writeSuccess)
+}
+
+// TestSMSTSumBasedOrdering verifies the core SMST property:
+// dense indices are deterministically ordered by nonce position in the sparse tree,
+// using the sum (count) at each node to navigate to the i-th leaf.
+func TestSMSTSumBasedOrdering(t *testing.T) {
+	tree := NewSMST(24)
+
+	// Insert nonces in random order - they should be retrievable by dense index
+	// in a deterministic order based on tree structure (left-to-right traversal)
+	nonces := []int32{1000, 50, 500, 5, 100, 10, 750}
+	for _, nonce := range nonces {
+		leafHash := smstHashLeaf(encodeLeaf(nonce, []byte{byte(nonce)}))
+		_, err := tree.Insert(nonce, leafHash)
+		if err != nil {
+			t.Fatalf("Insert(%d) failed: %v", nonce, err)
+		}
+	}
+
+	// Verify count equals number of inserted nonces
+	if tree.Count() != uint32(len(nonces)) {
+		t.Fatalf("expected count %d, got %d", len(nonces), tree.Count())
+	}
+
+	// Get all nonces by dense index - should be left-to-right tree order
+	retrievedNonces := make([]int32, tree.Count())
+	for i := uint32(0); i < tree.Count(); i++ {
+		nonce, _, err := tree.GetLeafByDenseIndex(i)
+		if err != nil {
+			t.Fatalf("GetLeafByDenseIndex(%d) failed: %v", i, err)
+		}
+		retrievedNonces[i] = nonce
+	}
+
+	// The order should be deterministic based on tree structure
+	// Smaller nonces go to the left (path has more 0 bits), larger to the right
+	// So nonces should be roughly sorted when retrieved by dense index
+	t.Logf("Retrieved nonces by dense index: %v", retrievedNonces)
+
+	// Verify all original nonces are present
+	seenNonces := make(map[int32]bool)
+	for _, n := range retrievedNonces {
+		seenNonces[n] = true
+	}
+	for _, n := range nonces {
+		if !seenNonces[n] {
+			t.Errorf("nonce %d not found in retrieved nonces", n)
+		}
+	}
+}
+
+// TestSMSTProofProvesCorrectNonceAtIndex verifies that:
+// 1. A proof generated for dense index i
+// 2. Contains the correct nonce (the one at that position)
+// 3. Verifies successfully against the root
+func TestSMSTProofProvesCorrectNonceAtIndex(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	// Insert artifacts with various nonces
+	artifacts := []struct {
+		nonce  int32
+		vector []byte
+	}{
+		{100, []byte{1, 2, 3}},
+		{5, []byte{4, 5, 6}},
+		{1000, []byte{7, 8, 9}},
+		{50, []byte{10, 11, 12}},
+		{500, []byte{13, 14, 15}},
+	}
+
+	for _, a := range artifacts {
+		if err := store.Add(a.nonce, a.vector); err != nil {
+			t.Fatalf("Add(%d) failed: %v", a.nonce, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	t.Logf("Store has %d artifacts, root: %x", count, rootHash[:8])
+
+	// For each dense index, verify:
+	for i := uint32(0); i < count; i++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(i, count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d) failed: %v", i, err)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+
+		// Decode and verify the proof
+		elements := DecodeProofElements(proof)
+		verified := VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements)
+		if !verified {
+			t.Errorf("Proof verification failed for dense index %d (nonce %d)", i, nonce)
+			t.Logf("  proof elements: %d, nonce: %d, leafData len: %d", len(elements), nonce, len(leafData))
+			t.Logf("  rootHash: %x", rootHash)
+			t.Logf("  count: %d", count)
+		} else {
+			t.Logf("Dense index %d: nonce=%d, proof verified OK", i, nonce)
+		}
+	}
+}
+
+// TestSMSTProofFailsForWrongNonce verifies that a proof for one nonce
+// does NOT verify if we claim it's for a different nonce
+func TestSMSTProofFailsForWrongNonce(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	store.Add(100, []byte{1, 2, 3})
+	store.Add(200, []byte{4, 5, 6})
+	store.Add(300, []byte{7, 8, 9})
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	// Get proof for index 0
+	nonce0, vector0, proof0, _ := store.GetArtifactAndProof(0, count)
+	elements0 := DecodeProofElements(proof0)
+
+	// Verify it works for the correct nonce
+	leafData0 := encodeLeaf(nonce0, vector0)
+	if !VerifySMSTProofWithCounts(rootHash, count, nonce0, leafData0, elements0) {
+		t.Fatal("Proof should verify for correct nonce")
+	}
+
+	// Try to verify with a WRONG nonce - should fail
+	wrongNonce := int32(999)
+	wrongLeafData := encodeLeaf(wrongNonce, vector0)
+	if VerifySMSTProofWithCounts(rootHash, count, wrongNonce, wrongLeafData, elements0) {
+		t.Error("Proof should NOT verify for wrong nonce - this breaks duplicate prevention!")
+	}
+}
+
+// TestSMSTDuplicateNoncePreventionEndToEnd tests the full duplicate prevention flow:
+// 1. Participant inserts artifacts with unique nonces
+// 2. Attempting to insert duplicate nonce fails
+// 3. Proofs can only verify artifacts that were actually inserted
+func TestSMSTDuplicateNoncePreventionEndToEnd(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	// Simulate: participant receives nonces 1, 2, 3 from inference
+	store.Add(1, []byte{0x11})
+	store.Add(2, []byte{0x22})
+	store.Add(3, []byte{0x33})
+
+	// Malicious attempt: try to add nonce 2 again (duplicate)
+	err = store.Add(2, []byte{0xFF})
+	if err != ErrDuplicateNonce {
+		t.Errorf("Expected ErrDuplicateNonce, got: %v", err)
+	}
+
+	// Count should still be 3
+	if store.Count() != 3 {
+		t.Errorf("Expected count 3, got %d", store.Count())
+	}
+
+	store.Flush()
+	rootHash := store.GetRoot()
+	count := store.Count()
+
+	// Verify all inserted nonces can be proven
+	for i := uint32(0); i < count; i++ {
+		nonce, vector, proof, _ := store.GetArtifactAndProof(i, count)
+		leafData := encodeLeaf(nonce, vector)
+		elements := DecodeProofElements(proof)
+
+		if !VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements) {
+			t.Errorf("Valid artifact at index %d (nonce %d) failed verification", i, nonce)
+		}
+	}
+
+	// Verify that a non-existent nonce cannot be proven
+	fakeNonce := int32(999)
+	fakeVector := []byte{0x99}
+	fakeLeafData := encodeLeaf(fakeNonce, fakeVector)
+
+	// Get proof for index 0 and try to use it for fake nonce
+	_, _, proof0, _ := store.GetArtifactAndProof(0, count)
+	elements0 := DecodeProofElements(proof0)
+
+	if VerifySMSTProofWithCounts(rootHash, count, fakeNonce, fakeLeafData, elements0) {
+		t.Error("Fake nonce should NOT verify with stolen proof")
+	}
+
+	t.Log("Duplicate prevention working correctly")
+}
+
+// Regression tests for risk hardening
+
+func TestSMSTDepthExpansionHashCorrectness(t *testing.T) {
+	// Verify that proofs remain valid and verifiable after depth expansion.
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	// Insert nonces that fit in default depth
+	nonces := []int32{1, 5, 10, 100}
+	for _, n := range nonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	countBefore := store.Count()
+	rootBefore := store.GetRoot()
+
+	// Verify proofs work before expansion
+	for i := uint32(0); i < countBefore; i++ {
+		nonce, vector, proof, _ := store.GetArtifactAndProof(i, countBefore)
+		leafData := encodeLeaf(nonce, vector)
+		if !VerifySMSTProofSlice(rootBefore, countBefore, nonce, leafData, proof) {
+			t.Errorf("proof verification failed BEFORE expansion for index %d", i)
+		}
+	}
+
+	// Force expansion with large nonce (> 2^24 to exceed default depth)
+	largeNonce := int32(1 << 25)
+	if err := store.Add(largeNonce, []byte{0xFF}); err != nil {
+		t.Fatalf("Add(%d): %v", largeNonce, err)
+	}
+	store.Flush()
+
+	countAfter := store.Count()
+	rootAfter := store.GetRoot()
+
+	if bytes.Equal(rootBefore, rootAfter) {
+		t.Errorf("root should change after expansion")
+	}
+
+	// Verify proofs work AFTER expansion for ALL artifacts including originals
+	for i := uint32(0); i < countAfter; i++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(i, countAfter)
+		if err != nil {
+			t.Errorf("GetArtifactAndProof(%d) after expansion: %v", i, err)
+			continue
+		}
+		leafData := encodeLeaf(nonce, vector)
+		if !VerifySMSTProofSlice(rootAfter, countAfter, nonce, leafData, proof) {
+			t.Errorf("proof verification FAILED after expansion for index %d (nonce=%d)", i, nonce)
+		}
+	}
+}
+
+func TestSMSTDepthExpansionIncremental(t *testing.T) {
+	// Start with depth 4 and expand incrementally to depth 24.
+	// After each expansion, verify ALL previous artifacts still have valid proofs.
+	// Tests the expansion algorithm by working directly with SMST at small initial depth.
+
+	initialDepth := 4
+	finalDepth := 24
+
+	tree := NewSMST(initialDepth)
+
+	// Track all inserted items
+	type item struct {
+		nonce  int32
+		vector []byte
+	}
+	var inserted []item
+
+	// Helper to build proof with counts directly from tree (like store does)
+	buildProofWithCounts := func(tree *SMST, nonce int32) []SMSTProofElement {
+		path := tree.noncePath(nonce)
+		elements := make([]SMSTProofElement, 0, tree.depth)
+
+		var collect func(node *smstNode, level int)
+		collect = func(node *smstNode, level int) {
+			if level == tree.depth || node == nil {
+				return
+			}
+			goRight := path[level]
+			if goRight {
+				elements = append(elements, SMSTProofElement{
+					SiblingHash:  tree.nodeHash(node.left, level+1),
+					SiblingCount: tree.nodeCount(node.left),
+				})
+				collect(node.right, level+1)
+			} else {
+				elements = append(elements, SMSTProofElement{
+					SiblingHash:  tree.nodeHash(node.right, level+1),
+					SiblingCount: tree.nodeCount(node.right),
+				})
+				collect(node.left, level+1)
+			}
+		}
+		collect(tree.root, 0)
+		return elements
+	}
+
+	// Helper to verify all proofs
+	verifyAll := func(stage string) bool {
+		rootHash, count := tree.GetRoot()
+		allPassed := true
+		for _, it := range inserted {
+			proofElements := buildProofWithCounts(tree, it.nonce)
+			leafData := encodeLeaf(it.nonce, it.vector)
+			if !VerifySMSTProofWithCounts(rootHash, count, it.nonce, leafData, proofElements) {
+				t.Errorf("[%s] Proof FAILED for nonce=%d", stage, it.nonce)
+				allPassed = false
+			}
+		}
+		return allPassed
+	}
+
+	// Insert initial nonces that fit in depth 4 (0-15)
+	initialNonces := []int32{0, 1, 5, 10, 15}
+	for _, n := range initialNonces {
+		vec := []byte{byte(n)}
+		leafHash := smstHashLeaf(encodeLeaf(n, vec))
+		if _, err := tree.Insert(n, leafHash); err != nil {
+			t.Fatalf("Initial Insert(%d): %v", n, err)
+		}
+		inserted = append(inserted, item{n, vec})
+	}
+
+	if tree.Depth() != initialDepth {
+		t.Errorf("Expected initial depth %d, got %d", initialDepth, tree.Depth())
+	}
+
+	t.Logf("Initial: depth=%d, count=%d", tree.Depth(), tree.Count())
+	if !verifyAll("initial") {
+		t.Fatal("Initial verification failed")
+	}
+
+	// Expand incrementally from depth 5 to finalDepth
+	for targetDepth := initialDepth + 1; targetDepth <= finalDepth; targetDepth++ {
+		// Nonce requiring depth D has highest bit at position D-1
+		// 2^(D-1) requires exactly depth D
+		triggerNonce := int32(1<<(targetDepth-1)) + int32(targetDepth)
+
+		vec := []byte{byte(triggerNonce), byte(triggerNonce >> 8), byte(triggerNonce >> 16)}
+		leafHash := smstHashLeaf(encodeLeaf(triggerNonce, vec))
+
+		depthBefore := tree.Depth()
+		if _, err := tree.Insert(triggerNonce, leafHash); err != nil {
+			t.Fatalf("Insert(nonce=%d) for depth %d: %v", triggerNonce, targetDepth, err)
+		}
+		inserted = append(inserted, item{triggerNonce, vec})
+
+		if tree.Depth() < targetDepth {
+			t.Errorf("Expected depth >= %d, got %d", targetDepth, tree.Depth())
+		}
+
+		expanded := depthBefore != tree.Depth()
+		if expanded {
+			t.Logf("Expanded: %d -> %d (nonce=%d, count=%d)",
+				depthBefore, tree.Depth(), triggerNonce, tree.Count())
+		}
+
+		// Verify ALL proofs still work
+		stage := fmt.Sprintf("depth=%d", tree.Depth())
+		if !verifyAll(stage) {
+			t.Fatalf("Verification failed after expanding to depth %d", tree.Depth())
+		}
+	}
+
+	t.Logf("SUCCESS: depth %d->%d, %d items, all proofs verified at each step",
+		initialDepth, tree.Depth(), len(inserted))
+}
+
+func TestSMSTMalformedProofRejection(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	nonces := []int32{10, 20, 30, 40, 50}
+	for _, n := range nonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	count, rootHash := store.GetFlushedRoot()
+	nonce, vector, _, _ := store.GetArtifactAndProof(2, count)
+	leafData := encodeLeaf(nonce, vector)
+
+	// Test 1: Empty proof should fail
+	if VerifySMSTProofSlice(rootHash, count, nonce, leafData, nil) {
+		t.Error("empty proof should fail verification")
+	}
+	if VerifySMSTProofSlice(rootHash, count, nonce, leafData, [][]byte{}) {
+		t.Error("empty slice proof should fail verification")
+	}
+
+	// Test 2: Malformed proof element (wrong size) should fail
+	if VerifySMSTProofSlice(rootHash, count, nonce, leafData, [][]byte{make([]byte, 35)}) {
+		t.Error("malformed proof (35 bytes) should fail verification")
+	}
+	if VerifySMSTProofSlice(rootHash, count, nonce, leafData, [][]byte{make([]byte, 37)}) {
+		t.Error("malformed proof (37 bytes) should fail verification")
+	}
+
+	// Test 3: Proof with correct size but wrong content should fail
+	wrongContent := make([][]byte, 24) // default depth
+	for i := range wrongContent {
+		wrongContent[i] = make([]byte, 36)
+		copy(wrongContent[i], []byte("wrong hash content here!!!!!!!!!"))
+	}
+	if VerifySMSTProofSlice(rootHash, count, nonce, leafData, wrongContent) {
+		t.Error("proof with wrong content should fail verification")
+	}
+}
+
+func TestSMSTIndexBindingVerification(t *testing.T) {
+	dir, _ := os.MkdirTemp("", "smst-index-binding-*")
+	defer os.RemoveAll(dir)
+
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	// Insert artifacts with specific nonces
+	nonces := []int32{100, 200, 300, 400, 500}
+	for _, n := range nonces {
+		if err := store.AddWithNode(n, []byte{byte(n)}, "node1"); err != nil {
+			t.Fatalf("AddWithNode(%d) failed: %v", n, err)
+		}
+	}
+
+	if err := store.Flush(); err != nil {
+		t.Fatalf("Flush failed: %v", err)
+	}
+
+	count, rootHash := store.GetFlushedRoot()
+
+	// Test each artifact at its correct dense index
+	for expectedIndex := uint32(0); expectedIndex < count; expectedIndex++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(expectedIndex, count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d) failed: %v", expectedIndex, err)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+
+		// Correct index should verify
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, expectedIndex, nonce, leafData, proof) {
+			t.Errorf("Valid proof at index %d should verify", expectedIndex)
+		}
+
+		// Wrong index should NOT verify
+		wrongIndex := (expectedIndex + 1) % count
+		if VerifySMSTProofWithDenseIndex(rootHash, count, wrongIndex, nonce, leafData, proof) {
+			t.Errorf("Proof at index %d should NOT verify when claimed at index %d", expectedIndex, wrongIndex)
+		}
+	}
+
+	// Test: taking proof from index 0 and claiming it's for index 2 should fail
+	nonce0, vector0, proof0, _ := store.GetArtifactAndProof(0, count)
+	leafData0 := encodeLeaf(nonce0, vector0)
+
+	if VerifySMSTProofWithDenseIndex(rootHash, count, 2, nonce0, leafData0, proof0) {
+		t.Error("Proof for index 0 should NOT verify when claimed at index 2")
+	}
+}
+
+func TestSMSTRebuildFailsOnCorruption(t *testing.T) {
+	dir, _ := os.MkdirTemp("", "smst-corruption-*")
+	defer os.RemoveAll(dir)
+
+	// Create store and add artifacts
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+
+	for i := int32(0); i < 10; i++ {
+		if err := store.AddWithNode(i, []byte{byte(i)}, "node1"); err != nil {
+			t.Fatalf("AddWithNode(%d) failed: %v", i, err)
+		}
+	}
+
+	if err := store.Flush(); err != nil {
+		t.Fatalf("Flush failed: %v", err)
+	}
+
+	store.Close()
+
+	// Corrupt the data file by truncating it
+	dataPath := dir + "/artifacts.data"
+	info, _ := os.Stat(dataPath)
+	originalSize := info.Size()
+
+	// Truncate to half
+	if err := os.Truncate(dataPath, originalSize/2); err != nil {
+		t.Fatalf("Truncate failed: %v", err)
+	}
+
+	// Reopen store (recovery should handle truncation gracefully)
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		// Recovery failed entirely - this is acceptable behavior for severe corruption
+		t.Logf("Recovery failed (acceptable): %v", err)
+		return
+	}
+	defer store2.Close()
+
+	// Store opened, but GetRootAt for the original count should fail
+	// because not all artifacts are readable
+	_, err = store2.GetRootAt(10)
+	if err == nil {
+		t.Error("GetRootAt should fail when data file is corrupted")
+	} else {
+		t.Logf("GetRootAt correctly failed: %v", err)
+	}
+}
+
+// Security hardening tests - verify SMST properties that prevent duplicate attacks
+
+// TestSMSTCountInflationAttackFails verifies that an attacker cannot claim
+// a higher count than actual leaves. The count is cryptographically committed
+// in the root hash via sibling counts at each level.
+func TestSMSTCountInflationAttackFails(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	// Create tree with 5 real leaves
+	realNonces := []int32{10, 20, 30, 40, 50}
+	for _, n := range realNonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	actualCount := store.Count() // = 5
+	rootHash := store.GetRoot()
+
+	// Get valid proof for denseIndex=0
+	nonce, vector, proof, err := store.GetArtifactAndProof(0, actualCount)
+	if err != nil {
+		t.Fatalf("GetArtifactAndProof(0): %v", err)
+	}
+	leafData := encodeLeaf(nonce, vector)
+
+	// Verify with CORRECT count - should pass
+	if !VerifySMSTProofSlice(rootHash, actualCount, nonce, leafData, proof) {
+		t.Fatal("Proof should verify with correct count")
+	}
+
+	// ATTACK: Claim inflated count (10 instead of 5)
+	// This simulates an attacker who claims count=10 on-chain but only has 5 leaves.
+	// The proof's sibling counts sum to 5 (committed by rootHash), so verification
+	// will compute currentCount=5, which != 10, causing failure.
+	inflatedCount := uint32(10)
+	if VerifySMSTProofSlice(rootHash, inflatedCount, nonce, leafData, proof) {
+		t.Error("SECURITY FAILURE: Proof verified with inflated count! Count inflation attack possible.")
+	}
+
+	// Also verify with dense index check
+	if VerifySMSTProofWithDenseIndex(rootHash, inflatedCount, 0, nonce, leafData, proof) {
+		t.Error("SECURITY FAILURE: VerifySMSTProofWithDenseIndex passed with inflated count!")
+	}
+
+	t.Log("Count inflation attack correctly prevented")
+}
+
+// TestSMSTProofWithWrongCountFails verifies that proofs fail when count
+// doesn't match the committed tree state.
+func TestSMSTProofWithWrongCountFails(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for i := int32(0); i < 100; i++ {
+		if err := store.Add(i, []byte{byte(i)}); err != nil {
+			t.Fatalf("Add(%d): %v", i, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	// Get proof for middle index
+	idx := uint32(50)
+	nonce, vector, proof, _ := store.GetArtifactAndProof(idx, count)
+	leafData := encodeLeaf(nonce, vector)
+	elements := DecodeProofElements(proof)
+
+	// Correct count passes
+	if !VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements) {
+		t.Fatal("Proof should verify with correct count")
+	}
+
+	// count-1 fails (sibling counts sum to 100, not 99)
+	if VerifySMSTProofWithCounts(rootHash, count-1, nonce, leafData, elements) {
+		t.Error("Proof should NOT verify with count-1")
+	}
+
+	// count+1 fails (sibling counts sum to 100, not 101)
+	if VerifySMSTProofWithCounts(rootHash, count+1, nonce, leafData, elements) {
+		t.Error("Proof should NOT verify with count+1")
+	}
+
+	// Very different count fails
+	if VerifySMSTProofWithCounts(rootHash, 1000, nonce, leafData, elements) {
+		t.Error("Proof should NOT verify with count=1000")
+	}
+
+	t.Logf("Wrong count correctly rejected for all test cases")
+}
+
+// TestSMSTNonceHasUniqueDenseIndex verifies the core SMST security property:
+// each nonce maps to exactly ONE dense index. This is what prevents duplicates -
+// you cannot serve the same nonce for different dense indices.
+func TestSMSTNonceHasUniqueDenseIndex(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	// Insert nonces with gaps to create a sparse tree
+	nonces := []int32{5, 50, 500, 5000, 50000}
+	for _, n := range nonces {
+		if err := store.Add(n, []byte{byte(n % 256)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	// For each nonce, verify it can ONLY be proven at its unique dense index
+	for expectedIdx := uint32(0); expectedIdx < count; expectedIdx++ {
+		nonce, vector, proof, _ := store.GetArtifactAndProof(expectedIdx, count)
+		leafData := encodeLeaf(nonce, vector)
+
+		// Correct index passes
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, expectedIdx, nonce, leafData, proof) {
+			t.Errorf("Nonce %d should verify at its correct index %d", nonce, expectedIdx)
+		}
+
+		// ALL other indices must fail for this nonce
+		for wrongIdx := uint32(0); wrongIdx < count; wrongIdx++ {
+			if wrongIdx == expectedIdx {
+				continue
+			}
+			if VerifySMSTProofWithDenseIndex(rootHash, count, wrongIdx, nonce, leafData, proof) {
+				t.Errorf("SECURITY FAILURE: Nonce %d verified at wrong index %d (should only be %d)",
+					nonce, wrongIdx, expectedIdx)
+			}
+		}
+	}
+
+	t.Log("Each nonce correctly maps to exactly one dense index")
+}
+
+// TestSMSTNegativeNonces verifies that negative nonces (which become large uint32
+// values internally) are handled correctly.
+func TestSMSTNegativeNonces(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	// Test negative nonces - these become large uint32 values internally
+	// int32(-1) -> uint32(4294967295), requires depth 32
+	negativeNonces := []int32{-1, -100, -1000000}
+	positiveNonces := []int32{0, 1, 100}
+
+	allNonces := append(positiveNonces, negativeNonces...)
+	for _, n := range allNonces {
+		if err := store.Add(n, []byte{byte(n & 0xFF)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	// Verify depth expanded to handle large nonces
+	if store.smst.Depth() < 32 {
+		t.Logf("Tree depth: %d (may not have expanded to 32 for small negative values)", store.smst.Depth())
+	}
+
+	// All nonces should be provable
+	for i := uint32(0); i < count; i++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(i, count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d): %v", i, err)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, i, nonce, leafData, proof) {
+			t.Errorf("Proof failed for nonce %d at index %d", nonce, i)
+		}
+	}
+
+	// Note: int32(-1) when interpreted as uint32 becomes 4294967295,
+	// which determines its tree path. This is handled correctly by the
+	// depth expansion logic.
+
+	t.Logf("Negative nonces handled correctly, tree depth: %d", store.smst.Depth())
+}
+
+// TestSMSTCountBoundaries verifies edge cases for count values.
+func TestSMSTCountBoundaries(t *testing.T) {
+	t.Run("count=0", func(t *testing.T) {
+		// Empty proof with count=0 should fail
+		if VerifySMSTProofSlice(make([]byte, 32), 0, 0, []byte{}, nil) {
+			t.Error("Empty proof with count=0 should fail")
+		}
+		if VerifySMSTProofSlice(make([]byte, 32), 0, 0, []byte{}, [][]byte{}) {
+			t.Error("Empty proof slice with count=0 should fail")
+		}
+	})
+
+	t.Run("denseIndex >= count", func(t *testing.T) {
+		dir := t.TempDir()
+		store, _ := OpenSMST(dir)
+		defer store.Close()
+
+		store.Add(1, []byte{1})
+		store.Add(2, []byte{2})
+		store.Flush()
+
+		count := store.Count() // = 2
+		rootHash := store.GetRoot()
+		nonce, vector, proof, _ := store.GetArtifactAndProof(0, count)
+		leafData := encodeLeaf(nonce, vector)
+
+		// denseIndex = count should fail (valid range is [0, count))
+		if VerifySMSTProofWithDenseIndex(rootHash, count, count, nonce, leafData, proof) {
+			t.Error("denseIndex == count should fail")
+		}
+
+		// denseIndex > count should fail
+		if VerifySMSTProofWithDenseIndex(rootHash, count, count+100, nonce, leafData, proof) {
+			t.Error("denseIndex > count should fail")
+		}
+	})
+
+	t.Run("single leaf tree", func(t *testing.T) {
+		dir := t.TempDir()
+		store, _ := OpenSMST(dir)
+		defer store.Close()
+
+		store.Add(42, []byte{42})
+		store.Flush()
+
+		count := store.Count() // = 1
+		rootHash := store.GetRoot()
+		nonce, vector, proof, _ := store.GetArtifactAndProof(0, count)
+		leafData := encodeLeaf(nonce, vector)
+
+		// Single leaf at index 0 should verify
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, 0, nonce, leafData, proof) {
+			t.Error("Single leaf tree proof should verify")
+		}
+
+		// Index 1 should fail (out of range)
+		if VerifySMSTProofWithDenseIndex(rootHash, count, 1, nonce, leafData, proof) {
+			t.Error("Index 1 in single-leaf tree should fail")
+		}
+	})
+}
+
+// TestSMSTSnapshotConsistency verifies that GetArtifactAndProof returns
+// consistent data from the same snapshot tree state. This is critical for
+// preventing the bug where GetArtifact uses current tree but GetProof uses snapshot.
+func TestSMSTSnapshotConsistency(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	// Insert initial artifacts
+	initialNonces := []int32{10, 20, 30, 40, 50}
+	for _, n := range initialNonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	snapshotCount := store.Count()
+	snapshotRoot, err := store.GetRootAt(snapshotCount)
+	if err != nil {
+		t.Fatalf("GetRootAt: %v", err)
+	}
+
+	// Add more artifacts to advance current state beyond snapshot
+	additionalNonces := []int32{5, 15, 25, 35, 45, 55} // Note: 5 < 10, so it changes dense index order!
+	for _, n := range additionalNonces {
+		if err := store.Add(n, []byte{byte(n)}); err != nil {
+			t.Fatalf("Add(%d): %v", n, err)
+		}
+	}
+	store.Flush()
+
+	// Current count is now different from snapshot
+	currentCount := store.Count()
+	if currentCount == snapshotCount {
+		t.Fatal("Test setup error: current count should differ from snapshot")
+	}
+
+	// For each dense index in the snapshot, verify GetArtifactAndProof returns
+	// data that verifies correctly against the snapshot root
+	for i := uint32(0); i < snapshotCount; i++ {
+		nonce, vector, proof, err := store.GetArtifactAndProof(i, snapshotCount)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d, %d): %v", i, snapshotCount, err)
+		}
+
+		leafData := encodeLeaf(nonce, vector)
+
+		// This MUST verify successfully - if it doesn't, we have snapshot inconsistency
+		if !VerifySMSTProofWithDenseIndex(snapshotRoot, snapshotCount, i, nonce, leafData, proof) {
+			t.Errorf("Snapshot consistency FAILED for index %d: proof does not verify", i)
+			t.Logf("  nonce=%d, snapshotCount=%d, currentCount=%d", nonce, snapshotCount, currentCount)
+		}
+	}
+
+	t.Logf("Snapshot consistency verified: snapshotCount=%d, currentCount=%d", snapshotCount, currentCount)
+}
+
+func TestSMSTGetArtifactAndProofByNonce(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for _, nonce := range []int32{100, 5, 50, 1000} {
+		if err := store.Add(nonce, []byte{byte(nonce)}); err != nil {
+			t.Fatalf("Add(%d): %v", nonce, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+	for expectedIndex := uint32(0); expectedIndex < count; expectedIndex++ {
+		nonce, vector, _, err := store.GetArtifactAndProof(expectedIndex, count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof(%d): %v", expectedIndex, err)
+		}
+
+		denseIndex, byNonceVector, proof, err := store.GetArtifactAndProofByNonce(nonce, count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProofByNonce(%d): %v", nonce, err)
+		}
+		if denseIndex != expectedIndex {
+			t.Fatalf("nonce %d: expected dense index %d, got %d", nonce, expectedIndex, denseIndex)
+		}
+		if !bytes.Equal(byNonceVector, vector) {
+			t.Fatalf("nonce %d: vector mismatch", nonce)
+		}
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, denseIndex, nonce, encodeLeaf(nonce, byNonceVector), proof) {
+			t.Fatalf("nonce %d: proof failed verification at dense index %d", nonce, denseIndex)
+		}
+	}
+}
+
+func TestSMSTGetArtifactAndProofByNonceSnapshotSemantics(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for _, nonce := range []int32{10, 50, 90} {
+		if err := store.Add(nonce, []byte{byte(nonce)}); err != nil {
+			t.Fatalf("Add(%d): %v", nonce, err)
+		}
+	}
+	store.Flush()
+
+	snapshotCount := store.Count()
+	snapshotRoot := store.GetRoot()
+
+	lateNonce := int32(20)
+	if err := store.Add(lateNonce, []byte{byte(lateNonce)}); err != nil {
+		t.Fatalf("Add late nonce: %v", err)
+	}
+	store.Flush()
+
+	if _, _, _, err := store.GetArtifactAndProofByNonce(lateNonce, snapshotCount); !errors.Is(err, ErrNonceNotFound) {
+		t.Fatalf("expected ErrNonceNotFound for late nonce at snapshot, got %v", err)
+	}
+
+	denseIndex, vector, proof, err := store.GetArtifactAndProofByNonce(50, snapshotCount)
+	if err != nil {
+		t.Fatalf("GetArtifactAndProofByNonce existing nonce: %v", err)
+	}
+	if denseIndex != 1 {
+		t.Fatalf("expected nonce 50 at snapshot dense index 1, got %d", denseIndex)
+	}
+	if !VerifySMSTProofWithDenseIndex(snapshotRoot, snapshotCount, denseIndex, 50, encodeLeaf(50, vector), proof) {
+		t.Fatal("snapshot proof failed verification")
+	}
+}
+
+func TestSMSTGetArtifactAndProofByNonceErrorCases(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	if _, _, _, err := store.GetArtifactAndProofByNonce(1, 0); !errors.Is(err, ErrNonceNotFound) {
+		t.Fatalf("expected ErrNonceNotFound for empty snapshot, got %v", err)
+	}
+	if err := store.Add(1, []byte{1}); err != nil {
+		t.Fatalf("Add: %v", err)
+	}
+	store.Flush()
+
+	count := store.Count()
+	if _, _, _, err := store.GetArtifactAndProofByNonce(2, count); !errors.Is(err, ErrNonceNotFound) {
+		t.Fatalf("expected ErrNonceNotFound for absent nonce, got %v", err)
+	}
+	if _, _, _, err := store.GetArtifactAndProofByNonce(1, count+1); err == nil {
+		t.Fatal("expected error for future snapshot")
+	}
+}
+
+func TestSMSTBatchProofsMatchSingleCalls(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for _, nonce := range []int32{100, 5, 50, 1000, 7} {
+		if err := store.Add(nonce, []byte{byte(nonce)}); err != nil {
+			t.Fatalf("Add(%d): %v", nonce, err)
+		}
+	}
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+
+	indices := []uint32{0, 2, 4}
+	entries, err := store.GetArtifactsAndProofs(indices, count)
+	if err != nil {
+		t.Fatalf("GetArtifactsAndProofs: %v", err)
+	}
+	if len(entries) != len(indices) {
+		t.Fatalf("entries = %d, want %d", len(entries), len(indices))
+	}
+	for i, entry := range entries {
+		nonce, vector, proof, err := store.GetArtifactAndProof(indices[i], count)
+		if err != nil {
+			t.Fatalf("GetArtifactAndProof: %v", err)
+		}
+		if entry.DenseIndex != indices[i] || entry.Nonce != nonce || !bytes.Equal(entry.Vector, vector) || len(entry.Proof) != len(proof) {
+			t.Fatalf("batch entry %d does not match single call", i)
+		}
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, entry.DenseIndex, entry.Nonce, encodeLeaf(entry.Nonce, entry.Vector), entry.Proof) {
+			t.Fatalf("batch proof %d failed verification", i)
+		}
+	}
+
+	nonceEntries, err := store.GetArtifactsAndProofsByNonce([]int32{5, 1000, 9999}, count)
+	if err != nil {
+		t.Fatalf("GetArtifactsAndProofsByNonce: %v", err)
+	}
+	if len(nonceEntries) != 2 {
+		t.Fatalf("nonce entries = %d, want 2", len(nonceEntries))
+	}
+	for _, entry := range nonceEntries {
+		if !VerifySMSTProofWithDenseIndex(rootHash, count, entry.DenseIndex, entry.Nonce, encodeLeaf(entry.Nonce, entry.Vector), entry.Proof) {
+			t.Fatalf("by-nonce proof for nonce %d failed verification", entry.Nonce)
+		}
+	}
+}
+
+// TestSMSTVerifierOverflowProtection tests that the verifier is protected against
+// integer overflow in the computedIndex accumulation.
+func TestSMSTVerifierOverflowProtection(t *testing.T) {
+	// Create a minimal valid proof structure for testing edge cases
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	store.Add(1, []byte{1})
+	store.Add(2, []byte{2})
+	store.Flush()
+
+	count := store.Count()
+	rootHash := store.GetRoot()
+	nonce, vector, proof, _ := store.GetArtifactAndProof(0, count)
+	leafData := encodeLeaf(nonce, vector)
+
+	// Valid proof should work
+	if !VerifySMSTProofWithDenseIndex(rootHash, count, 0, nonce, leafData, proof) {
+		t.Fatal("Valid proof should verify")
+	}
+
+	// Test with count=0 (should fail early)
+	if VerifySMSTProofWithDenseIndex(rootHash, 0, 0, nonce, leafData, proof) {
+		t.Error("count=0 should fail verification")
+	}
+
+	// Test with empty proof (should fail early)
+	if VerifySMSTProofWithDenseIndex(rootHash, count, 0, nonce, leafData, [][]byte{}) {
+		t.Error("Empty proof should fail verification")
+	}
+
+	// Test with nil proof (should fail early)
+	if VerifySMSTProofWithDenseIndex(rootHash, count, 0, nonce, leafData, nil) {
+		t.Error("Nil proof should fail verification")
+	}
+}
+
+// TestSMSTGetArtifactAndProofErrorCases tests error handling in GetArtifactAndProof
+func TestSMSTGetArtifactAndProofErrorCases(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for i := int32(0); i < 5; i++ {
+		store.Add(i*10, []byte{byte(i)})
+	}
+	store.Flush()
+
+	count := store.Count()
+
+	// Test: denseIndex >= snapshotCount should fail
+	_, _, _, err = store.GetArtifactAndProof(count, count)
+	if err != ErrLeafIndexOutOfRange {
+		t.Errorf("Expected ErrLeafIndexOutOfRange for index=count, got %v", err)
+	}
+
+	_, _, _, err = store.GetArtifactAndProof(count+100, count)
+	if err != ErrLeafIndexOutOfRange {
+		t.Errorf("Expected ErrLeafIndexOutOfRange for index>count, got %v", err)
+	}
+
+	// Test: snapshotCount > current count should fail
+	_, _, _, err = store.GetArtifactAndProof(0, count+10)
+	if err == nil {
+		t.Error("Expected error for snapshotCount > current count")
+	}
+
+	// Test: valid request should succeed
+	nonce, vector, proof, err := store.GetArtifactAndProof(0, count)
+	if err != nil {
+		t.Fatalf("Valid request failed: %v", err)
+	}
+	if nonce == 0 && vector == nil && proof == nil {
+		t.Error("Valid request returned empty data")
+	}
+}
+
+func TestDistributionHistory_NormalOperation(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	store.AddWithNode(1, []byte{1}, "nodeA")
+	store.AddWithNode(2, []byte{2}, "nodeB")
+	store.AddWithNode(3, []byte{3}, "nodeA")
+	store.Flush()
+
+	dist1, exact1, err := store.GetNodeDistributionAt(3)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(3) failed: %v", err)
+	}
+	if !exact1 {
+		t.Error("expected exact=true for count=3")
+	}
+	if dist1["nodeA"] != 2 || dist1["nodeB"] != 1 {
+		t.Errorf("unexpected distribution at count=3: %v", dist1)
+	}
+
+	store.AddWithNode(4, []byte{4}, "nodeB")
+	store.AddWithNode(5, []byte{5}, "nodeB")
+	store.Flush()
+
+	dist2, exact2, err := store.GetNodeDistributionAt(5)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(5) failed: %v", err)
+	}
+	if !exact2 {
+		t.Error("expected exact=true for count=5")
+	}
+	if dist2["nodeA"] != 2 || dist2["nodeB"] != 3 {
+		t.Errorf("unexpected distribution at count=5: %v", dist2)
+	}
+
+	distOld, exactOld, err := store.GetNodeDistributionAt(3)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(3) after second flush failed: %v", err)
+	}
+	if !exactOld {
+		t.Error("expected exact=true for historical count=3")
+	}
+	if distOld["nodeA"] != 2 || distOld["nodeB"] != 1 {
+		t.Errorf("historical distribution at count=3 changed: %v", distOld)
+	}
+}
+
+func TestDistributionHistory_Recovery(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeB")
+	store1.Flush()
+
+	store1.AddWithNode(3, []byte{3}, "nodeA")
+	store1.AddWithNode(4, []byte{4}, "nodeA")
+	store1.Flush()
+
+	store1.Close()
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST (reopen) failed: %v", err)
+	}
+	defer store2.Close()
+
+	dist2, exact2, err := store2.GetNodeDistributionAt(2)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(2) failed: %v", err)
+	}
+	if !exact2 {
+		t.Error("expected exact=true for count=2 after recovery")
+	}
+	if dist2["nodeA"] != 1 || dist2["nodeB"] != 1 {
+		t.Errorf("distribution at count=2 after recovery: %v", dist2)
+	}
+
+	dist4, exact4, err := store2.GetNodeDistributionAt(4)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(4) failed: %v", err)
+	}
+	if !exact4 {
+		t.Error("expected exact=true for count=4 after recovery")
+	}
+	if dist4["nodeA"] != 3 || dist4["nodeB"] != 1 {
+		t.Errorf("distribution at count=4 after recovery: %v", dist4)
+	}
+}
+
+func TestDistributionHistory_CorruptedFile(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeB")
+	store1.Flush()
+	store1.Close()
+
+	distPath := filepath.Join(dir, "distributions.jsonl")
+	f, err := os.OpenFile(distPath, os.O_APPEND|os.O_WRONLY, 0644)
+	if err != nil {
+		t.Fatalf("open distributions.jsonl failed: %v", err)
+	}
+	f.WriteString("{invalid json line\n")
+	f.WriteString(`{"count":10,"dist":{"nodeC":5,"nodeD":5}}` + "\n")
+	f.Close()
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST (reopen) failed: %v", err)
+	}
+	defer store2.Close()
+
+	dist2, exact2, err := store2.GetNodeDistributionAt(2)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(2) failed: %v", err)
+	}
+	if !exact2 {
+		t.Error("expected exact=true for valid count=2")
+	}
+	if dist2["nodeA"] != 1 || dist2["nodeB"] != 1 {
+		t.Errorf("distribution at count=2: %v", dist2)
+	}
+
+	dist10, exact10, err := store2.GetNodeDistributionAt(10)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(10) failed: %v", err)
+	}
+	if !exact10 {
+		t.Error("expected exact=true for count=10 (valid line after corrupt)")
+	}
+	if dist10["nodeC"] != 5 || dist10["nodeD"] != 5 {
+		t.Errorf("distribution at count=10: %v", dist10)
+	}
+}
+
+func TestDistributionHistory_EmptyFile(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeB")
+	store1.Flush()
+	store1.Close()
+
+	distPath := filepath.Join(dir, "distributions.jsonl")
+	if err := os.Truncate(distPath, 0); err != nil {
+		t.Fatalf("truncate distributions.jsonl failed: %v", err)
+	}
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST (reopen) failed: %v", err)
+	}
+	defer store2.Close()
+
+	dist, exact, err := store2.GetNodeDistributionAt(2)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(2) failed: %v", err)
+	}
+	if exact {
+		t.Error("expected exact=false when history is empty")
+	}
+	if len(dist) != 0 {
+		t.Errorf("expected empty distribution when history lost, got %v", dist)
+	}
+}
+
+func TestDistributionHistory_MissingFile(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeA")
+	store1.AddWithNode(3, []byte{3}, "nodeB")
+	store1.Flush()
+	store1.Close()
+
+	distPath := filepath.Join(dir, "distributions.jsonl")
+	if err := os.Remove(distPath); err != nil {
+		t.Fatalf("remove distributions.jsonl failed: %v", err)
+	}
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST (reopen) failed: %v", err)
+	}
+	defer store2.Close()
+
+	dist, exact, err := store2.GetNodeDistributionAt(3)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(3) failed: %v", err)
+	}
+	if exact {
+		t.Error("expected exact=false when file was missing")
+	}
+	if len(dist) != 0 {
+		t.Errorf("expected empty distribution when history lost, got %v", dist)
+	}
+}
+
+func TestDistributionHistory_TruncatedLine(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeB")
+	store1.Flush()
+	store1.Close()
+
+	distPath := filepath.Join(dir, "distributions.jsonl")
+	f, err := os.OpenFile(distPath, os.O_APPEND|os.O_WRONLY, 0644)
+	if err != nil {
+		t.Fatalf("open distributions.jsonl failed: %v", err)
+	}
+	f.WriteString(`{"count":5,"dist":{"nodeA":3,`)
+	f.Close()
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST (reopen) failed: %v", err)
+	}
+	defer store2.Close()
+
+	dist2, exact2, err := store2.GetNodeDistributionAt(2)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(2) failed: %v", err)
+	}
+	if !exact2 {
+		t.Error("expected exact=true for valid count=2")
+	}
+	if dist2["nodeA"] != 1 || dist2["nodeB"] != 1 {
+		t.Errorf("distribution at count=2: %v", dist2)
+	}
+
+	_, exact5, err := store2.GetNodeDistributionAt(5)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(5) failed: %v", err)
+	}
+	if exact5 {
+		t.Error("expected exact=false for truncated count=5")
+	}
+}
+
+func TestDistributionHistory_SimulationAccuracy(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	for i := int32(0); i < 100; i++ {
+		nodeId := "nodeA"
+		if i%3 == 0 {
+			nodeId = "nodeB"
+		}
+		if i%7 == 0 {
+			nodeId = "nodeC"
+		}
+		store.AddWithNode(i, []byte{byte(i)}, nodeId)
+	}
+	store.Flush()
+
+	for _, targetCount := range []uint32{10, 25, 50, 75, 99} {
+		dist, exact, err := store.GetNodeDistributionAt(targetCount)
+		if err != nil {
+			t.Fatalf("GetNodeDistributionAt(%d) failed: %v", targetCount, err)
+		}
+		if exact {
+			continue
+		}
+
+		var total uint32
+		for _, c := range dist {
+			total += c
+		}
+		if total != targetCount {
+			t.Errorf("simulation for count=%d: sum=%d (expected %d)", targetCount, total, targetCount)
+		}
+	}
+}
+
+func TestDistributionHistory_ZeroCount(t *testing.T) {
+	dir := t.TempDir()
+	store, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+	defer store.Close()
+
+	dist, exact, err := store.GetNodeDistributionAt(0)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(0) failed: %v", err)
+	}
+	if !exact {
+		t.Error("expected exact=true for count=0")
+	}
+	if len(dist) != 0 {
+		t.Errorf("expected empty distribution for count=0, got %v", dist)
+	}
+}
+
+func TestDistributionHistory_CrashRecovery(t *testing.T) {
+	dir := t.TempDir()
+
+	store1, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST failed: %v", err)
+	}
+
+	store1.AddWithNode(1, []byte{1}, "nodeA")
+	store1.AddWithNode(2, []byte{2}, "nodeB")
+	store1.AddWithNode(3, []byte{3}, "nodeA")
+	store1.Flush()
+
+	store1.AddWithNode(4, []byte{4}, "nodeA")
+	store1.AddWithNode(5, []byte{5}, "nodeB")
+	store1.Flush()
+
+	store1.Close()
+
+	distPath := filepath.Join(dir, "distributions.jsonl")
+	content, err := os.ReadFile(distPath)
+	if err != nil {
+		t.Fatalf("read distributions.jsonl failed: %v", err)
+	}
+	lines := bytes.Split(content, []byte("\n"))
+	if len(lines) < 2 {
+		t.Fatalf("expected at least 2 distribution entries, got %d", len(lines))
+	}
+	if err := os.WriteFile(distPath, lines[0], 0644); err != nil {
+		t.Fatalf("truncate to first entry failed: %v", err)
+	}
+
+	store2, err := OpenSMST(dir)
+	if err != nil {
+		t.Fatalf("OpenSMST (reopen) failed: %v", err)
+	}
+	defer store2.Close()
+
+	if store2.Count() != 5 {
+		t.Errorf("expected 5 artifacts recovered, got %d", store2.Count())
+	}
+
+	dist3, exact3, err := store2.GetNodeDistributionAt(3)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(3) failed: %v", err)
+	}
+	if !exact3 {
+		t.Error("expected exact=true for count=3 (was in truncated history)")
+	}
+	if dist3["nodeA"] != 2 || dist3["nodeB"] != 1 {
+		t.Errorf("distribution at count=3: %v", dist3)
+	}
+
+	dist5, exact5, err := store2.GetNodeDistributionAt(5)
+	if err != nil {
+		t.Fatalf("GetNodeDistributionAt(5) failed: %v", err)
+	}
+	if exact5 {
+		t.Error("expected exact=false for count=5 (was lost in crash)")
+	}
+
+	var total uint32
+	for _, c := range dist5 {
+		total += c
+	}
+	if total != 5 {
+		t.Errorf("simulated distribution should sum to 5, got %d", total)
+	}
+}
+
+// TestDistributionLostAfterRestart_ScannerLimit reproduces the bufio.Scanner
+// 64 KB default line limit. 1100 nodes × ~65 bytes/entry ≈ 71 KB per line,
+// which exceeds the limit. On reopen the distribution silently becomes empty.
+func TestDistributionLostAfterRestart_ScannerLimit(t *testing.T) {
+	dir := t.TempDir()
+
+	s, _ := OpenSMST(dir)
+	for i := 0; i < 1100; i++ {
+		s.AddWithNode(int32(i+1), []byte{1}, fmt.Sprintf("node-%055d", i))
+	}
+	s.Flush()
+	want := len(s.GetNodeDistribution())
+	s.Close()
+
+	s2, _ := OpenSMST(dir)
+	defer s2.Close()
+	got := len(s2.GetNodeDistribution())
+
+	if got != want {
+		t.Fatalf("distribution lost after restart: recovered %d nodes, want %d", got, want)
+	}
+}
diff --git a/decentralized-api/poc/artifacts/smst_verify.go b/decentralized-api/poc/artifacts/smst_verify.go
new file mode 100644
index 0000000000..692d216319
--- /dev/null
+++ b/decentralized-api/poc/artifacts/smst_verify.go
@@ -0,0 +1,126 @@
+package artifacts
+
+import "encoding/binary"
+
+func smstNoncePath(nonce int32, depth int) []bool {
+	path := make([]bool, depth)
+	n := uint32(nonce)
+	for i := 0; i < depth; i++ {
+		bit := (n >> (depth - 1 - i)) & 1
+		path[i] = bit == 1
+	}
+	return path
+}
+
+func bytesEqual(a, b []byte) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func verifySMSTProofWithCounts(rootHash []byte, count uint32, nonce int32, leafData []byte, proof []smstProofElement) bool {
+	if len(proof) == 0 {
+		return false
+	}
+
+	depth := len(proof)
+	leafHash := smstHashLeaf(leafData)
+	path := smstNoncePath(nonce, depth)
+
+	currentHash := leafHash
+	currentCount := uint32(1)
+
+	for i := depth - 1; i >= 0; i-- {
+		elem := proof[i]
+		goRight := path[i]
+
+		var leftHash, rightHash []byte
+		var leftCount, rightCount uint32
+
+		if goRight {
+			leftHash = elem.siblingHash
+			rightHash = currentHash
+			leftCount = elem.siblingCount
+			rightCount = currentCount
+		} else {
+			leftHash = currentHash
+			rightHash = elem.siblingHash
+			leftCount = currentCount
+			rightCount = elem.siblingCount
+		}
+
+		currentCount = leftCount + rightCount
+		currentHash = smstHashNode(leftHash, rightHash, currentCount)
+	}
+
+	if currentCount != count {
+		return false
+	}
+
+	return bytesEqual(currentHash, rootHash)
+}
+
+type smstProofElement struct {
+	siblingHash  []byte
+	siblingCount uint32
+}
+
+// decodeProofElements decodes proof from slice format ([][]byte where each is 36 bytes).
+func decodeProofElements(proof [][]byte) []smstProofElement {
+	elements := make([]smstProofElement, len(proof))
+	for i, data := range proof {
+		if len(data) != 36 {
+			return nil
+		}
+		elements[i].siblingHash = data[:32]
+		elements[i].siblingCount = binary.LittleEndian.Uint32(data[32:36])
+	}
+	return elements
+}
+
+
+// VerifySMSTProofWithDenseIndex verifies an SMST proof and checks that the nonce
+// is at the claimed dense index position. The sibling counts in the proof are
+// committed by the root hash, making the index binding cryptographically sound.
+//
+// Security: This function is hardened against overflow attacks. The computedIndex
+// accumulator uses uint64 to detect overflow, and we explicitly check that it
+// stays within bounds of count. Since sibling counts are committed by the root hash,
+// a malicious prover cannot forge counts without changing the root.
+func VerifySMSTProofWithDenseIndex(rootHash []byte, count uint32, denseIndex uint32, nonce int32, leafData []byte, proof [][]byte) bool {
+	// Reject edge cases: empty proof, zero count, or out-of-bounds index
+	if len(proof) == 0 || count == 0 || denseIndex >= count {
+		return false
+	}
+
+	elements := decodeProofElements(proof)
+	if elements == nil {
+		return false
+	}
+
+	if !verifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements) {
+		return false
+	}
+
+	depth := len(elements)
+	path := smstNoncePath(nonce, depth)
+
+	var computedIndex uint64
+	for i := 0; i < depth; i++ {
+		if path[i] {
+			computedIndex += uint64(elements[i].siblingCount)
+			if computedIndex >= uint64(count) && computedIndex != uint64(denseIndex) {
+				return false
+			}
+		}
+	}
+
+	// Final check: computed index must exactly match claimed dense index
+	return computedIndex == uint64(denseIndex)
+}
diff --git a/decentralized-api/poc/artifacts/snapshot_cache.go b/decentralized-api/poc/artifacts/snapshot_cache.go
new file mode 100644
index 0000000000..31e78584ce
--- /dev/null
+++ b/decentralized-api/poc/artifacts/snapshot_cache.go
@@ -0,0 +1,197 @@
+package artifacts
+
+import (
+	"container/list"
+	"fmt"
+	"sync"
+	"time"
+)
+
+const (
+	// snapshotCacheMaxEntries must fit the pinned working set plus rotation
+	// room. With 2 models the worst case pins 4 trees (early + historical
+	// final per model); 6 leaves 2 rotating slots even then. Note that
+	// exceeding the cap with pinned-only entries evicts the LRU pinned tree.
+	snapshotCacheMaxEntries    = 6
+	snapshotCacheIdleTTL       = 20 * time.Minute
+	snapshotCacheMaxConcurrent = 2
+)
+
+type snapshotCacheKey struct {
+	store *SMSTArtifactStore
+	count uint32
+}
+
+type snapshotCacheEntry struct {
+	key        snapshotCacheKey
+	tree       *SMST
+	lastAccess time.Time
+	pinned     bool
+	elem       *list.Element
+}
+
+type snapshotBuildCall struct {
+	done chan struct{}
+	tree *SMST
+	err  error
+}
+
+type snapshotCache struct {
+	mu         sync.Mutex
+	maxEntries int
+	idleTTL    time.Duration
+	entries    map[snapshotCacheKey]*snapshotCacheEntry
+	lru        *list.List
+	inflight   map[snapshotCacheKey]*snapshotBuildCall
+	buildSem   chan struct{}
+	now        func() time.Time
+}
+
+var globalSnapshotCache = newSnapshotCache(snapshotCacheMaxEntries, snapshotCacheMaxConcurrent)
+
+func newSnapshotCache(maxEntries, maxConcurrent int) *snapshotCache {
+	if maxConcurrent <= 0 {
+		maxConcurrent = snapshotCacheMaxConcurrent
+	}
+	return &snapshotCache{
+		maxEntries: maxEntries,
+		idleTTL:    snapshotCacheIdleTTL,
+		entries:    make(map[snapshotCacheKey]*snapshotCacheEntry, maxEntries),
+		lru:        list.New(),
+		inflight:   make(map[snapshotCacheKey]*snapshotBuildCall),
+		buildSem:   make(chan struct{}, maxConcurrent),
+		now:        time.Now,
+	}
+}
+
+func (c *snapshotCache) getOrBuild(store *SMSTArtifactStore, count uint32, pinned bool) (*SMST, error) {
+	key := snapshotCacheKey{store: store, count: count}
+	return c.getOrBuildWithBuilder(key, pinned, func() (*SMST, error) {
+		return store.buildSnapshotTree(count)
+	})
+}
+
+func (c *snapshotCache) getOrBuildWithBuilder(key snapshotCacheKey, pinned bool, builder func() (*SMST, error)) (*SMST, error) {
+	c.mu.Lock()
+	now := c.now()
+	c.pruneExpiredLocked(now)
+	if entry, ok := c.entries[key]; ok {
+		entry.lastAccess = now
+		entry.pinned = entry.pinned || pinned
+		c.lru.MoveToFront(entry.elem)
+		tree := entry.tree
+		c.mu.Unlock()
+		return tree, nil
+	}
+	if call, ok := c.inflight[key]; ok {
+		c.mu.Unlock()
+		<-call.done
+		return call.tree, call.err
+	}
+
+	call := &snapshotBuildCall{done: make(chan struct{})}
+	c.inflight[key] = call
+	c.mu.Unlock()
+
+	c.buildSem <- struct{}{}
+	tree, err := builder()
+	<-c.buildSem
+
+	c.mu.Lock()
+	call.tree = tree
+	call.err = err
+	delete(c.inflight, key)
+	if err == nil {
+		c.insertLocked(key, tree, pinned, c.now())
+	}
+	close(call.done)
+	c.mu.Unlock()
+
+	return tree, err
+}
+
+func (c *snapshotCache) purgeStore(store *SMSTArtifactStore) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	for elem := c.lru.Back(); elem != nil; {
+		prev := elem.Prev()
+		entry := elem.Value.(*snapshotCacheEntry)
+		if entry.key.store == store {
+			c.removeEntryLocked(entry)
+		}
+		elem = prev
+	}
+}
+
+func (c *snapshotCache) insertLocked(key snapshotCacheKey, tree *SMST, pinned bool, now time.Time) {
+	if entry, ok := c.entries[key]; ok {
+		entry.tree = tree
+		entry.lastAccess = now
+		entry.pinned = entry.pinned || pinned
+		c.lru.MoveToFront(entry.elem)
+		return
+	}
+
+	entry := &snapshotCacheEntry{
+		key:        key,
+		tree:       tree,
+		lastAccess: now,
+		pinned:     pinned,
+	}
+	entry.elem = c.lru.PushFront(entry)
+	c.entries[key] = entry
+	c.enforceMaxEntriesLocked()
+}
+
+func (c *snapshotCache) pruneExpiredLocked(now time.Time) {
+	for elem := c.lru.Back(); elem != nil; {
+		prev := elem.Prev()
+		entry := elem.Value.(*snapshotCacheEntry)
+		if !entry.pinned && now.Sub(entry.lastAccess) > c.idleTTL {
+			c.removeEntryLocked(entry)
+		}
+		elem = prev
+	}
+}
+
+func (c *snapshotCache) enforceMaxEntriesLocked() {
+	for len(c.entries) > c.maxEntries {
+		if entry := c.oldestUnpinnedLocked(); entry != nil {
+			c.removeEntryLocked(entry)
+			continue
+		}
+		if back := c.lru.Back(); back != nil {
+			c.removeEntryLocked(back.Value.(*snapshotCacheEntry))
+			continue
+		}
+		return
+	}
+}
+
+func (c *snapshotCache) oldestUnpinnedLocked() *snapshotCacheEntry {
+	for elem := c.lru.Back(); elem != nil; elem = elem.Prev() {
+		entry := elem.Value.(*snapshotCacheEntry)
+		if !entry.pinned {
+			return entry
+		}
+	}
+	return nil
+}
+
+func (c *snapshotCache) removeEntryLocked(entry *snapshotCacheEntry) {
+	delete(c.entries, entry.key)
+	c.lru.Remove(entry.elem)
+}
+
+func (s *SMSTArtifactStore) buildSnapshotTree(count uint32) (*SMST, error) {
+	offsets, buffered, err := s.snapshotRebuildInputs(count)
+	if err != nil {
+		return nil, err
+	}
+	tree := rebuildTreeFromInputs(s.dataFile, offsets, buffered, count)
+	if tree.Count() != count {
+		return nil, fmt.Errorf("rebuilt count %d differs from requested %d", tree.Count(), count)
+	}
+	return tree, nil
+}
diff --git a/decentralized-api/poc/artifacts/snapshot_cache_test.go b/decentralized-api/poc/artifacts/snapshot_cache_test.go
new file mode 100644
index 0000000000..20ced694b3
--- /dev/null
+++ b/decentralized-api/poc/artifacts/snapshot_cache_test.go
@@ -0,0 +1,184 @@
+package artifacts
+
+import (
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func TestSnapshotCacheCapAndPinnedEntries(t *testing.T) {
+	c := newSnapshotCache(4, 2)
+	now := time.Unix(100, 0)
+	c.now = func() time.Time { return now }
+
+	store := &SMSTArtifactStore{}
+	c.mu.Lock()
+	for i := uint32(1); i <= 4; i++ {
+		c.insertLocked(snapshotCacheKey{store: store, count: i}, NewSMST(smstDefaultDepth), i == 1, now)
+		now = now.Add(time.Second)
+	}
+	c.insertLocked(snapshotCacheKey{store: store, count: 5}, NewSMST(smstDefaultDepth), false, now)
+	c.mu.Unlock()
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if len(c.entries) != 4 {
+		t.Fatalf("cache size = %d, want 4", len(c.entries))
+	}
+	if _, ok := c.entries[snapshotCacheKey{store: store, count: 1}]; !ok {
+		t.Fatal("pinned entry was evicted by unpinned pressure")
+	}
+	if _, ok := c.entries[snapshotCacheKey{store: store, count: 2}]; ok {
+		t.Fatal("oldest unpinned entry should have been evicted")
+	}
+}
+
+func TestSnapshotCacheIdleEvictionAndPurge(t *testing.T) {
+	c := newSnapshotCache(4, 2)
+	now := time.Unix(100, 0)
+	c.now = func() time.Time { return now }
+	c.idleTTL = time.Minute
+
+	storeA := &SMSTArtifactStore{}
+	storeB := &SMSTArtifactStore{}
+
+	c.mu.Lock()
+	c.insertLocked(snapshotCacheKey{store: storeA, count: 1}, NewSMST(smstDefaultDepth), false, now)
+	c.insertLocked(snapshotCacheKey{store: storeA, count: 2}, NewSMST(smstDefaultDepth), true, now)
+	c.insertLocked(snapshotCacheKey{store: storeB, count: 1}, NewSMST(smstDefaultDepth), true, now)
+	c.mu.Unlock()
+
+	now = now.Add(2 * time.Minute)
+	c.mu.Lock()
+	c.pruneExpiredLocked(now)
+	c.mu.Unlock()
+
+	c.mu.Lock()
+	if _, ok := c.entries[snapshotCacheKey{store: storeA, count: 1}]; ok {
+		t.Fatal("idle unpinned entry should be evicted")
+	}
+	if _, ok := c.entries[snapshotCacheKey{store: storeA, count: 2}]; !ok {
+		t.Fatal("pinned entry should not be idle-evicted")
+	}
+	c.mu.Unlock()
+
+	c.purgeStore(storeA)
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if _, ok := c.entries[snapshotCacheKey{store: storeA, count: 2}]; ok {
+		t.Fatal("purgeStore should remove pinned entries for that store")
+	}
+	if _, ok := c.entries[snapshotCacheKey{store: storeB, count: 1}]; !ok {
+		t.Fatal("purgeStore removed unrelated store entry")
+	}
+}
+
+func TestLiveCountServedWithoutCache(t *testing.T) {
+	store, err := OpenSMST(t.TempDir())
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for _, nonce := range []int32{10, 20, 30} {
+		if err := store.AddWithNode(nonce, []byte{byte(nonce)}, ""); err != nil {
+			t.Fatalf("Add(%d): %v", nonce, err)
+		}
+	}
+	store.Flush()
+	count := store.Count()
+
+	if _, err := store.GetArtifactsAndProofs([]uint32{0, 1}, count); err != nil {
+		t.Fatalf("GetArtifactsAndProofs: %v", err)
+	}
+	if _, err := store.GetArtifactsAndProofsByNonce([]int32{20}, count); err != nil {
+		t.Fatalf("GetArtifactsAndProofsByNonce: %v", err)
+	}
+
+	globalSnapshotCache.mu.Lock()
+	_, cached := globalSnapshotCache.entries[snapshotCacheKey{store: store, count: count}]
+	globalSnapshotCache.mu.Unlock()
+	if cached {
+		t.Fatal("live count must be served from the live tree, not cached")
+	}
+}
+
+func TestWarmSnapshotPinsEntry(t *testing.T) {
+	// Cold path: tip already past the count and no retained capture, so Warm
+	// rebuilds into the process snapshot cache. COW off so flush does not
+	// retain; tip advance then leaves earlyCount without an in-memory clone.
+	t.Setenv(envSMSTCOW, "0")
+	store, err := OpenSMST(t.TempDir())
+	if err != nil {
+		t.Fatalf("OpenSMST: %v", err)
+	}
+	defer store.Close()
+
+	for _, nonce := range []int32{1, 2, 3} {
+		if err := store.AddWithNode(nonce, []byte{byte(nonce)}, ""); err != nil {
+			t.Fatalf("Add(%d): %v", nonce, err)
+		}
+	}
+	store.Flush()
+	earlyCount := store.Count()
+
+	if err := store.AddWithNode(4, []byte{4}, ""); err != nil {
+		t.Fatalf("Add(4): %v", err)
+	}
+	store.Flush()
+
+	store.WarmSnapshot(earlyCount)
+
+	globalSnapshotCache.mu.Lock()
+	entry, ok := globalSnapshotCache.entries[snapshotCacheKey{store: store, count: earlyCount}]
+	globalSnapshotCache.mu.Unlock()
+	if !ok {
+		t.Fatal("warm-up must cache the snapshot tree")
+	}
+	if !entry.pinned {
+		t.Fatal("warm-up entry must be pinned")
+	}
+}
+
+func TestSnapshotCacheSingleFlight(t *testing.T) {
+	c := newSnapshotCache(4, 2)
+	key := snapshotCacheKey{store: &SMSTArtifactStore{}, count: 1}
+
+	var builds int32
+	start := make(chan struct{})
+	done := make(chan struct{})
+	builder := func() (*SMST, error) {
+		atomic.AddInt32(&builds, 1)
+		close(start)
+		<-done
+		return NewSMST(smstDefaultDepth), nil
+	}
+
+	const callers = 8
+	var wg sync.WaitGroup
+	errs := make(chan error, callers)
+	for i := 0; i < callers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			_, err := c.getOrBuildWithBuilder(key, false, builder)
+			errs <- err
+		}()
+	}
+
+	<-start
+	time.Sleep(20 * time.Millisecond)
+	close(done)
+	wg.Wait()
+	close(errs)
+
+	for err := range errs {
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	}
+	if builds != 1 {
+		t.Fatalf("builds = %d, want 1", builds)
+	}
+}
diff --git a/decentralized-api/poc/artifacts/store.go b/decentralized-api/poc/artifacts/store.go
deleted file mode 100644
index 8b83128293..0000000000
--- a/decentralized-api/poc/artifacts/store.go
+++ /dev/null
@@ -1,518 +0,0 @@
-package artifacts
-
-import (
-	"bufio"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-)
-
-const (
-	// MaxLeafCount caps artifacts to ensure MMR size calculations stay within int limits.
-	// mmrSizeForLeaves(n) = 2n - popcount(n), so 2n must fit in int32: n <= MaxInt32/2.
-	MaxLeafCount = (1 << 30) - 1 // 1,073,741,823
-)
-
-var (
-	ErrDuplicateNonce      = errors.New("duplicate nonce")
-	ErrLeafIndexOutOfRange = errors.New("leaf index out of range")
-	ErrStoreClosed         = errors.New("store is closed")
-	ErrCapacityExceeded    = errors.New("store capacity exceeded")
-)
-
-// ArtifactStore provides append-only storage for PoC artifacts with MMR commitments.
-//
-// Uses single file on disk + in-memory state (offsets, MMR, nonce map).
-// On restart, state is rebuilt by reading the data file (~2-3 sec for 1M artifacts, 1 cpu core).
-type ArtifactStore struct {
-	mu     sync.RWMutex
-	dir    string
-	closed bool
-
-	dataFile  *os.File // artifacts.data: [LE32 len][LE32 nonce][vector]...
-	nodesFile *os.File // nodes.data: JSON map of node_id -> count
-
-	buffer           []bufferedArtifact
-	offsets          []uint64
-	nonceToLeafIndex map[int32]uint32
-	mmrNodes         [][]byte
-	nextLeafIndex    uint32
-
-	flushedLeafCount  uint32
-	flushedDataOffset uint64
-
-	// Node distribution tracking
-	nodeCounts        map[string]uint32 // node_id -> artifact count (in-memory, includes unflushed)
-	flushedNodeCounts map[string]uint32 // persisted node counts
-}
-
-type bufferedArtifact struct {
-	nonce  int32
-	vector []byte
-	nodeId string
-}
-
-func Open(dir string) (*ArtifactStore, error) {
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		return nil, fmt.Errorf("create dir: %w", err)
-	}
-
-	dataPath := filepath.Join(dir, "artifacts.data")
-	nodesPath := filepath.Join(dir, "nodes.json")
-
-	dataFile, err := os.OpenFile(dataPath, os.O_RDWR|os.O_CREATE, 0644)
-	if err != nil {
-		return nil, fmt.Errorf("open data file: %w", err)
-	}
-
-	nodesFile, err := os.OpenFile(nodesPath, os.O_RDWR|os.O_CREATE, 0644)
-	if err != nil {
-		dataFile.Close()
-		return nil, fmt.Errorf("open nodes file: %w", err)
-	}
-
-	s := &ArtifactStore{
-		dir:               dir,
-		dataFile:          dataFile,
-		nodesFile:         nodesFile,
-		buffer:            make([]bufferedArtifact, 0, 1024),
-		offsets:           make([]uint64, 0, 1024),
-		nonceToLeafIndex:  make(map[int32]uint32),
-		mmrNodes:          make([][]byte, 0, 1024),
-		nodeCounts:        make(map[string]uint32),
-		flushedNodeCounts: make(map[string]uint32),
-	}
-
-	if err := s.recover(); err != nil {
-		s.dataFile.Close()
-		s.nodesFile.Close()
-		return nil, fmt.Errorf("recover: %w", err)
-	}
-
-	return s, nil
-}
-
-func (s *ArtifactStore) recover() error {
-	info, err := s.dataFile.Stat()
-	if err != nil {
-		return fmt.Errorf("stat data file: %w", err)
-	}
-
-	if info.Size() == 0 {
-		return nil
-	}
-
-	if _, err := s.dataFile.Seek(0, io.SeekStart); err != nil {
-		return fmt.Errorf("seek data file: %w", err)
-	}
-
-	var offset uint64
-	for {
-		nonce, vector, n, err := readArtifact(s.dataFile)
-		if err == io.EOF {
-			break
-		}
-		if errors.Is(err, io.ErrUnexpectedEOF) {
-			if truncErr := s.dataFile.Truncate(int64(offset)); truncErr != nil {
-				return fmt.Errorf("truncate after partial record: %w", truncErr)
-			}
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("read artifact at offset %d: %w", offset, err)
-		}
-
-		if _, exists := s.nonceToLeafIndex[nonce]; exists {
-			return fmt.Errorf("duplicate nonce %d at offset %d", nonce, offset)
-		}
-
-		if s.nextLeafIndex >= MaxLeafCount {
-			return fmt.Errorf("data file exceeds max leaf count %d", MaxLeafCount)
-		}
-
-		s.offsets = append(s.offsets, offset)
-		s.nonceToLeafIndex[nonce] = s.nextLeafIndex
-		leafHash := hashLeaf(encodeLeaf(nonce, vector))
-		appendToMMR(&s.mmrNodes, leafHash, s.nextLeafIndex)
-		s.nextLeafIndex++
-		offset += uint64(n)
-	}
-
-	s.flushedLeafCount = s.nextLeafIndex
-	s.flushedDataOffset = offset
-
-	// Recover node counts from nodes.json
-	if err := s.recoverNodeCounts(); err != nil {
-		return fmt.Errorf("recover node counts: %w", err)
-	}
-
-	return nil
-}
-
-func (s *ArtifactStore) recoverNodeCounts() error {
-	info, err := s.nodesFile.Stat()
-	if err != nil {
-		return fmt.Errorf("stat nodes file: %w", err)
-	}
-
-	if info.Size() == 0 {
-		return nil
-	}
-
-	if _, err := s.nodesFile.Seek(0, io.SeekStart); err != nil {
-		return fmt.Errorf("seek nodes file: %w", err)
-	}
-
-	decoder := json.NewDecoder(s.nodesFile)
-	if err := decoder.Decode(&s.flushedNodeCounts); err != nil {
-		return fmt.Errorf("decode nodes file: %w", err)
-	}
-
-	// Copy flushed counts to current counts
-	for k, v := range s.flushedNodeCounts {
-		s.nodeCounts[k] = v
-	}
-
-	return nil
-}
-
-// Add appends an artifact if nonce is not already in the store.
-// Deprecated: Use AddWithNode to track per-node distribution.
-func (s *ArtifactStore) Add(nonce int32, vector []byte) error {
-	return s.AddWithNode(nonce, vector, "")
-}
-
-// AddWithNode appends an artifact and tracks which node contributed it.
-func (s *ArtifactStore) AddWithNode(nonce int32, vector []byte, nodeId string) error {
-	leafHash := hashLeaf(encodeLeaf(nonce, vector))
-
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.closed {
-		return ErrStoreClosed
-	}
-
-	if s.nextLeafIndex >= MaxLeafCount {
-		return ErrCapacityExceeded
-	}
-
-	if _, exists := s.nonceToLeafIndex[nonce]; exists {
-		return ErrDuplicateNonce
-	}
-
-	s.nonceToLeafIndex[nonce] = s.nextLeafIndex
-	s.buffer = append(s.buffer, bufferedArtifact{nonce: nonce, vector: vector, nodeId: nodeId})
-
-	appendToMMR(&s.mmrNodes, leafHash, s.nextLeafIndex)
-	s.nextLeafIndex++
-
-	// Track node contribution
-	if nodeId != "" {
-		s.nodeCounts[nodeId]++
-	}
-
-	return nil
-}
-
-func (s *ArtifactStore) Flush() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.closed {
-		return ErrStoreClosed
-	}
-
-	return s.flushLocked()
-}
-
-// flushLocked flushes buffered artifacts to disk. Caller must hold s.mu.
-func (s *ArtifactStore) flushLocked() error {
-	if len(s.buffer) == 0 {
-		return nil
-	}
-
-	if _, err := s.dataFile.Seek(0, io.SeekEnd); err != nil {
-		return fmt.Errorf("seek data file: %w", err)
-	}
-
-	w := bufio.NewWriter(s.dataFile)
-	offset := s.flushedDataOffset
-
-	for _, art := range s.buffer {
-		s.offsets = append(s.offsets, offset)
-		n, err := writeArtifact(w, art.nonce, art.vector)
-		if err != nil {
-			return fmt.Errorf("write artifact: %w", err)
-		}
-		offset += uint64(n)
-	}
-
-	if err := w.Flush(); err != nil {
-		return fmt.Errorf("flush buffer: %w", err)
-	}
-	if err := s.dataFile.Sync(); err != nil {
-		return fmt.Errorf("sync data file: %w", err)
-	}
-
-	// Persist node counts
-	if err := s.flushNodeCountsLocked(); err != nil {
-		return fmt.Errorf("flush node counts: %w", err)
-	}
-
-	s.flushedLeafCount = s.nextLeafIndex
-	s.flushedDataOffset = offset
-	s.buffer = s.buffer[:0]
-
-	return nil
-}
-
-func (s *ArtifactStore) flushNodeCountsLocked() error {
-	// Copy current counts to flushed
-	for k, v := range s.nodeCounts {
-		s.flushedNodeCounts[k] = v
-	}
-
-	// Truncate and rewrite
-	if err := s.nodesFile.Truncate(0); err != nil {
-		return fmt.Errorf("truncate nodes file: %w", err)
-	}
-	if _, err := s.nodesFile.Seek(0, io.SeekStart); err != nil {
-		return fmt.Errorf("seek nodes file: %w", err)
-	}
-
-	encoder := json.NewEncoder(s.nodesFile)
-	if err := encoder.Encode(s.flushedNodeCounts); err != nil {
-		return fmt.Errorf("encode nodes file: %w", err)
-	}
-
-	if err := s.nodesFile.Sync(); err != nil {
-		return fmt.Errorf("sync nodes file: %w", err)
-	}
-
-	return nil
-}
-
-// GetRoot returns the current MMR root hash (32 bytes), or nil if empty.
-func (s *ArtifactStore) GetRoot() []byte {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	if s.nextLeafIndex == 0 {
-		return nil
-	}
-
-	return bagPeaks(s.mmrNodes, s.nextLeafIndex)
-}
-
-// GetRootAt returns the MMR root hash at a specific snapshot count.
-// This enables snapshot binding validation: callers can verify that a
-// (root_hash, count) pair matches the store's historical state.
-// Returns nil if snapshotCount is 0, error if snapshotCount exceeds current count.
-func (s *ArtifactStore) GetRootAt(snapshotCount uint32) ([]byte, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	if s.closed {
-		return nil, ErrStoreClosed
-	}
-
-	if snapshotCount == 0 {
-		return nil, nil
-	}
-
-	if snapshotCount > s.nextLeafIndex {
-		return nil, fmt.Errorf("snapshot count %d exceeds current count %d", snapshotCount, s.nextLeafIndex)
-	}
-
-	return bagPeaks(s.mmrNodes, snapshotCount), nil
-}
-
-// GetFlushedRoot returns the root and count of ONLY persisted artifacts.
-// Safe to report externally - survives process crashes.
-func (s *ArtifactStore) GetFlushedRoot() (count uint32, root []byte) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	if s.flushedLeafCount == 0 {
-		return 0, nil
-	}
-
-	return s.flushedLeafCount, bagPeaks(s.mmrNodes, s.flushedLeafCount)
-}
-
-func (s *ArtifactStore) Count() uint32 {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.nextLeafIndex
-}
-
-// GetNodeDistribution returns a copy of the flushed node distribution.
-func (s *ArtifactStore) GetNodeDistribution() map[string]uint32 {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	result := make(map[string]uint32, len(s.flushedNodeCounts))
-	for k, v := range s.flushedNodeCounts {
-		result[k] = v
-	}
-	return result
-}
-
-// GetNodeCounts returns a copy of the current (unflushed) node distribution.
-// Useful for logging/debugging to see real-time artifact counts per node.
-func (s *ArtifactStore) GetNodeCounts() map[string]uint32 {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	result := make(map[string]uint32, len(s.nodeCounts))
-	for k, v := range s.nodeCounts {
-		result[k] = v
-	}
-	return result
-}
-
-func (s *ArtifactStore) GetArtifact(leafIndex uint32) (nonce int32, vector []byte, err error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	if s.closed {
-		return 0, nil, ErrStoreClosed
-	}
-
-	if leafIndex >= s.nextLeafIndex {
-		return 0, nil, ErrLeafIndexOutOfRange
-	}
-
-	if leafIndex >= s.flushedLeafCount {
-		bufIdx := leafIndex - s.flushedLeafCount
-		art := s.buffer[bufIdx]
-		return art.nonce, art.vector, nil
-	}
-
-	offset := s.offsets[leafIndex]
-	// Use ReadAt for thread-safe concurrent reads (doesn't modify shared file position)
-	nonce, vector, _, err = readArtifactAt(s.dataFile, int64(offset))
-	if err != nil {
-		return 0, nil, fmt.Errorf("read artifact: %w", err)
-	}
-
-	return nonce, vector, nil
-}
-
-// GetProof generates a merkle proof for leafIndex at snapshotCount.
-func (s *ArtifactStore) GetProof(leafIndex uint32, snapshotCount uint32) ([][]byte, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	if s.closed {
-		return nil, ErrStoreClosed
-	}
-
-	if leafIndex >= snapshotCount {
-		return nil, ErrLeafIndexOutOfRange
-	}
-
-	if snapshotCount > s.nextLeafIndex {
-		return nil, fmt.Errorf("snapshot count %d exceeds current count %d", snapshotCount, s.nextLeafIndex)
-	}
-
-	return generateProof(s.mmrNodes, leafIndex, snapshotCount)
-}
-
-func (s *ArtifactStore) Close() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.closed {
-		return nil
-	}
-
-	s.closed = true
-
-	if err := s.flushLocked(); err != nil {
-		return fmt.Errorf("flush on close: %w", err)
-	}
-
-	if err := s.dataFile.Close(); err != nil {
-		return fmt.Errorf("close data file: %w", err)
-	}
-
-	if err := s.nodesFile.Close(); err != nil {
-		return fmt.Errorf("close nodes file: %w", err)
-	}
-
-	return nil
-}
-
-// writeArtifact format: [LE32 len][LE32 nonce][vector bytes]
-func writeArtifact(w io.Writer, nonce int32, vector []byte) (int, error) {
-	totalLen := 4 + len(vector)
-	header := make([]byte, 8)
-	binary.LittleEndian.PutUint32(header[0:4], uint32(totalLen))
-	binary.LittleEndian.PutUint32(header[4:8], uint32(nonce))
-
-	n1, err := w.Write(header)
-	if err != nil {
-		return n1, err
-	}
-
-	n2, err := w.Write(vector)
-	if err != nil {
-		return n1 + n2, err
-	}
-
-	return n1 + n2, nil
-}
-
-func readArtifact(r io.Reader) (int32, []byte, int, error) {
-	var header [8]byte
-	if _, err := io.ReadFull(r, header[:]); err != nil {
-		return 0, nil, 0, err
-	}
-
-	totalLen := binary.LittleEndian.Uint32(header[0:4])
-	nonce := int32(binary.LittleEndian.Uint32(header[4:8]))
-
-	vectorLen := totalLen - 4
-	vector := make([]byte, vectorLen)
-	if _, err := io.ReadFull(r, vector); err != nil {
-		return 0, nil, 0, err
-	}
-
-	return nonce, vector, 8 + int(vectorLen), nil
-}
-
-// readArtifactAt reads an artifact at a specific offset using ReadAt.
-// Unlike readArtifact, this is thread-safe for concurrent reads because
-// ReadAt doesn't modify the shared file position.
-func readArtifactAt(r io.ReaderAt, offset int64) (int32, []byte, int, error) {
-	var header [8]byte
-	if _, err := r.ReadAt(header[:], offset); err != nil {
-		return 0, nil, 0, err
-	}
-
-	totalLen := binary.LittleEndian.Uint32(header[0:4])
-	nonce := int32(binary.LittleEndian.Uint32(header[4:8]))
-
-	vectorLen := totalLen - 4
-	vector := make([]byte, vectorLen)
-	if _, err := r.ReadAt(vector, offset+8); err != nil {
-		return 0, nil, 0, err
-	}
-
-	return nonce, vector, 8 + int(vectorLen), nil
-}
-
-// encodeLeaf: LE32(nonce) || vector
-func encodeLeaf(nonce int32, vector []byte) []byte {
-	buf := make([]byte, 4+len(vector))
-	binary.LittleEndian.PutUint32(buf[:4], uint32(nonce))
-	copy(buf[4:], vector)
-	return buf
-}
diff --git a/decentralized-api/poc/artifacts/store_test.go b/decentralized-api/poc/artifacts/store_test.go
deleted file mode 100644
index 16583cfcd5..0000000000
--- a/decentralized-api/poc/artifacts/store_test.go
+++ /dev/null
@@ -1,504 +0,0 @@
-package artifacts
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sync"
-	"testing"
-)
-
-func TestOpenEmpty(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	if store.Count() != 0 {
-		t.Errorf("expected count 0, got %d", store.Count())
-	}
-
-	if store.GetRoot() != nil {
-		t.Errorf("expected nil root for empty store")
-	}
-}
-
-func TestAddAndCount(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	// Add some artifacts
-	for i := int32(0); i < 10; i++ {
-		vector := []byte{byte(i), byte(i + 1), byte(i + 2)}
-		if err := store.Add(i, vector); err != nil {
-			t.Fatalf("Add(%d) failed: %v", i, err)
-		}
-	}
-
-	if store.Count() != 10 {
-		t.Errorf("expected count 10, got %d", store.Count())
-	}
-}
-
-func TestDuplicateNonceRejection(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	vector := []byte{1, 2, 3}
-	if err := store.Add(42, vector); err != nil {
-		t.Fatalf("First Add failed: %v", err)
-	}
-
-	// Try to add duplicate
-	if err := store.Add(42, vector); err != ErrDuplicateNonce {
-		t.Errorf("expected ErrDuplicateNonce, got %v", err)
-	}
-
-	// Count should still be 1
-	if store.Count() != 1 {
-		t.Errorf("expected count 1, got %d", store.Count())
-	}
-}
-
-func TestFlushAndGetArtifact(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	// Add artifacts
-	artifacts := []struct {
-		nonce  int32
-		vector []byte
-	}{
-		{100, []byte{1, 2, 3, 4}},
-		{200, []byte{5, 6, 7, 8, 9}},
-		{-50, []byte{10, 11}}, // Negative nonce
-	}
-
-	for _, a := range artifacts {
-		if err := store.Add(a.nonce, a.vector); err != nil {
-			t.Fatalf("Add(%d) failed: %v", a.nonce, err)
-		}
-	}
-
-	// Get from buffer (before flush)
-	for i, a := range artifacts {
-		nonce, vector, err := store.GetArtifact(uint32(i))
-		if err != nil {
-			t.Fatalf("GetArtifact(%d) failed: %v", i, err)
-		}
-		if nonce != a.nonce {
-			t.Errorf("artifact %d: expected nonce %d, got %d", i, a.nonce, nonce)
-		}
-		if !bytes.Equal(vector, a.vector) {
-			t.Errorf("artifact %d: vector mismatch", i)
-		}
-	}
-
-	// Flush to disk
-	if err := store.Flush(); err != nil {
-		t.Fatalf("Flush failed: %v", err)
-	}
-
-	// Get from disk (after flush)
-	for i, a := range artifacts {
-		nonce, vector, err := store.GetArtifact(uint32(i))
-		if err != nil {
-			t.Fatalf("GetArtifact(%d) after flush failed: %v", i, err)
-		}
-		if nonce != a.nonce {
-			t.Errorf("artifact %d after flush: expected nonce %d, got %d", i, a.nonce, nonce)
-		}
-		if !bytes.Equal(vector, a.vector) {
-			t.Errorf("artifact %d after flush: vector mismatch", i)
-		}
-	}
-}
-
-func TestGetArtifactOutOfRange(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	store.Add(1, []byte{1})
-
-	_, _, err = store.GetArtifact(5)
-	if err != ErrLeafIndexOutOfRange {
-		t.Errorf("expected ErrLeafIndexOutOfRange, got %v", err)
-	}
-}
-
-func TestRecovery(t *testing.T) {
-	dir := t.TempDir()
-
-	// Create store and add data
-	store1, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-
-	artifacts := []struct {
-		nonce  int32
-		vector []byte
-	}{
-		{10, []byte{1, 2, 3}},
-		{20, []byte{4, 5, 6}},
-		{30, []byte{7, 8, 9}},
-	}
-
-	for _, a := range artifacts {
-		if err := store1.Add(a.nonce, a.vector); err != nil {
-			t.Fatalf("Add failed: %v", err)
-		}
-	}
-
-	if err := store1.Flush(); err != nil {
-		t.Fatalf("Flush failed: %v", err)
-	}
-
-	root1 := store1.GetRoot()
-	count1 := store1.Count()
-
-	store1.Close()
-
-	// Reopen and verify recovery
-	store2, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Reopen failed: %v", err)
-	}
-	defer store2.Close()
-
-	if store2.Count() != count1 {
-		t.Errorf("recovered count: expected %d, got %d", count1, store2.Count())
-	}
-
-	root2 := store2.GetRoot()
-	if !bytes.Equal(root1, root2) {
-		t.Errorf("recovered root mismatch")
-	}
-
-	// Verify artifacts
-	for i, a := range artifacts {
-		nonce, vector, err := store2.GetArtifact(uint32(i))
-		if err != nil {
-			t.Fatalf("GetArtifact(%d) after recovery failed: %v", i, err)
-		}
-		if nonce != a.nonce {
-			t.Errorf("artifact %d: expected nonce %d, got %d", i, a.nonce, nonce)
-		}
-		if !bytes.Equal(vector, a.vector) {
-			t.Errorf("artifact %d: vector mismatch", i)
-		}
-	}
-
-	// Verify duplicate rejection still works after recovery
-	if err := store2.Add(10, []byte{1}); err != ErrDuplicateNonce {
-		t.Errorf("expected duplicate rejection after recovery, got %v", err)
-	}
-}
-
-func TestProofGeneration(t *testing.T) {
-	dir := t.TempDir()
-	store, _ := Open(dir)
-	defer store.Close()
-
-	// Add 8 artifacts to get a single-peak tree
-	for i := int32(0); i < 8; i++ {
-		store.Add(i, []byte{byte(i)})
-	}
-
-	root := store.GetRoot()
-	if root == nil {
-		t.Fatal("root should not be nil")
-	}
-
-	// Generate and verify proof for each leaf
-	for i := uint32(0); i < 8; i++ {
-		proof, err := store.GetProof(i, 8)
-		if err != nil {
-			t.Fatalf("GetProof(%d, 8) failed: %v", i, err)
-		}
-
-		// Proof should have 3 siblings for a perfect 8-leaf tree (log2(8) = 3)
-		if len(proof) != 3 {
-			t.Errorf("proof for leaf %d: expected 3 elements, got %d", i, len(proof))
-		}
-
-		// Verify the proof
-		leafData := encodeLeaf(int32(i), []byte{byte(i)})
-		if !VerifyProof(root, 8, i, leafData, proof) {
-			t.Errorf("proof verification failed for leaf %d", i)
-		}
-	}
-}
-
-func TestProofForVariousTreeSizes(t *testing.T) {
-	sizes := []int{1, 2, 3, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 100, 127, 128, 255, 256}
-
-	for _, size := range sizes {
-		t.Run(fmt.Sprintf("size_%d", size), func(t *testing.T) {
-			dir := t.TempDir()
-			store, _ := Open(dir)
-			defer store.Close()
-
-			for i := 0; i < size; i++ {
-				store.Add(int32(i), []byte{byte(i)})
-			}
-
-			root := store.GetRoot()
-			for i := uint32(0); i < uint32(size); i++ {
-				proof, err := store.GetProof(i, uint32(size))
-				if err != nil {
-					t.Fatalf("GetProof(%d, %d) failed: %v", i, size, err)
-				}
-				leafData := encodeLeaf(int32(i), []byte{byte(i)})
-				if !VerifyProof(root, uint32(size), i, leafData, proof) {
-					t.Errorf("proof failed for leaf %d in tree of size %d", i, size)
-				}
-			}
-		})
-	}
-}
-
-func TestGetRootAt(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	// Empty store
-	root, err := store.GetRootAt(0)
-	if err != nil {
-		t.Errorf("GetRootAt(0) on empty store should not error: %v", err)
-	}
-	if root != nil {
-		t.Errorf("GetRootAt(0) should return nil")
-	}
-
-	// Add artifacts and record roots at each count
-	roots := make([][]byte, 11)
-	for i := int32(1); i <= 10; i++ {
-		if err := store.Add(i, []byte{byte(i)}); err != nil {
-			t.Fatalf("Add(%d) failed: %v", i, err)
-		}
-		root, err := store.GetRootAt(uint32(i))
-		if err != nil {
-			t.Fatalf("GetRootAt(%d) failed: %v", i, err)
-		}
-		roots[i] = root
-	}
-
-	// Verify historical roots are still accessible
-	for i := uint32(1); i <= 10; i++ {
-		root, err := store.GetRootAt(i)
-		if err != nil {
-			t.Fatalf("GetRootAt(%d) failed: %v", i, err)
-		}
-		if !bytes.Equal(root, roots[i]) {
-			t.Errorf("GetRootAt(%d) returned different root", i)
-		}
-	}
-}
-
-func TestGetFlushedRoot(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	// Empty store
-	count, root := store.GetFlushedRoot()
-	if count != 0 {
-		t.Errorf("expected count 0, got %d", count)
-	}
-	if root != nil {
-		t.Errorf("expected nil root for empty store")
-	}
-
-	// Add but don't flush
-	for i := int32(0); i < 5; i++ {
-		store.Add(i, []byte{byte(i)})
-	}
-
-	count, root = store.GetFlushedRoot()
-	if count != 0 {
-		t.Errorf("expected flushed count 0 before flush, got %d", count)
-	}
-
-	// Flush
-	store.Flush()
-	count, root = store.GetFlushedRoot()
-	if count != 5 {
-		t.Errorf("expected flushed count 5 after flush, got %d", count)
-	}
-	if root == nil {
-		t.Error("expected non-nil root after flush")
-	}
-}
-
-func TestAddAfterClose(t *testing.T) {
-	dir := t.TempDir()
-	store, _ := Open(dir)
-	store.Add(1, []byte{1})
-	store.Close()
-
-	err := store.Add(2, []byte{2})
-	if err != ErrStoreClosed {
-		t.Errorf("expected ErrStoreClosed, got %v", err)
-	}
-}
-
-func TestNegativeNonce(t *testing.T) {
-	dir := t.TempDir()
-	store, _ := Open(dir)
-	defer store.Close()
-
-	store.Add(-1, []byte{1})
-	store.Add(-100, []byte{2})
-	store.Add(-2147483648, []byte{3}) // INT32_MIN
-
-	if store.Count() != 3 {
-		t.Errorf("expected 3, got %d", store.Count())
-	}
-
-	nonce, _, err := store.GetArtifact(0)
-	if err != nil || nonce != -1 {
-		t.Errorf("expected nonce -1, got %d, err: %v", nonce, err)
-	}
-}
-
-func TestRecoveryWithTruncatedRecord(t *testing.T) {
-	dir := t.TempDir()
-
-	store1, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-
-	store1.Add(10, []byte{1, 2, 3})
-	store1.Add(20, []byte{4, 5, 6})
-	store1.Flush()
-	root1 := store1.GetRoot()
-	store1.Close()
-
-	// Append garbage (partial record) to data file
-	dataPath := filepath.Join(dir, "artifacts.data")
-	f, err := os.OpenFile(dataPath, os.O_WRONLY|os.O_APPEND, 0644)
-	if err != nil {
-		t.Fatalf("open data file: %v", err)
-	}
-	f.Write([]byte{0x10, 0x00, 0x00, 0x00}) // partial header
-	f.Close()
-
-	// Reopen - should recover by truncating partial record
-	store2, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Reopen with truncated record failed: %v", err)
-	}
-	defer store2.Close()
-
-	if store2.Count() != 2 {
-		t.Errorf("expected count 2 after truncation recovery, got %d", store2.Count())
-	}
-
-	root2 := store2.GetRoot()
-	if !bytes.Equal(root1, root2) {
-		t.Errorf("root mismatch after truncation recovery")
-	}
-}
-
-func TestConcurrentGetArtifact(t *testing.T) {
-	dir := t.TempDir()
-	store, err := Open(dir)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer store.Close()
-
-	const artifactCount = 100
-	const goroutines = 50
-	const readsPerGoroutine = 20
-
-	for i := 0; i < artifactCount; i++ {
-		vector := []byte{byte(i), byte(i + 1), byte(i + 2), byte(i + 3)}
-		if err := store.Add(int32(i), vector); err != nil {
-			t.Fatalf("Add(%d) failed: %v", i, err)
-		}
-	}
-
-	if err := store.Flush(); err != nil {
-		t.Fatalf("Flush failed: %v", err)
-	}
-
-	var wg sync.WaitGroup
-	errChan := make(chan error, goroutines*readsPerGoroutine)
-
-	for g := 0; g < goroutines; g++ {
-		wg.Add(1)
-		go func(goroutineID int) {
-			defer wg.Done()
-			for r := 0; r < readsPerGoroutine; r++ {
-				leafIdx := uint32((goroutineID*readsPerGoroutine + r) % artifactCount)
-				nonce, vector, err := store.GetArtifact(leafIdx)
-				if err != nil {
-					errChan <- fmt.Errorf("goroutine %d: GetArtifact(%d) failed: %v", goroutineID, leafIdx, err)
-					return
-				}
-				expectedNonce := int32(leafIdx)
-				expectedVector := []byte{byte(leafIdx), byte(leafIdx + 1), byte(leafIdx + 2), byte(leafIdx + 3)}
-				if nonce != expectedNonce {
-					errChan <- fmt.Errorf("goroutine %d: leafIdx %d: expected nonce %d, got %d", goroutineID, leafIdx, expectedNonce, nonce)
-					return
-				}
-				if !bytes.Equal(vector, expectedVector) {
-					errChan <- fmt.Errorf("goroutine %d: leafIdx %d: vector mismatch", goroutineID, leafIdx)
-					return
-				}
-			}
-		}(g)
-	}
-
-	wg.Wait()
-	close(errChan)
-
-	for err := range errChan {
-		t.Error(err)
-	}
-}
-
-func BenchmarkAdd(b *testing.B) {
-	dir := b.TempDir()
-	store, _ := Open(dir)
-	defer store.Close()
-
-	vector := make([]byte, 100)
-	for i := range vector {
-		vector[i] = byte(i)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		store.Add(int32(i), vector)
-	}
-}
diff --git a/decentralized-api/poc/commit_worker.go b/decentralized-api/poc/commit_worker.go
index 545fb3c347..12dadfb812 100644
--- a/decentralized-api/poc/commit_worker.go
+++ b/decentralized-api/poc/commit_worker.go
@@ -157,7 +157,7 @@ func (w *CommitWorker) maybeSubmitCommit(pocHeight int64) {
 
 		key := commitKey{stage: pocHeight, modelID: stageStore.ModelID}
 		last, hasLast := w.lastCommitted[key]
-		
+
 		if !hasLast && w.participantAddress != "" {
 			queryClient := w.recorder.NewInferenceQueryClient()
 			resp, err := queryClient.PoCV2StoreCommit(context.Background(), &types.QueryPoCV2StoreCommitRequest{
@@ -197,7 +197,7 @@ func (w *CommitWorker) maybeSubmitCommit(pocHeight int64) {
 
 	msg := &types.MsgPoCV2StoreCommit{
 		PocStageStartBlockHeight: pocHeight,
-		Entries:                 entries,
+		Entries:                  entries,
 	}
 
 	if err := w.recorder.SubmitPoCV2StoreCommit(msg); err != nil {
@@ -258,6 +258,11 @@ func (w *CommitWorker) submitWeightDistribution(pocHeight int64) {
 			continue
 		}
 
+		if err := stageStore.Store.PrebuildSnapshot(commitResp.Count); err != nil {
+			logging.Warn("CommitWorker: prebuild failed", types.PoC,
+				"pocHeight", pocHeight, "modelId", stageStore.ModelID, "count", commitResp.Count, "error", err)
+		}
+
 		distributionResp, err := queryClient.MLNodeWeightDistribution(context.Background(), &types.QueryMLNodeWeightDistributionRequest{
 			PocStageStartBlockHeight: pocHeight,
 			ParticipantAddress:       w.participantAddress,
@@ -267,7 +272,16 @@ func (w *CommitWorker) submitWeightDistribution(pocHeight int64) {
 			continue
 		}
 
-		distribution := stageStore.Store.GetNodeDistribution()
+		distribution, exact, err := stageStore.Store.GetNodeDistributionAt(commitResp.Count)
+		if err != nil {
+			logging.Error("CommitWorker: failed to get distribution", types.PoC,
+				"pocHeight", pocHeight, "modelId", stageStore.ModelID, "count", commitResp.Count, "error", err)
+			continue
+		}
+		if !exact {
+			logging.Warn("CommitWorker: using simulated distribution (history miss)", types.PoC,
+				"pocHeight", pocHeight, "modelId", stageStore.ModelID, "count", commitResp.Count)
+		}
 		if len(distribution) == 0 {
 			continue
 		}
@@ -292,7 +306,7 @@ func (w *CommitWorker) submitWeightDistribution(pocHeight int64) {
 
 	msg := &types.MsgMLNodeWeightDistribution{
 		PocStageStartBlockHeight: pocHeight,
-		Entries:                 entries,
+		Entries:                  entries,
 	}
 
 	if err := w.recorder.SubmitMLNodeWeightDistribution(msg); err != nil {
diff --git a/decentralized-api/poc/early_guard.go b/decentralized-api/poc/early_guard.go
new file mode 100644
index 0000000000..24a9e31587
--- /dev/null
+++ b/decentralized-api/poc/early_guard.go
@@ -0,0 +1,505 @@
+package poc
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"sort"
+	"strconv"
+	"sync"
+
+	"decentralized-api/logging"
+	"decentralized-api/poc/earlyshare"
+
+	grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
+	"github.com/productscience/inference/x/inference/types"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+// earlyShareQueryClient is the subset of the inference query client the guard
+// needs for capture. Implemented by the client returned from
+// CosmosMessageClient.NewInferenceQueryClient().
+type earlyShareQueryClient interface {
+	AllPoCV2StoreCommitsForStage(ctx context.Context, in *types.QueryAllPoCV2StoreCommitsForStageRequest, opts ...grpc.CallOption) (*types.QueryAllPoCV2StoreCommitsForStageResponse, error)
+}
+
+// earlyShareStore is the subset of *earlyshare.Store used by the guard. It is an
+// interface so the guard can be unit-tested with a fake store.
+type earlyShareStore interface {
+	HasCompletedCapture(ctx context.Context, stageHeight int64) (bool, error)
+	UpsertCheckpoints(ctx context.Context, checkpoints []earlyshare.Checkpoint) error
+	MarkStageCaptured(ctx context.Context, stageHeight int64, target, capturedAt int64, perModelCounts map[string]int) error
+	MarkCaptureRun(ctx context.Context, stageHeight int64, modelID string, target, capturedAt int64, count int, status string) error
+	GetCheckpoints(ctx context.Context, stageHeight int64) ([]earlyshare.Checkpoint, error)
+	GetGuardState(ctx context.Context, participant, modelID string) (earlyshare.GuardState, bool, error)
+	UpsertGuardState(ctx context.Context, st earlyshare.GuardState) error
+	DeleteStage(ctx context.Context, stageHeight int64) error
+}
+
+// EarlyShareGuard ties the early-share config, local store, and the validation
+// path together. A nil *EarlyShareGuard is a valid disabled guard.
+type EarlyShareGuard struct {
+	cfg   earlyshare.Config
+	store earlyShareStore
+
+	// captureMu collapses concurrent capture attempts for the retry window
+	// (the dispatcher may fire MaybeCapture on every block past the target).
+	captureMu sync.Mutex
+}
+
+// NewEarlyShareGuard builds a guard. Returns nil when the config is disabled or
+// the store is nil so callers can treat it as a no-op.
+func NewEarlyShareGuard(cfg earlyshare.Config, store earlyShareStore) *EarlyShareGuard {
+	cfg = cfg.Normalized()
+	if !cfg.Enabled() || store == nil {
+		return nil
+	}
+	return &EarlyShareGuard{
+		cfg:   cfg,
+		store: store,
+	}
+}
+
+// Enabled reports whether the guard is active.
+func (g *EarlyShareGuard) Enabled() bool {
+	return g != nil && g.cfg.Enabled()
+}
+
+// FirstFraction returns the configured first-window fraction.
+func (g *EarlyShareGuard) FirstFraction() float64 {
+	if g == nil {
+		return earlyshare.DefaultFirstFraction
+	}
+	return g.cfg.FirstFraction
+}
+
+// DeleteStage prunes early-share rows for a stage. Safe on a nil guard.
+func (g *EarlyShareGuard) DeleteStage(ctx context.Context, stageHeight int64) {
+	if g == nil || g.store == nil {
+		return
+	}
+	if err := g.store.DeleteStage(ctx, stageHeight); err != nil {
+		logging.Warn("EarlyShareGuard: failed to prune stage", types.PoC, "stage", stageHeight, "error", err)
+	}
+}
+
+// MaybeCapture captures the early checkpoint for a stage if not already done.
+// It is idempotent: a completed capture (e.g. after a restart) is never
+// repeated, and concurrent attempts collapse to one.
+//
+// The query is pinned to the target block height (x-cosmos-block-height), so
+// the captured snapshot is the consensus state at exactly that height. Every
+// validator capturing the same stage therefore records identical checkpoints,
+// regardless of when in the window its capture actually runs — the capture can
+// be retried on later blocks and still lands on the same snapshot, as long as
+// the queried node retains state for the target height.
+func (g *EarlyShareGuard) MaybeCapture(ctx context.Context, qc earlyShareQueryClient, stageHeight, target, capturedAt int64) {
+	if !g.Enabled() || g.store == nil {
+		return
+	}
+	if !g.captureMu.TryLock() {
+		return // another capture attempt for this process is already running
+	}
+	defer g.captureMu.Unlock()
+
+	done, err := g.store.HasCompletedCapture(ctx, stageHeight)
+	if err != nil {
+		logging.Warn("EarlyShareGuard: capture idempotency check failed", types.PoC, "stage", stageHeight, "error", err)
+		return
+	}
+	if done {
+		return
+	}
+
+	// Pin the query to the target height so all validators see the same state.
+	queryCtx := metadata.AppendToOutgoingContext(ctx,
+		grpctypes.GRPCBlockHeightHeader, strconv.FormatInt(target, 10))
+	queryCtx, cancel := context.WithTimeout(queryCtx, 30*1e9) // 30s
+	defer cancel()
+
+	resp, err := qc.AllPoCV2StoreCommitsForStage(queryCtx, &types.QueryAllPoCV2StoreCommitsForStageRequest{
+		PocStageStartBlockHeight: stageHeight,
+	})
+	if err != nil {
+		logging.Warn("EarlyShareGuard: early capture query failed", types.PoC, "stage", stageHeight, "error", err)
+		_ = g.store.MarkCaptureRun(ctx, stageHeight, "", target, capturedAt, 0, earlyshare.StatusFailed)
+		return
+	}
+
+	checkpoints := make([]earlyshare.Checkpoint, 0, len(resp.Commits))
+	perModel := make(map[string]int)
+	for _, c := range resp.Commits {
+		if c == nil {
+			continue
+		}
+		checkpoints = append(checkpoints, earlyshare.Checkpoint{
+			StageHeight:           stageHeight,
+			ParticipantAddress:    c.ParticipantAddress,
+			ModelID:               c.ModelId,
+			EarlyCount:            c.Count,
+			EarlyRootHash:         c.RootHash,
+			CheckpointBlockHeight: target,
+			CapturedAtBlockHeight: capturedAt,
+		})
+		perModel[c.ModelId]++
+	}
+
+	if len(checkpoints) > 0 {
+		if err := g.store.UpsertCheckpoints(ctx, checkpoints); err != nil {
+			logging.Error("EarlyShareGuard: failed to persist early checkpoints", types.PoC, "stage", stageHeight, "error", err)
+			return
+		}
+	}
+	if err := g.store.MarkStageCaptured(ctx, stageHeight, target, capturedAt, perModel); err != nil {
+		logging.Error("EarlyShareGuard: failed to mark capture run", types.PoC, "stage", stageHeight, "error", err)
+		return
+	}
+	// The digest is a deterministic hash of the whole captured snapshot.
+	// Because the capture query is height-pinned, every validator capturing
+	// this stage must log the same digest; differing digests across
+	// validators indicate capture divergence (version skew, pruned state)
+	// and are the primary observe-mode health signal for the guard.
+	logging.Info("EarlyShareGuard: captured early checkpoints", types.PoC,
+		"stage", stageHeight, "target", target, "capturedAt", capturedAt,
+		"commits", len(checkpoints), "digest", checkpointsDigest(checkpoints))
+}
+
+// checkpointsDigest computes an order-independent digest of a captured
+// checkpoint set: entries are sorted by (participant, model) and hashed.
+func checkpointsDigest(checkpoints []earlyshare.Checkpoint) string {
+	sorted := make([]earlyshare.Checkpoint, len(checkpoints))
+	copy(sorted, checkpoints)
+	sort.Slice(sorted, func(i, j int) bool {
+		if sorted[i].ParticipantAddress != sorted[j].ParticipantAddress {
+			return sorted[i].ParticipantAddress < sorted[j].ParticipantAddress
+		}
+		return sorted[i].ModelID < sorted[j].ModelID
+	})
+
+	h := sha256.New()
+	for _, cp := range sorted {
+		fmt.Fprintf(h, "%s|%s|%d|%x\n", cp.ParticipantAddress, cp.ModelID, cp.EarlyCount, cp.EarlyRootHash)
+	}
+	return hex.EncodeToString(h.Sum(nil)[:8])
+}
+
+// earlyDecision is the precomputed guard outcome for one (participant, model).
+type earlyDecision struct {
+	shareVoteNo      bool
+	requireInclusion bool
+	earlyCount       uint32
+	earlyRoot        []byte
+	finalCount       uint32
+	earlyShare       float64
+	threshold        float64
+}
+
+// guardRuntime carries the per-ValidateAll guard state into the workers.
+type guardRuntime struct {
+	guard             *EarlyShareGuard
+	decisions         map[string]earlyDecision
+	stage             int64
+	validatorPubKey   string
+	samplingBlockHash string
+}
+
+type earlyGuardOutcome int
+
+const (
+	earlyGuardPass earlyGuardOutcome = iota
+	earlyGuardVoteNo
+	earlyGuardRetry
+)
+
+func earlyShareKey(participant, modelID string) string {
+	return participant + "|" + modelID
+}
+
+// Evaluate computes per-participant guard decisions for a stage and advances the
+// miss-streak state for the assigned participants. It returns nil when the guard
+// is disabled or the stage cannot be evaluated (fail open).
+//
+//   - finalCommits: all latest commits for the stage (whole network), used for
+//     the weighted median.
+//   - modelVotingPowers: established per-model voting power from the validation
+//     snapshot (model_id -> participant -> voting power).
+//   - assigned: set of earlyShareKey(participant, model) this validator will
+//     actually validate; only those get decisions and state updates.
+//   - isConfirmation: true when this stage is a confirmation PoC (CPoC). Only a
+//     passing CPoC clears the miss streak; a passing regular PoC does not.
+func (g *EarlyShareGuard) Evaluate(
+	ctx context.Context,
+	stageHeight int64,
+	isConfirmation bool,
+	finalCommits []*types.PoCV2StoreCommitWithAddress,
+	modelVotingPowers map[string]map[string]int64,
+	assigned map[string]bool,
+) map[string]earlyDecision {
+	if !g.Enabled() || g.store == nil {
+		return nil
+	}
+
+	captured, err := g.store.HasCompletedCapture(ctx, stageHeight)
+	if err != nil {
+		logging.Warn("EarlyShareGuard: capture lookup failed; skipping guard", types.PoC, "stage", stageHeight, "error", err)
+		return nil
+	}
+	if !captured {
+		logging.Info("EarlyShareGuard: no early capture for stage; skipping guard", types.PoC, "stage", stageHeight)
+		return nil
+	}
+
+	checkpoints, err := g.store.GetCheckpoints(ctx, stageHeight)
+	if err != nil {
+		logging.Warn("EarlyShareGuard: checkpoint load failed; skipping guard", types.PoC, "stage", stageHeight, "error", err)
+		return nil
+	}
+	cpByKey := make(map[string]earlyshare.Checkpoint, len(checkpoints))
+	for _, c := range checkpoints {
+		cpByKey[earlyShareKey(c.ParticipantAddress, c.ModelID)] = c
+	}
+
+	commitsByModel := make(map[string][]*types.PoCV2StoreCommitWithAddress)
+	for _, c := range finalCommits {
+		if c == nil {
+			continue
+		}
+		commitsByModel[c.ModelId] = append(commitsByModel[c.ModelId], c)
+	}
+
+	decisions := make(map[string]earlyDecision)
+
+	for modelID, commits := range commitsByModel {
+		vp := modelVotingPowers[modelID]
+		var totalVP int64
+		for _, w := range vp {
+			totalVP += w
+		}
+		if len(vp) == 0 || totalVP <= 0 {
+			// No established weighting data for this model: skip (fail open).
+			logging.Info("EarlyShareGuard: no voting power for model; skipping guard for model", types.PoC,
+				"stage", stageHeight, "model", modelID)
+			continue
+		}
+
+		type participantData struct {
+			finalCount       uint32
+			earlyCount       uint32
+			earlyRoot        []byte
+			share            float64
+			requireInclusion bool
+			shareFail        bool
+			excluded         bool
+		}
+		pdata := make(map[string]participantData, len(commits))
+		points := make([]earlyshare.SharePoint, 0, len(commits))
+
+		for _, commit := range commits {
+			addr := commit.ParticipantAddress
+			fc := commit.Count
+			if fc == 0 {
+				pdata[addr] = participantData{excluded: true}
+				continue
+			}
+			cp, hasCP := cpByKey[earlyShareKey(addr, modelID)]
+			d := participantData{finalCount: fc}
+			switch {
+			case !hasCP:
+				// Present in final, absent from early snapshot -> early_share 0.
+				d.earlyCount = 0
+				d.share = 0
+				points = append(points, earlyshare.SharePoint{Share: 0, Weight: vp[addr]})
+			case len(cp.EarlyRootHash) == 0:
+				// Unusable captured data: drop from distribution and skip this
+				// participant entirely (fail open for them).
+				d.excluded = true
+			case cp.EarlyCount > fc:
+				// Invalid: early exceeds final. Not a data point. Share fails;
+				// inclusion proof unavailable.
+				d.earlyCount = cp.EarlyCount
+				d.earlyRoot = cp.EarlyRootHash
+				d.shareFail = true
+			default:
+				d.earlyCount = cp.EarlyCount
+				d.earlyRoot = cp.EarlyRootHash
+				d.share = float64(cp.EarlyCount) / float64(fc)
+				d.requireInclusion = g.cfg.RequireInclusionProof && cp.EarlyCount > 0
+				points = append(points, earlyshare.SharePoint{Share: d.share, Weight: vp[addr]})
+			}
+			pdata[addr] = d
+		}
+
+		median, ok := earlyshare.WeightedMedianShare(points)
+		if !ok {
+			logging.Info("EarlyShareGuard: no positive-weight data points; skipping guard for model", types.PoC,
+				"stage", stageHeight, "model", modelID)
+			continue
+		}
+		threshold := median * g.cfg.ThresholdRatio
+
+		for addr, d := range pdata {
+			key := earlyShareKey(addr, modelID)
+			if !assigned[key] || d.excluded {
+				continue
+			}
+
+			passed := !d.shareFail && d.share >= threshold
+
+			prev, _, err := g.store.GetGuardState(ctx, addr, modelID)
+			if err != nil {
+				logging.Warn("EarlyShareGuard: guard-state load failed; skipping participant", types.PoC,
+					"stage", stageHeight, "participant", addr, "model", modelID, "error", err)
+				continue
+			}
+			outcome := earlyshare.ApplyMissStreak(prev, passed, isConfirmation, stageHeight)
+			if err := g.store.UpsertGuardState(ctx, outcome.NewState); err != nil {
+				logging.Warn("EarlyShareGuard: guard-state save failed", types.PoC,
+					"stage", stageHeight, "participant", addr, "model", modelID, "error", err)
+			}
+
+			// Log every low-early-share miss as it happens, including the first
+			// one that is still within grace (does not yet vote no). This makes
+			// observe mode surface low early shares early instead of staying
+			// silent until the miss streak trips. shareFail marks the invalid
+			// early>final case where the share is not a usable data point.
+			if !passed {
+				logging.Info("EarlyShareGuard: low early share miss", types.PoC,
+					"stage", stageHeight,
+					"participant", addr,
+					"modelId", modelID,
+					"earlyShare", d.share,
+					"threshold", threshold,
+					"shareFail", d.shareFail,
+					"consecutiveMisses", outcome.NewState.ConsecutiveMisses,
+					"isConfirmation", isConfirmation,
+					"wouldVoteNo", outcome.VoteNo,
+					"enforcing", g.cfg.Enforcing())
+			}
+
+			decisions[key] = earlyDecision{
+				shareVoteNo:      outcome.VoteNo,
+				requireInclusion: d.requireInclusion,
+				earlyCount:       d.earlyCount,
+				earlyRoot:        d.earlyRoot,
+				finalCount:       d.finalCount,
+				earlyShare:       d.share,
+				threshold:        threshold,
+			}
+		}
+	}
+
+	return decisions
+}
+
+// decide combines the inclusion check (immediate, no grace) with the precomputed
+// low-early-share decision (miss-streak gated).
+func (g *EarlyShareGuard) decide(
+	ctx context.Context,
+	pf proofFetcher,
+	stage int64,
+	work participantWork,
+	dec earlyDecision,
+	validatorPubKey string,
+	samplingBlockHash string,
+) (earlyGuardOutcome, string) {
+	if dec.requireInclusion {
+		outcome, reason := g.checkInclusion(ctx, pf, stage, work, dec, validatorPubKey, samplingBlockHash)
+		if outcome != earlyGuardPass {
+			return outcome, reason
+		}
+	}
+	if dec.shareVoteNo {
+		return earlyGuardVoteNo, fmt.Sprintf("low_early_share early_share=%.4f threshold=%.4f", dec.earlyShare, dec.threshold)
+	}
+	return earlyGuardPass, ""
+}
+
+// checkInclusion verifies that sampled early artifacts are present unchanged in
+// the final commitment. Cryptographic mismatches are hard failures; transient
+// network errors ask the validator to retry in enforce mode.
+func (g *EarlyShareGuard) checkInclusion(
+	ctx context.Context,
+	pf proofFetcher,
+	stage int64,
+	work participantWork,
+	dec earlyDecision,
+	validatorPubKey string,
+	samplingBlockHash string,
+) (earlyGuardOutcome, string) {
+	if dec.earlyCount == 0 || len(dec.earlyRoot) == 0 {
+		return earlyGuardPass, "" // nothing to compare; handled elsewhere
+	}
+	leafIndices := sampleLeafIndices(
+		validatorPubKey,
+		samplingBlockHash,
+		stage,
+		work.modelId+"|early-inclusion",
+		dec.earlyCount,
+		g.cfg.InclusionSampleSize,
+	)
+	if len(leafIndices) == 0 {
+		return earlyGuardPass, ""
+	}
+
+	earlyProofs, err := pf.FetchAndVerifyProofs(ctx, work.url, ProofRequest{
+		PocStageStartBlockHeight: stage,
+		ModelId:                  work.modelId,
+		RootHash:                 dec.earlyRoot,
+		Count:                    dec.earlyCount,
+		LeafIndices:              leafIndices,
+		ParticipantAddress:       work.address,
+	})
+	if err != nil {
+		if isPermanentProofError(err) {
+			return earlyGuardVoteNo, fmt.Sprintf("inclusion_early_proof_invalid: %v", err)
+		}
+		logging.Debug("EarlyShareGuard: early inclusion proof unavailable (transient)", types.PoC,
+			"participant", work.address, "error", err)
+		return earlyGuardRetry, fmt.Sprintf("inclusion_early_proof_unavailable: %v", err)
+	}
+	// Coverage, duplicate response items, and proof validity are enforced by the
+	// proof fetchers. The guard only checks the cross-root invariant: same nonce,
+	// same vector in the final tree.
+	earlyByNonce := make(map[int32]VerifiedArtifact, len(earlyProofs))
+	nonces := make([]int32, 0, len(earlyProofs))
+	for _, artifact := range earlyProofs {
+		earlyByNonce[artifact.Nonce] = artifact
+		nonces = append(nonces, artifact.Nonce)
+	}
+
+	finalProofs, err := pf.FetchAndVerifyProofsByNonce(ctx, work.url, ProofByNonceRequest{
+		PocStageStartBlockHeight: stage,
+		ModelId:                  work.modelId,
+		RootHash:                 work.rootHash,
+		Count:                    work.count,
+		Nonces:                   nonces,
+		ParticipantAddress:       work.address,
+	})
+	if err != nil {
+		if isPermanentProofError(err) {
+			return earlyGuardVoteNo, fmt.Sprintf("inclusion_final_proof_invalid: %v", err)
+		}
+		logging.Debug("EarlyShareGuard: final by-nonce inclusion proof unavailable (transient)", types.PoC,
+			"participant", work.address, "error", err)
+		return earlyGuardRetry, fmt.Sprintf("inclusion_final_proof_unavailable: %v", err)
+	}
+
+	for _, finalArtifact := range finalProofs {
+		earlyArtifact := earlyByNonce[finalArtifact.Nonce]
+		if finalArtifact.VectorB64 != earlyArtifact.VectorB64 {
+			return earlyGuardVoteNo, fmt.Sprintf("inclusion_vector_mismatch nonce=%d", finalArtifact.Nonce)
+		}
+	}
+
+	return earlyGuardPass, ""
+}
+
+func isPermanentProofError(err error) bool {
+	return errors.Is(err, ErrProofVerificationFailed) ||
+		errors.Is(err, ErrIncompleteCoverage) ||
+		errors.Is(err, ErrNonceAbsent) ||
+		errors.Is(err, ErrInvalidVectorData)
+}
diff --git a/decentralized-api/poc/early_guard_test.go b/decentralized-api/poc/early_guard_test.go
new file mode 100644
index 0000000000..a077704cdc
--- /dev/null
+++ b/decentralized-api/poc/early_guard_test.go
@@ -0,0 +1,545 @@
+package poc
+
+import (
+	"context"
+	"testing"
+
+	"decentralized-api/chainphase"
+	"decentralized-api/poc/earlyshare"
+
+	grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
+	"github.com/productscience/inference/x/inference/types"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+func TestEarlyShareCaptureTarget(t *testing.T) {
+	mkState := func(phase types.EpochPhase, pocStart int64, dur int64) *chainphase.EpochState {
+		return &chainphase.EpochState{
+			IsSynced:     true,
+			CurrentPhase: phase,
+			LatestEpoch: types.EpochContext{
+				PocStartBlockHeight: pocStart,
+				EpochParams:         types.EpochParams{PocStageDuration: dur},
+			},
+		}
+	}
+
+	t.Run("regular poc generation", func(t *testing.T) {
+		st := mkState(types.PoCGeneratePhase, 1000, 30)
+		stage, target, ok := EarlyShareCaptureTarget(st, 1.0/3.0)
+		if !ok {
+			t.Fatal("expected ok")
+		}
+		if stage != 1000 {
+			t.Fatalf("stage = %d, want 1000", stage)
+		}
+		if target != 1010 { // 1000 + floor(30/3)
+			t.Fatalf("target = %d, want 1010", target)
+		}
+	})
+
+	t.Run("wind-down still captures", func(t *testing.T) {
+		st := mkState(types.PoCGenerateWindDownPhase, 1000, 30)
+		_, _, ok := EarlyShareCaptureTarget(st, 1.0/3.0)
+		if !ok {
+			t.Fatal("wind-down should still allow capture")
+		}
+	})
+
+	t.Run("non-generation phase skips", func(t *testing.T) {
+		st := mkState(types.PoCValidatePhase, 1000, 30)
+		if _, _, ok := EarlyShareCaptureTarget(st, 1.0/3.0); ok {
+			t.Fatal("validate phase must not capture")
+		}
+	})
+
+	t.Run("nil/not synced skips", func(t *testing.T) {
+		if _, _, ok := EarlyShareCaptureTarget(nil, 1.0/3.0); ok {
+			t.Fatal("nil must skip")
+		}
+		st := mkState(types.PoCGeneratePhase, 1000, 30)
+		st.IsSynced = false
+		if _, _, ok := EarlyShareCaptureTarget(st, 1.0/3.0); ok {
+			t.Fatal("not synced must skip")
+		}
+	})
+
+	t.Run("invalid fraction or duration skips", func(t *testing.T) {
+		if _, _, ok := EarlyShareCaptureTarget(mkState(types.PoCGeneratePhase, 1000, 0), 1.0/3.0); ok {
+			t.Fatal("zero duration must skip")
+		}
+		if _, _, ok := EarlyShareCaptureTarget(mkState(types.PoCGeneratePhase, 1000, 30), 0); ok {
+			t.Fatal("zero fraction must skip")
+		}
+	})
+
+	t.Run("fraction arithmetic is integer-deterministic", func(t *testing.T) {
+		// Different float spellings of "one third" (the code default, the
+		// documented config literal, a hand-typed shorter one) must quantize
+		// to the same ppm and produce the identical target height for any
+		// duration. This is what pins all validators to the same capture
+		// block.
+		spellings := []float64{1.0 / 3.0, 0.3333333333, 0.333333}
+		for _, dur := range []int64{30, 100, 720, 7201, 99999} {
+			want := int64(-1)
+			for _, f := range spellings {
+				_, target, ok := EarlyShareCaptureTarget(mkState(types.PoCGeneratePhase, 1000, dur), f)
+				if !ok {
+					t.Fatalf("fraction %v duration %d: expected ok", f, dur)
+				}
+				if want == -1 {
+					want = target
+				} else if target != want {
+					t.Fatalf("fraction %v duration %d: target %d differs from %d", f, dur, target, want)
+				}
+			}
+			// offset = round(dur * 333333 / 1e6), pure integer arithmetic.
+			expected := 1000 + (dur*333333+500000)/1000000
+			if want != expected {
+				t.Fatalf("duration %d: target %d, want %d", dur, want, expected)
+			}
+		}
+	})
+
+	t.Run("confirmation poc generation", func(t *testing.T) {
+		st := mkState(types.InferencePhase, 1000, 30)
+		st.ActiveConfirmationPoCEvent = &types.ConfirmationPoCEvent{
+			Phase:                 types.ConfirmationPoCPhase_CONFIRMATION_POC_GENERATION,
+			TriggerHeight:         5000,
+			GenerationStartHeight: 5002,
+		}
+		stage, target, ok := EarlyShareCaptureTarget(st, 1.0/3.0)
+		if !ok {
+			t.Fatal("expected ok for CPoC")
+		}
+		if stage != 5000 {
+			t.Fatalf("stage = %d, want 5000", stage)
+		}
+		if target != 5012 { // 5002 + 10
+			t.Fatalf("target = %d, want 5012", target)
+		}
+	})
+}
+
+// fakeStore is an in-memory earlyShareStore for Evaluate tests.
+type fakeStore struct {
+	captured    map[int64]bool
+	checkpoints map[int64][]earlyshare.Checkpoint
+	state       map[string]earlyshare.GuardState
+}
+
+func newFakeStore() *fakeStore {
+	return &fakeStore{
+		captured:    map[int64]bool{},
+		checkpoints: map[int64][]earlyshare.Checkpoint{},
+		state:       map[string]earlyshare.GuardState{},
+	}
+}
+
+func (f *fakeStore) HasCompletedCapture(_ context.Context, stage int64) (bool, error) {
+	return f.captured[stage], nil
+}
+func (f *fakeStore) UpsertCheckpoints(_ context.Context, cps []earlyshare.Checkpoint) error {
+	for _, c := range cps {
+		f.checkpoints[c.StageHeight] = append(f.checkpoints[c.StageHeight], c)
+	}
+	return nil
+}
+func (f *fakeStore) MarkStageCaptured(_ context.Context, stage int64, _, _ int64, _ map[string]int) error {
+	f.captured[stage] = true
+	return nil
+}
+func (f *fakeStore) MarkCaptureRun(_ context.Context, _ int64, _ string, _, _ int64, _ int, _ string) error {
+	return nil
+}
+func (f *fakeStore) GetCheckpoints(_ context.Context, stage int64) ([]earlyshare.Checkpoint, error) {
+	return f.checkpoints[stage], nil
+}
+func (f *fakeStore) GetGuardState(_ context.Context, p, m string) (earlyshare.GuardState, bool, error) {
+	st, ok := f.state[p+"|"+m]
+	if !ok {
+		return earlyshare.GuardState{ParticipantAddress: p, ModelID: m}, false, nil
+	}
+	return st, true, nil
+}
+func (f *fakeStore) UpsertGuardState(_ context.Context, st earlyshare.GuardState) error {
+	f.state[st.ParticipantAddress+"|"+st.ModelID] = st
+	return nil
+}
+func (f *fakeStore) DeleteStage(_ context.Context, stage int64) error {
+	delete(f.checkpoints, stage)
+	delete(f.captured, stage)
+	return nil
+}
+
+func TestEvaluate(t *testing.T) {
+	ctx := context.Background()
+	const stage = int64(1000)
+	const model = "m1"
+
+	store := newFakeStore()
+	store.captured[stage] = true
+	store.checkpoints[stage] = []earlyshare.Checkpoint{
+		{StageHeight: stage, ParticipantAddress: "a", ModelID: model, EarlyCount: 10, EarlyRootHash: []byte{1}},
+		{StageHeight: stage, ParticipantAddress: "b", ModelID: model, EarlyCount: 90, EarlyRootHash: []byte{2}},
+		// c has no early checkpoint -> early_share 0
+	}
+	// Seed c with one grace miss already used so a fresh fail votes no.
+	store.state["c|"+model] = earlyshare.GuardState{ParticipantAddress: "c", ModelID: model, ConsecutiveMisses: 1}
+
+	guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeEnforce, RequireInclusionProof: true}, store)
+	if guard == nil {
+		t.Fatal("guard should be constructed")
+	}
+
+	finalCommits := []*types.PoCV2StoreCommitWithAddress{
+		{ParticipantAddress: "a", ModelId: model, Count: 100, RootHash: []byte{0xaa}},
+		{ParticipantAddress: "b", ModelId: model, Count: 100, RootHash: []byte{0xbb}},
+		{ParticipantAddress: "c", ModelId: model, Count: 100, RootHash: []byte{0xcc}},
+	}
+	votingPowers := map[string]map[string]int64{
+		model: {"a": 10, "b": 10, "c": 10},
+	}
+	// Validate a (passing) and c (failing) only.
+	assigned := map[string]bool{
+		earlyShareKey("a", model): true,
+		earlyShareKey("c", model): true,
+	}
+
+	// Evaluate as a CPoC stage so a's pass advances guard state.
+	decisions := guard.Evaluate(ctx, stage, true, finalCommits, votingPowers, assigned)
+
+	// shares: a=0.1, b=0.9, c=0. Weighted median (equal weights) -> 0.1.
+	// threshold = 0.1 * 0.5 = 0.05.
+	decA, okA := decisions[earlyShareKey("a", model)]
+	if !okA {
+		t.Fatal("missing decision for a")
+	}
+	if decA.shareVoteNo {
+		t.Fatalf("a should pass (share 0.1 >= 0.05); got vote no")
+	}
+	if !decA.requireInclusion {
+		t.Fatal("a has early_count>0 so inclusion should be required")
+	}
+
+	decC, okC := decisions[earlyShareKey("c", model)]
+	if !okC {
+		t.Fatal("missing decision for c")
+	}
+	if !decC.shareVoteNo {
+		t.Fatal("c should vote no (share 0 < 0.05, after grace already used)")
+	}
+	if decC.requireInclusion {
+		t.Fatal("c has early_count 0 so inclusion must not be required")
+	}
+
+	// b was not assigned -> no decision, but its share still informed the median.
+	if _, ok := decisions[earlyShareKey("b", model)]; ok {
+		t.Fatal("b should not have a decision (not assigned)")
+	}
+
+	// a's guard state should now reflect a CPoC pass (streak reset).
+	if st := store.state["a|"+model]; st.ConsecutiveMisses != 0 {
+		t.Fatalf("a state not reset by CPoC pass: %+v", st)
+	}
+}
+
+// TestEvaluatePoCPassDoesNotAdvance verifies that a passing regular PoC stage
+// does not reset the miss streak (only a CPoC pass does).
+func TestEvaluatePoCPassDoesNotAdvance(t *testing.T) {
+	ctx := context.Background()
+	const stage = int64(2000)
+	const model = "m1"
+
+	store := newFakeStore()
+	store.captured[stage] = true
+	store.checkpoints[stage] = []earlyshare.Checkpoint{
+		{StageHeight: stage, ParticipantAddress: "a", ModelID: model, EarlyCount: 50, EarlyRootHash: []byte{1}},
+	}
+	// Seed a with one grace miss already used.
+	store.state["a|"+model] = earlyshare.GuardState{ParticipantAddress: "a", ModelID: model, ConsecutiveMisses: 1}
+
+	guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeObserve}, store)
+	finalCommits := []*types.PoCV2StoreCommitWithAddress{
+		{ParticipantAddress: "a", ModelId: model, Count: 100, RootHash: []byte{0xaa}},
+	}
+	votingPowers := map[string]map[string]int64{model: {"a": 10}}
+	assigned := map[string]bool{earlyShareKey("a", model): true}
+
+	// Regular PoC (isConfirmation=false): a passes (share 0.5 >= threshold) but
+	// the pass must NOT reset the streak.
+	guard.Evaluate(ctx, stage, false, finalCommits, votingPowers, assigned)
+	if st := store.state["a|"+model]; st.ConsecutiveMisses != 1 {
+		t.Fatalf("PoC pass must not reset streak: %+v", st)
+	}
+}
+
+func TestEvaluateSkipsWhenNotCaptured(t *testing.T) {
+	store := newFakeStore() // nothing captured
+	guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeObserve}, store)
+	got := guard.Evaluate(context.Background(), 1000, false, nil, nil, nil)
+	if got != nil {
+		t.Fatalf("expected nil decisions when stage not captured, got %v", got)
+	}
+}
+
+func TestNewEarlyShareGuardDisabled(t *testing.T) {
+	if g := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeDisabled}, newFakeStore()); g != nil {
+		t.Fatal("disabled config should yield nil guard")
+	}
+	if g := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeObserve}, nil); g != nil {
+		t.Fatal("nil store should yield nil guard")
+	}
+}
+
+// fakeESQueryClient implements earlyShareQueryClient for MaybeCapture tests.
+type fakeESQueryClient struct {
+	resp    *types.QueryAllPoCV2StoreCommitsForStageResponse
+	err     error
+	calls   int
+	lastCtx context.Context
+}
+
+func (f *fakeESQueryClient) AllPoCV2StoreCommitsForStage(ctx context.Context, _ *types.QueryAllPoCV2StoreCommitsForStageRequest, _ ...grpc.CallOption) (*types.QueryAllPoCV2StoreCommitsForStageResponse, error) {
+	f.calls++
+	f.lastCtx = ctx
+	return f.resp, f.err
+}
+
+func TestMaybeCapture(t *testing.T) {
+	ctx := context.Background()
+	const stage = int64(1000)
+
+	t.Run("captures once then is idempotent", func(t *testing.T) {
+		store := newFakeStore()
+		guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeObserve}, store)
+		qc := &fakeESQueryClient{resp: &types.QueryAllPoCV2StoreCommitsForStageResponse{
+			Commits: []*types.PoCV2StoreCommitWithAddress{
+				{ParticipantAddress: "a", ModelId: "m1", Count: 10, RootHash: []byte{1}},
+				{ParticipantAddress: "b", ModelId: "m1", Count: 20, RootHash: []byte{2}},
+			},
+		}}
+
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1010)
+		if qc.calls != 1 {
+			t.Fatalf("expected 1 query call, got %d", qc.calls)
+		}
+		if got := len(store.checkpoints[stage]); got != 2 {
+			t.Fatalf("expected 2 checkpoints stored, got %d", got)
+		}
+		if !store.captured[stage] {
+			t.Fatal("stage should be marked captured")
+		}
+
+		// Second call must not re-query (HasCompletedCapture is true).
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1010)
+		if qc.calls != 1 {
+			t.Fatalf("expected no extra query call, got %d", qc.calls)
+		}
+	})
+
+	t.Run("query error fails open (no capture recorded)", func(t *testing.T) {
+		store := newFakeStore()
+		guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeEnforce}, store)
+		qc := &fakeESQueryClient{err: context.DeadlineExceeded}
+
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1010)
+		if store.captured[stage] {
+			t.Fatal("stage must not be marked captured on query error")
+		}
+		if len(store.checkpoints[stage]) != 0 {
+			t.Fatal("no checkpoints should be stored on query error")
+		}
+	})
+
+	t.Run("disabled guard is a no-op", func(t *testing.T) {
+		var guard *EarlyShareGuard // nil == disabled
+		qc := &fakeESQueryClient{}
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1010)
+		if qc.calls != 0 {
+			t.Fatalf("disabled guard must not query, got %d calls", qc.calls)
+		}
+	})
+
+	t.Run("query is pinned to the target height", func(t *testing.T) {
+		store := newFakeStore()
+		guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeObserve}, store)
+		qc := &fakeESQueryClient{resp: &types.QueryAllPoCV2StoreCommitsForStageResponse{}}
+
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1042)
+		if qc.calls != 1 {
+			t.Fatalf("expected 1 query call, got %d", qc.calls)
+		}
+		md, ok := metadata.FromOutgoingContext(qc.lastCtx)
+		if !ok {
+			t.Fatal("capture query context missing outgoing metadata")
+		}
+		heights := md.Get(grpctypes.GRPCBlockHeightHeader)
+		if len(heights) != 1 || heights[0] != "1010" {
+			t.Fatalf("expected height header pinned to 1010, got %v", heights)
+		}
+	})
+
+	t.Run("failed capture can be retried on a later block", func(t *testing.T) {
+		store := newFakeStore()
+		guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeObserve}, store)
+		qc := &fakeESQueryClient{err: context.DeadlineExceeded}
+
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1010)
+		if store.captured[stage] {
+			t.Fatal("stage must not be marked captured on query error")
+		}
+
+		// Retry a few blocks later succeeds and still pins the original target.
+		qc.err = nil
+		qc.resp = &types.QueryAllPoCV2StoreCommitsForStageResponse{
+			Commits: []*types.PoCV2StoreCommitWithAddress{
+				{ParticipantAddress: "a", ModelId: "m1", Count: 10, RootHash: []byte{1}},
+			},
+		}
+		guard.MaybeCapture(ctx, qc, stage, 1010, 1013)
+		if !store.captured[stage] {
+			t.Fatal("stage should be marked captured after retry")
+		}
+		md, _ := metadata.FromOutgoingContext(qc.lastCtx)
+		if got := md.Get(grpctypes.GRPCBlockHeightHeader); len(got) != 1 || got[0] != "1010" {
+			t.Fatalf("retry must pin the original target height, got %v", got)
+		}
+	})
+}
+
+// scriptedProofFetcher returns artifacts/errors keyed by the request root hash so
+// the early vs final commitments can be distinguished.
+type scriptedProofFetcher struct {
+	byRoot map[string]struct {
+		arts []VerifiedArtifact
+		err  error
+	}
+	byNonce map[string]struct {
+		arts []VerifiedArtifact
+		err  error
+	}
+	calls      int
+	nonceCalls int
+}
+
+func (s *scriptedProofFetcher) FetchAndVerifyProofs(_ context.Context, _ string, req ProofRequest) ([]VerifiedArtifact, error) {
+	s.calls++
+	r, ok := s.byRoot[string(req.RootHash)]
+	if !ok {
+		return nil, nil
+	}
+	return r.arts, r.err
+}
+
+func (s *scriptedProofFetcher) FetchAndVerifyProofsByNonce(_ context.Context, _ string, req ProofByNonceRequest) ([]VerifiedArtifact, error) {
+	s.nonceCalls++
+	r, ok := s.byNonce[string(req.RootHash)]
+	if !ok {
+		return nil, nil
+	}
+	return r.arts, r.err
+}
+
+func TestDecide(t *testing.T) {
+	ctx := context.Background()
+	const stage = int64(1000)
+	guard := NewEarlyShareGuard(earlyshare.Config{Mode: earlyshare.ModeEnforce, RequireInclusionProof: true, InclusionSampleSize: 1}, newFakeStore())
+
+	finalRoot := []byte{0xaa}
+	earlyRoot := []byte{0xee}
+	work := participantWork{address: "a", modelId: "m1", count: 100, url: "http://p", rootHash: finalRoot}
+
+	mkFetcher := func(earlyArt, finalArt VerifiedArtifact, earlyErr, finalErr error) *scriptedProofFetcher {
+		f := &scriptedProofFetcher{byRoot: map[string]struct {
+			arts []VerifiedArtifact
+			err  error
+		}{}, byNonce: map[string]struct {
+			arts []VerifiedArtifact
+			err  error
+		}{}}
+		f.byRoot[string(earlyRoot)] = struct {
+			arts []VerifiedArtifact
+			err  error
+		}{arts: []VerifiedArtifact{earlyArt}, err: earlyErr}
+		f.byNonce[string(finalRoot)] = struct {
+			arts []VerifiedArtifact
+			err  error
+		}{arts: []VerifiedArtifact{finalArt}, err: finalErr}
+		return f
+	}
+
+	inclusionDec := earlyDecision{requireInclusion: true, earlyCount: 10, earlyRoot: earlyRoot, finalCount: 100, earlyShare: 0.1, threshold: 0.05}
+
+	t.Run("matching inclusion and passing share -> pass", func(t *testing.T) {
+		art := VerifiedArtifact{LeafIndex: 3, Nonce: 7, VectorB64: "vec"}
+		f := mkFetcher(art, art, nil, nil)
+		outcome, reason := guard.decide(ctx, f, stage, work, inclusionDec, "pub", "hash")
+		if outcome != earlyGuardPass {
+			t.Fatalf("expected pass, got %v: %s", outcome, reason)
+		}
+	})
+
+	t.Run("vector mismatch -> immediate vote no", func(t *testing.T) {
+		f := mkFetcher(
+			VerifiedArtifact{LeafIndex: 3, Nonce: 7, VectorB64: "early-vec"},
+			VerifiedArtifact{LeafIndex: 9, Nonce: 7, VectorB64: "final-vec"},
+			nil,
+			nil,
+		)
+		outcome, reason := guard.decide(ctx, f, stage, work, inclusionDec, "pub", "hash")
+		if outcome != earlyGuardVoteNo {
+			t.Fatal("vector mismatch must vote no")
+		}
+		if reason == "" {
+			t.Fatal("expected mismatch reason")
+		}
+	})
+
+	t.Run("early proof permanent error -> immediate vote no", func(t *testing.T) {
+		art := VerifiedArtifact{LeafIndex: 3, Nonce: 7, VectorB64: "vec"}
+		f := mkFetcher(art, art, ErrProofVerificationFailed, nil)
+		outcome, _ := guard.decide(ctx, f, stage, work, inclusionDec, "pub", "hash")
+		if outcome != earlyGuardVoteNo {
+			t.Fatal("permanent early-proof error must vote no")
+		}
+	})
+
+	t.Run("low share with no inclusion requirement -> vote no via miss streak", func(t *testing.T) {
+		f := mkFetcher(VerifiedArtifact{}, VerifiedArtifact{}, nil, nil)
+		dec := earlyDecision{shareVoteNo: true, requireInclusion: false, earlyShare: 0.01, threshold: 0.05}
+		outcome, reason := guard.decide(ctx, f, stage, work, dec, "pub", "hash")
+		if outcome != earlyGuardVoteNo {
+			t.Fatal("shareVoteNo should vote no")
+		}
+		if f.calls != 0 {
+			t.Fatalf("no inclusion required, fetcher should not be called; got %d", f.calls)
+		}
+		if reason == "" {
+			t.Fatal("expected a low_early_share reason")
+		}
+	})
+
+	t.Run("transient early-proof error requests retry", func(t *testing.T) {
+		art := VerifiedArtifact{LeafIndex: 3, Nonce: 7, VectorB64: "vec"}
+		f := mkFetcher(art, art, context.DeadlineExceeded, nil)
+		dec := inclusionDec
+		dec.shareVoteNo = false
+		outcome, reason := guard.decide(ctx, f, stage, work, dec, "pub", "hash")
+		if outcome != earlyGuardRetry {
+			t.Fatalf("transient early-proof error must retry, got %v: %s", outcome, reason)
+		}
+	})
+
+	t.Run("transient final by-nonce error requests retry", func(t *testing.T) {
+		art := VerifiedArtifact{LeafIndex: 3, Nonce: 7, VectorB64: "vec"}
+		f := mkFetcher(art, art, nil, context.DeadlineExceeded)
+		dec := inclusionDec
+		dec.shareVoteNo = false
+		outcome, reason := guard.decide(ctx, f, stage, work, dec, "pub", "hash")
+		if outcome != earlyGuardRetry {
+			t.Fatalf("transient by-nonce error must retry, got %v: %s", outcome, reason)
+		}
+	})
+}
diff --git a/decentralized-api/poc/earlyshare/config.go b/decentralized-api/poc/earlyshare/config.go
new file mode 100644
index 0000000000..6052d12651
--- /dev/null
+++ b/decentralized-api/poc/earlyshare/config.go
@@ -0,0 +1,74 @@
+package earlyshare
+
+// Mode controls how the early-share guard behaves.
+type Mode string
+
+const (
+	// ModeDisabled performs no capture and has no validation effect.
+	ModeDisabled Mode = "disabled"
+	// ModeObserve captures checkpoints and logs pass/fail decisions but never
+	// changes the vote.
+	ModeObserve Mode = "observe"
+	// ModeEnforce votes no after the miss-streak rule triggers or the early
+	// inclusion proof check fails.
+	ModeEnforce Mode = "enforce"
+)
+
+// Config holds the runtime configuration for the early-share guard.
+type Config struct {
+	Mode                  Mode
+	FirstFraction         float64
+	ThresholdRatio        float64
+	RequireInclusionProof bool
+	InclusionSampleSize   int
+}
+
+// Defaults for the guard. The guard ships in enforce mode; operators can opt
+// out by explicitly setting mode to "observe" or "disabled" in the DAPI config.
+const (
+	DefaultFirstFraction       = 1.0 / 3.0
+	DefaultThresholdRatio      = 0.5
+	DefaultInclusionSampleSize = 5
+)
+
+// DefaultConfig returns the enforce-by-default configuration.
+func DefaultConfig() Config {
+	return Config{
+		Mode:                  ModeEnforce,
+		FirstFraction:         DefaultFirstFraction,
+		ThresholdRatio:        DefaultThresholdRatio,
+		RequireInclusionProof: true,
+		InclusionSampleSize:   DefaultInclusionSampleSize,
+	}
+}
+
+// Normalized fills zero/invalid fields with defaults and clamps ranges.
+func (c Config) Normalized() Config {
+	out := c
+	switch out.Mode {
+	case ModeObserve, ModeEnforce, ModeDisabled:
+		// keep
+	default:
+		out.Mode = ModeDisabled
+	}
+	if out.FirstFraction <= 0 || out.FirstFraction >= 1 {
+		out.FirstFraction = DefaultFirstFraction
+	}
+	if out.ThresholdRatio <= 0 {
+		out.ThresholdRatio = DefaultThresholdRatio
+	}
+	if out.InclusionSampleSize <= 0 {
+		out.InclusionSampleSize = DefaultInclusionSampleSize
+	}
+	return out
+}
+
+// Enabled reports whether the guard should capture and evaluate.
+func (c Config) Enabled() bool {
+	return c.Mode == ModeObserve || c.Mode == ModeEnforce
+}
+
+// Enforcing reports whether failing decisions should actually change the vote.
+func (c Config) Enforcing() bool {
+	return c.Mode == ModeEnforce
+}
diff --git a/decentralized-api/poc/earlyshare/config_test.go b/decentralized-api/poc/earlyshare/config_test.go
new file mode 100644
index 0000000000..dce359f165
--- /dev/null
+++ b/decentralized-api/poc/earlyshare/config_test.go
@@ -0,0 +1,76 @@
+package earlyshare
+
+import (
+	"math"
+	"testing"
+)
+
+func TestDefaultConfigEnforces(t *testing.T) {
+	// The guard must be active in enforce mode on nodes that upgrade the
+	// binary without touching their config. Opting out requires an explicit
+	// mode override.
+	got := DefaultConfig()
+	if got.Mode != ModeEnforce {
+		t.Fatalf("mode = %q, want enforce", got.Mode)
+	}
+	if !got.Normalized().Enforcing() {
+		t.Fatal("default config must survive normalization as enforcing")
+	}
+}
+
+func TestConfigNormalized(t *testing.T) {
+	t.Run("zero value disables and applies defaults", func(t *testing.T) {
+		got := Config{}.Normalized()
+		if got.Mode != ModeDisabled {
+			t.Fatalf("mode = %q, want disabled", got.Mode)
+		}
+		if math.Abs(got.FirstFraction-DefaultFirstFraction) > 1e-9 {
+			t.Fatalf("first fraction = %v, want %v", got.FirstFraction, DefaultFirstFraction)
+		}
+		if got.ThresholdRatio != DefaultThresholdRatio {
+			t.Fatalf("threshold ratio = %v, want %v", got.ThresholdRatio, DefaultThresholdRatio)
+		}
+		if got.InclusionSampleSize != DefaultInclusionSampleSize {
+			t.Fatalf("inclusion sample size = %v, want %v", got.InclusionSampleSize, DefaultInclusionSampleSize)
+		}
+	})
+
+	t.Run("invalid mode falls back to disabled", func(t *testing.T) {
+		got := Config{Mode: "bogus"}.Normalized()
+		if got.Mode != ModeDisabled {
+			t.Fatalf("mode = %q, want disabled", got.Mode)
+		}
+	})
+
+	t.Run("out-of-range fraction reset", func(t *testing.T) {
+		if got := (Config{FirstFraction: 1.5}).Normalized(); got.FirstFraction != DefaultFirstFraction {
+			t.Fatalf("fraction = %v, want default", got.FirstFraction)
+		}
+		if got := (Config{FirstFraction: -0.1}).Normalized(); got.FirstFraction != DefaultFirstFraction {
+			t.Fatalf("fraction = %v, want default", got.FirstFraction)
+		}
+	})
+
+	t.Run("enabled and enforcing flags", func(t *testing.T) {
+		if (Config{Mode: ModeDisabled}).Enabled() {
+			t.Fatal("disabled must not be enabled")
+		}
+		obs := Config{Mode: ModeObserve}
+		if !obs.Enabled() || obs.Enforcing() {
+			t.Fatal("observe must be enabled but not enforcing")
+		}
+		enf := Config{Mode: ModeEnforce}
+		if !enf.Enabled() || !enf.Enforcing() {
+			t.Fatal("enforce must be enabled and enforcing")
+		}
+	})
+
+	t.Run("inclusion sample size default only", func(t *testing.T) {
+		if got := (Config{InclusionSampleSize: -1}).Normalized(); got.InclusionSampleSize != DefaultInclusionSampleSize {
+			t.Fatalf("sample size = %v, want default", got.InclusionSampleSize)
+		}
+		if got := (Config{InclusionSampleSize: 999}).Normalized(); got.InclusionSampleSize != 999 {
+			t.Fatalf("sample size = %v, want explicit value", got.InclusionSampleSize)
+		}
+	})
+}
diff --git a/decentralized-api/poc/earlyshare/decision.go b/decentralized-api/poc/earlyshare/decision.go
new file mode 100644
index 0000000000..eb7708f6ef
--- /dev/null
+++ b/decentralized-api/poc/earlyshare/decision.go
@@ -0,0 +1,101 @@
+package earlyshare
+
+import "sort"
+
+// SharePoint is a single (early_share, weight) data point for the weighted
+// median over a (stage, model_id) distribution.
+type SharePoint struct {
+	Share  float64
+	Weight int64
+}
+
+// WeightedMedianShare returns the early_share value at which cumulative weight
+// crosses half of the total weight. Points are sorted by share ascending and
+// their weights accumulated. Points with non-positive weight do not move the
+// median but are otherwise ignored. Returns (0, false) when there is no
+// positive total weight.
+func WeightedMedianShare(points []SharePoint) (float64, bool) {
+	var total int64
+	filtered := make([]SharePoint, 0, len(points))
+	for _, p := range points {
+		if p.Weight <= 0 {
+			continue
+		}
+		filtered = append(filtered, p)
+		total += p.Weight
+	}
+	if total <= 0 || len(filtered) == 0 {
+		return 0, false
+	}
+
+	sort.SliceStable(filtered, func(i, j int) bool {
+		return filtered[i].Share < filtered[j].Share
+	})
+
+	// half is the smallest cumulative weight that reaches the median crossing.
+	// Using a strict "> total/2" with rational comparison (2*cum >= total)
+	// keeps behavior deterministic for even totals and ties.
+	var cum int64
+	for _, p := range filtered {
+		cum += p.Weight
+		if 2*cum >= total {
+			return p.Share, true
+		}
+	}
+	// Unreachable when total > 0, but return the last share defensively.
+	return filtered[len(filtered)-1].Share, true
+}
+
+// MissOutcome is the result of applying the miss-streak state machine.
+type MissOutcome struct {
+	// VoteNo is true when the participant should be voted no for low early
+	// share (subject to the caller's mode gating).
+	VoteNo bool
+	// NewState is the guard state to persist.
+	NewState GuardState
+}
+
+// ApplyMissStreak runs the one-miss-grace state machine.
+//
+// Asymmetry between PoC and CPoC: regular PoC early-share is cheap to fake, so a
+// passing PoC round is NOT trusted to clear the streak. Only a passing
+// confirmation PoC (CPoC) resets it. Failures count the same in either phase.
+//
+//   - pass and isConfirmation: consecutive_misses=0, no vote. A genuine CPoC
+//     pass resets the streak.
+//   - pass and !isConfirmation: no vote and no state change. A regular PoC pass
+//     does not reset the streak (passes are cheap to fake).
+//   - fail (either phase): consecutive_misses += 1; allow one grace miss
+//     (consecutive_misses == 1, no vote), then vote no once
+//     consecutive_misses >= 2.
+//
+// Re-applying the same stage is idempotent: a restart mid-validation re-runs
+// Evaluate for the stage, and counting the same miss twice would silently burn
+// the grace miss. When the persisted state was already updated for this stage,
+// the previous outcome is reproduced without mutating the streak.
+func ApplyMissStreak(prev GuardState, passed bool, isConfirmation bool, stageHeight int64) MissOutcome {
+	if prev.UpdatedStageHeight == stageHeight {
+		return MissOutcome{VoteNo: !passed && prev.ConsecutiveMisses >= 2, NewState: prev}
+	}
+
+	next := prev
+	next.UpdatedStageHeight = stageHeight
+
+	if passed {
+		if isConfirmation {
+			// Only a confirmation PoC pass is trusted to clear the streak.
+			next.ConsecutiveMisses = 0
+		}
+		// Regular PoC pass: leave the streak untouched.
+		return MissOutcome{VoteNo: false, NewState: next}
+	}
+
+	// Failure in either phase always accrues a miss.
+	next.ConsecutiveMisses = prev.ConsecutiveMisses + 1
+
+	// One grace miss, then vote no on the second consecutive miss.
+	if next.ConsecutiveMisses <= 1 {
+		return MissOutcome{VoteNo: false, NewState: next}
+	}
+	return MissOutcome{VoteNo: true, NewState: next}
+}
diff --git a/decentralized-api/poc/earlyshare/decision_test.go b/decentralized-api/poc/earlyshare/decision_test.go
new file mode 100644
index 0000000000..c3d0d6514e
--- /dev/null
+++ b/decentralized-api/poc/earlyshare/decision_test.go
@@ -0,0 +1,195 @@
+package earlyshare
+
+import "testing"
+
+func TestWeightedMedianShare(t *testing.T) {
+	tests := []struct {
+		name    string
+		points  []SharePoint
+		want    float64
+		wantOK  bool
+	}{
+		{
+			name:   "empty",
+			points: nil,
+			wantOK: false,
+		},
+		{
+			name:   "all non-positive weight",
+			points: []SharePoint{{Share: 0.5, Weight: 0}, {Share: 0.9, Weight: -3}},
+			wantOK: false,
+		},
+		{
+			name:   "single point",
+			points: []SharePoint{{Share: 0.42, Weight: 10}},
+			want:   0.42,
+			wantOK: true,
+		},
+		{
+			name: "weighted crossing favors heavy low share",
+			// Cumulative: 0.2(w=10) -> 10; 0.8(w=5) -> 15; total=15, half=7.5
+			// 2*10=20 >= 15 at first point.
+			points: []SharePoint{{Share: 0.8, Weight: 5}, {Share: 0.2, Weight: 10}},
+			want:   0.2,
+			wantOK: true,
+		},
+		{
+			name: "even split picks lower middle deterministically",
+			// shares 0.1,0.9 each weight 5; total=10, half=5; 2*5=10>=10 at 0.1.
+			points: []SharePoint{{Share: 0.9, Weight: 5}, {Share: 0.1, Weight: 5}},
+			want:   0.1,
+			wantOK: true,
+		},
+		{
+			name: "zero-weight point ignored",
+			points: []SharePoint{
+				{Share: 0.0, Weight: 0},
+				{Share: 0.5, Weight: 3},
+				{Share: 0.6, Weight: 3},
+			},
+			// total=6 half=3; 2*3=6>=6 at 0.5
+			want:   0.5,
+			wantOK: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, ok := WeightedMedianShare(tt.points)
+			if ok != tt.wantOK {
+				t.Fatalf("ok = %v, want %v", ok, tt.wantOK)
+			}
+			if ok && got != tt.want {
+				t.Fatalf("median = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestApplyMissStreak(t *testing.T) {
+	const stage = int64(100)
+	const cpoc = true
+	const poc = false
+
+	t.Run("CPoC pass resets streak", func(t *testing.T) {
+		out := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, true, cpoc, stage)
+		if out.VoteNo {
+			t.Fatal("pass should not vote no")
+		}
+		if out.NewState.ConsecutiveMisses != 0 {
+			t.Fatalf("misses = %d, want 0", out.NewState.ConsecutiveMisses)
+		}
+		if out.NewState.UpdatedStageHeight != stage {
+			t.Fatalf("stage = %d, want %d", out.NewState.UpdatedStageHeight, stage)
+		}
+	})
+
+	t.Run("PoC pass does NOT reset streak", func(t *testing.T) {
+		out := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, true, poc, stage)
+		if out.VoteNo {
+			t.Fatal("pass should not vote no")
+		}
+		if out.NewState.ConsecutiveMisses != 1 {
+			t.Fatalf("PoC pass must not reset misses; got %d, want 1", out.NewState.ConsecutiveMisses)
+		}
+	})
+
+	t.Run("PoC pass does not rescue an established miss streak", func(t *testing.T) {
+		// One grace miss already used; a regular PoC pass must not clear it.
+		out := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, true, poc, stage)
+		if out.VoteNo {
+			t.Fatal("a passing stage never votes no")
+		}
+		if out.NewState.ConsecutiveMisses != 1 {
+			t.Fatalf("PoC pass must leave misses at 1; got %d", out.NewState.ConsecutiveMisses)
+		}
+		// The very next failure should then vote no (streak not rescued).
+		next := ApplyMissStreak(out.NewState, false, poc, stage+1)
+		if !next.VoteNo {
+			t.Fatal("failure after an unrescued streak should vote no")
+		}
+	})
+
+	t.Run("first miss is grace", func(t *testing.T) {
+		out := ApplyMissStreak(GuardState{ConsecutiveMisses: 0}, false, poc, stage)
+		if out.VoteNo {
+			t.Fatal("first miss should be grace, not vote no")
+		}
+		if out.NewState.ConsecutiveMisses != 1 {
+			t.Fatalf("misses = %d, want 1", out.NewState.ConsecutiveMisses)
+		}
+	})
+
+	t.Run("two consecutive misses vote no without any prior pass", func(t *testing.T) {
+		// No CPoC pass ever; two consecutive early-share failures vote no.
+		first := ApplyMissStreak(GuardState{}, false, poc, stage)
+		if first.VoteNo {
+			t.Fatal("first miss should be grace")
+		}
+		second := ApplyMissStreak(first.NewState, false, poc, stage+1)
+		if !second.VoteNo {
+			t.Fatal("second consecutive miss should vote no")
+		}
+		if second.NewState.ConsecutiveMisses != 2 {
+			t.Fatalf("misses = %d, want 2", second.NewState.ConsecutiveMisses)
+		}
+	})
+
+	t.Run("second consecutive miss votes no (PoC or CPoC failure)", func(t *testing.T) {
+		for _, conf := range []bool{poc, cpoc} {
+			out := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, false, conf, stage)
+			if !out.VoteNo {
+				t.Fatalf("second consecutive miss should vote no (isConfirmation=%v)", conf)
+			}
+			if out.NewState.ConsecutiveMisses != 2 {
+				t.Fatalf("misses = %d, want 2", out.NewState.ConsecutiveMisses)
+			}
+		}
+	})
+
+	t.Run("CPoC pass clears streak after grace miss", func(t *testing.T) {
+		out := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, true, cpoc, stage)
+		if out.VoteNo || out.NewState.ConsecutiveMisses != 0 {
+			t.Fatalf("CPoC pass should reset; got vote=%v misses=%d", out.VoteNo, out.NewState.ConsecutiveMisses)
+		}
+	})
+
+	t.Run("replaying the same stage does not double-count a miss", func(t *testing.T) {
+		// First run for the stage: grace miss.
+		first := ApplyMissStreak(GuardState{}, false, poc, stage)
+		if first.VoteNo || first.NewState.ConsecutiveMisses != 1 {
+			t.Fatalf("first run: vote=%v misses=%d, want grace miss", first.VoteNo, first.NewState.ConsecutiveMisses)
+		}
+		// Restart mid-validation replays the same stage: state must not change
+		// and the outcome must match the first run.
+		replay := ApplyMissStreak(first.NewState, false, poc, stage)
+		if replay.VoteNo {
+			t.Fatal("replay must not vote no when the first run was grace")
+		}
+		if replay.NewState != first.NewState {
+			t.Fatalf("replay mutated state: %+v -> %+v", first.NewState, replay.NewState)
+		}
+	})
+
+	t.Run("replaying the same stage reproduces a vote-no outcome", func(t *testing.T) {
+		second := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, false, poc, stage)
+		if !second.VoteNo || second.NewState.ConsecutiveMisses != 2 {
+			t.Fatalf("setup: vote=%v misses=%d, want vote no at 2", second.VoteNo, second.NewState.ConsecutiveMisses)
+		}
+		replay := ApplyMissStreak(second.NewState, false, poc, stage)
+		if !replay.VoteNo {
+			t.Fatal("replay must reproduce the vote-no outcome")
+		}
+		if replay.NewState != second.NewState {
+			t.Fatalf("replay mutated state: %+v -> %+v", second.NewState, replay.NewState)
+		}
+	})
+
+	t.Run("replaying a passed stage stays passed", func(t *testing.T) {
+		first := ApplyMissStreak(GuardState{ConsecutiveMisses: 1}, true, cpoc, stage)
+		replay := ApplyMissStreak(first.NewState, true, cpoc, stage)
+		if replay.VoteNo || replay.NewState != first.NewState {
+			t.Fatalf("replay of a pass changed outcome: vote=%v state=%+v", replay.VoteNo, replay.NewState)
+		}
+	})
+}
diff --git a/decentralized-api/poc/earlyshare/store.go b/decentralized-api/poc/earlyshare/store.go
new file mode 100644
index 0000000000..d0a84cd732
--- /dev/null
+++ b/decentralized-api/poc/earlyshare/store.go
@@ -0,0 +1,285 @@
+// Package earlyshare provides DAPI-local persistence and helpers for the
+// early PoC share guard. It captures early on-chain PoC v2 commitments near the
+// first-third of the generation window, persists them locally, and tracks a
+// per-(participant, model) miss streak so DAPI can later compare early vs final
+// commitments during off-chain validation.
+//
+// This is intentionally DAPI-local: it does not create any consensus rule. See
+// proposals/poc/early-share-guard-dapi.md for the design.
+package earlyshare
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+)
+
+// Checkpoint is one early commitment captured for a (stage, participant, model).
+type Checkpoint struct {
+	StageHeight           int64
+	ParticipantAddress    string
+	ModelID               string
+	EarlyCount            uint32
+	EarlyRootHash         []byte
+	CheckpointBlockHeight int64
+	CapturedAtBlockHeight int64
+}
+
+// GuardState is the cross-epoch miss-streak state for a (participant, model).
+type GuardState struct {
+	ParticipantAddress string
+	ModelID            string
+	ConsecutiveMisses  int
+	UpdatedStageHeight int64
+}
+
+// Store persists early-share checkpoints, capture-run metadata, and guard state
+// in the embedded SQLite database. It reuses the *sql.DB owned by the DAPI
+// config manager so it does not open a second file.
+type Store struct {
+	db *sql.DB
+}
+
+// NewStore wraps an already-open *sql.DB.
+func NewStore(db *sql.DB) *Store {
+	return &Store{db: db}
+}
+
+// EnsureSchema creates the early-share tables if they do not exist.
+func (s *Store) EnsureSchema(ctx context.Context) error {
+	if s == nil || s.db == nil {
+		return errors.New("earlyshare: db is nil")
+	}
+	stmt := `
+CREATE TABLE IF NOT EXISTS poc_early_checkpoints (
+  stage_height INTEGER NOT NULL,
+  participant_address TEXT NOT NULL,
+  model_id TEXT NOT NULL,
+  early_count INTEGER NOT NULL,
+  early_root_hash BLOB NOT NULL,
+  checkpoint_block_height INTEGER NOT NULL,
+  captured_at_block_height INTEGER NOT NULL,
+  PRIMARY KEY (stage_height, participant_address, model_id)
+);
+
+CREATE TABLE IF NOT EXISTS poc_early_guard_state (
+  participant_address TEXT NOT NULL,
+  model_id TEXT NOT NULL,
+  consecutive_misses INTEGER NOT NULL DEFAULT 0,
+  updated_stage_height INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (participant_address, model_id)
+);
+
+CREATE TABLE IF NOT EXISTS poc_early_capture_runs (
+  stage_height INTEGER NOT NULL,
+  model_id TEXT NOT NULL,
+  target_block_height INTEGER NOT NULL,
+  captured_at_block_height INTEGER NOT NULL,
+  captured_commit_count INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  PRIMARY KEY (stage_height, model_id)
+);
+CREATE INDEX IF NOT EXISTS idx_poc_early_checkpoints_stage ON poc_early_checkpoints(stage_height);
+CREATE INDEX IF NOT EXISTS idx_poc_early_capture_runs_stage ON poc_early_capture_runs(stage_height);`
+	_, err := s.db.ExecContext(ctx, stmt)
+	return err
+}
+
+// capture-run status values.
+const (
+	StatusCompleted = "completed"
+	StatusFailed    = "failed"
+	// stageMarkerModel is a sentinel model_id used to record a stage-level
+	// capture run that is independent of any specific model.
+	stageMarkerModel = ""
+)
+
+// UpsertCheckpoints inserts or replaces the given checkpoints atomically.
+func (s *Store) UpsertCheckpoints(ctx context.Context, checkpoints []Checkpoint) error {
+	if s == nil || s.db == nil {
+		return errors.New("earlyshare: db is nil")
+	}
+	if len(checkpoints) == 0 {
+		return nil
+	}
+	tx, err := s.db.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	q := `INSERT INTO poc_early_checkpoints (
+  stage_height, participant_address, model_id, early_count, early_root_hash,
+  checkpoint_block_height, captured_at_block_height
+) VALUES (?, ?, ?, ?, ?, ?, ?)
+ON CONFLICT(stage_height, participant_address, model_id) DO UPDATE SET
+  early_count = excluded.early_count,
+  early_root_hash = excluded.early_root_hash,
+  checkpoint_block_height = excluded.checkpoint_block_height,
+  captured_at_block_height = excluded.captured_at_block_height`
+	stmt, err := tx.PrepareContext(ctx, q)
+	if err != nil {
+		return err
+	}
+	defer stmt.Close()
+
+	for _, c := range checkpoints {
+		if _, err := stmt.ExecContext(ctx,
+			c.StageHeight,
+			c.ParticipantAddress,
+			c.ModelID,
+			c.EarlyCount,
+			c.EarlyRootHash,
+			c.CheckpointBlockHeight,
+			c.CapturedAtBlockHeight,
+		); err != nil {
+			return err
+		}
+	}
+	return tx.Commit()
+}
+
+// GetCheckpoints returns all early checkpoints for a stage.
+func (s *Store) GetCheckpoints(ctx context.Context, stageHeight int64) ([]Checkpoint, error) {
+	if s == nil || s.db == nil {
+		return nil, errors.New("earlyshare: db is nil")
+	}
+	rows, err := s.db.QueryContext(ctx, `
+SELECT stage_height, participant_address, model_id, early_count, early_root_hash,
+       checkpoint_block_height, captured_at_block_height
+FROM poc_early_checkpoints WHERE stage_height = ?`, stageHeight)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []Checkpoint
+	for rows.Next() {
+		var c Checkpoint
+		if err := rows.Scan(
+			&c.StageHeight,
+			&c.ParticipantAddress,
+			&c.ModelID,
+			&c.EarlyCount,
+			&c.EarlyRootHash,
+			&c.CheckpointBlockHeight,
+			&c.CapturedAtBlockHeight,
+		); err != nil {
+			return nil, err
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+// HasCompletedCapture reports whether a completed capture run exists for the
+// stage. Used for capture idempotency and to decide if the guard may run.
+func (s *Store) HasCompletedCapture(ctx context.Context, stageHeight int64) (bool, error) {
+	if s == nil || s.db == nil {
+		return false, errors.New("earlyshare: db is nil")
+	}
+	var n int
+	err := s.db.QueryRowContext(ctx,
+		`SELECT COUNT(1) FROM poc_early_capture_runs WHERE stage_height = ? AND status = ?`,
+		stageHeight, StatusCompleted).Scan(&n)
+	if err != nil {
+		return false, err
+	}
+	return n > 0, nil
+}
+
+// MarkCaptureRun upserts a single capture-run row.
+func (s *Store) MarkCaptureRun(ctx context.Context, stageHeight int64, modelID string, target, capturedAt int64, count int, status string) error {
+	if s == nil || s.db == nil {
+		return errors.New("earlyshare: db is nil")
+	}
+	q := `INSERT INTO poc_early_capture_runs (
+  stage_height, model_id, target_block_height, captured_at_block_height, captured_commit_count, status
+) VALUES (?, ?, ?, ?, ?, ?)
+ON CONFLICT(stage_height, model_id) DO UPDATE SET
+  target_block_height = excluded.target_block_height,
+  captured_at_block_height = excluded.captured_at_block_height,
+  captured_commit_count = excluded.captured_commit_count,
+  status = excluded.status`
+	_, err := s.db.ExecContext(ctx, q, stageHeight, modelID, target, capturedAt, count, status)
+	return err
+}
+
+// MarkStageCaptured records per-model capture rows plus a stage-level marker so
+// HasCompletedCapture is true after a successful capture.
+func (s *Store) MarkStageCaptured(ctx context.Context, stageHeight int64, target, capturedAt int64, perModelCounts map[string]int) error {
+	if err := s.MarkCaptureRun(ctx, stageHeight, stageMarkerModel, target, capturedAt, sumCounts(perModelCounts), StatusCompleted); err != nil {
+		return err
+	}
+	for modelID, count := range perModelCounts {
+		if modelID == stageMarkerModel {
+			continue
+		}
+		if err := s.MarkCaptureRun(ctx, stageHeight, modelID, target, capturedAt, count, StatusCompleted); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func sumCounts(m map[string]int) int {
+	total := 0
+	for _, v := range m {
+		total += v
+	}
+	return total
+}
+
+// GetGuardState returns the miss-streak state for a (participant, model).
+// ok is false when no row exists yet.
+func (s *Store) GetGuardState(ctx context.Context, participant, modelID string) (GuardState, bool, error) {
+	if s == nil || s.db == nil {
+		return GuardState{}, false, errors.New("earlyshare: db is nil")
+	}
+	row := s.db.QueryRowContext(ctx, `
+SELECT consecutive_misses, updated_stage_height
+FROM poc_early_guard_state WHERE participant_address = ? AND model_id = ?`, participant, modelID)
+	st := GuardState{ParticipantAddress: participant, ModelID: modelID}
+	if err := row.Scan(&st.ConsecutiveMisses, &st.UpdatedStageHeight); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return GuardState{ParticipantAddress: participant, ModelID: modelID}, false, nil
+		}
+		return GuardState{}, false, err
+	}
+	return st, true, nil
+}
+
+// UpsertGuardState writes the miss-streak state for a (participant, model).
+func (s *Store) UpsertGuardState(ctx context.Context, st GuardState) error {
+	if s == nil || s.db == nil {
+		return errors.New("earlyshare: db is nil")
+	}
+	q := `INSERT INTO poc_early_guard_state (
+  participant_address, model_id, consecutive_misses, updated_stage_height
+) VALUES (?, ?, ?, ?)
+ON CONFLICT(participant_address, model_id) DO UPDATE SET
+  consecutive_misses = excluded.consecutive_misses,
+  updated_stage_height = excluded.updated_stage_height`
+	_, err := s.db.ExecContext(ctx, q, st.ParticipantAddress, st.ModelID, st.ConsecutiveMisses, st.UpdatedStageHeight)
+	return err
+}
+
+// DeleteStage removes checkpoints and capture-run rows for a stage. Guard state
+// is intentionally left intact (it carries the cross-epoch miss streak).
+func (s *Store) DeleteStage(ctx context.Context, stageHeight int64) error {
+	if s == nil || s.db == nil {
+		return errors.New("earlyshare: db is nil")
+	}
+	tx, err := s.db.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+	if _, err := tx.ExecContext(ctx, `DELETE FROM poc_early_checkpoints WHERE stage_height = ?`, stageHeight); err != nil {
+		return err
+	}
+	if _, err := tx.ExecContext(ctx, `DELETE FROM poc_early_capture_runs WHERE stage_height = ?`, stageHeight); err != nil {
+		return err
+	}
+	return tx.Commit()
+}
diff --git a/decentralized-api/poc/earlyshare/store_test.go b/decentralized-api/poc/earlyshare/store_test.go
new file mode 100644
index 0000000000..baf2338595
--- /dev/null
+++ b/decentralized-api/poc/earlyshare/store_test.go
@@ -0,0 +1,152 @@
+package earlyshare
+
+import (
+	"context"
+	"database/sql"
+	"path/filepath"
+	"testing"
+
+	_ "modernc.org/sqlite"
+)
+
+func newTestStore(t *testing.T) *Store {
+	t.Helper()
+	dbPath := filepath.Join(t.TempDir(), "earlyshare_test.db")
+	db, err := sql.Open("sqlite", dbPath)
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+	s := NewStore(db)
+	if err := s.EnsureSchema(context.Background()); err != nil {
+		t.Fatalf("ensure schema: %v", err)
+	}
+	return s
+}
+
+func TestStoreCheckpointRoundTrip(t *testing.T) {
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	cps := []Checkpoint{
+		{StageHeight: 10, ParticipantAddress: "a", ModelID: "m1", EarlyCount: 5, EarlyRootHash: []byte{1, 2, 3}, CheckpointBlockHeight: 3, CapturedAtBlockHeight: 4},
+		{StageHeight: 10, ParticipantAddress: "b", ModelID: "m1", EarlyCount: 9, EarlyRootHash: []byte{4, 5}, CheckpointBlockHeight: 3, CapturedAtBlockHeight: 4},
+	}
+	if err := s.UpsertCheckpoints(ctx, cps); err != nil {
+		t.Fatalf("upsert: %v", err)
+	}
+
+	// Upsert again updates in place (idempotent capture).
+	cps[0].EarlyCount = 6
+	if err := s.UpsertCheckpoints(ctx, cps[:1]); err != nil {
+		t.Fatalf("re-upsert: %v", err)
+	}
+
+	got, err := s.GetCheckpoints(ctx, 10)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("got %d checkpoints, want 2", len(got))
+	}
+	byAddr := map[string]Checkpoint{}
+	for _, c := range got {
+		byAddr[c.ParticipantAddress] = c
+	}
+	if byAddr["a"].EarlyCount != 6 {
+		t.Fatalf("a early_count = %d, want 6", byAddr["a"].EarlyCount)
+	}
+	if string(byAddr["b"].EarlyRootHash) != string([]byte{4, 5}) {
+		t.Fatalf("b root mismatch")
+	}
+}
+
+func TestStoreCaptureRuns(t *testing.T) {
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	ok, err := s.HasCompletedCapture(ctx, 10)
+	if err != nil {
+		t.Fatalf("has: %v", err)
+	}
+	if ok {
+		t.Fatal("should not have capture before marking")
+	}
+
+	if err := s.MarkStageCaptured(ctx, 10, 3, 4, map[string]int{"m1": 2, "m2": 1}); err != nil {
+		t.Fatalf("mark: %v", err)
+	}
+	ok, err = s.HasCompletedCapture(ctx, 10)
+	if err != nil {
+		t.Fatalf("has: %v", err)
+	}
+	if !ok {
+		t.Fatal("should have completed capture after marking")
+	}
+
+	// Empty capture still records the stage marker.
+	if err := s.MarkStageCaptured(ctx, 20, 5, 6, nil); err != nil {
+		t.Fatalf("mark empty: %v", err)
+	}
+	if ok, _ := s.HasCompletedCapture(ctx, 20); !ok {
+		t.Fatal("empty capture should still mark stage completed")
+	}
+}
+
+func TestStoreGuardState(t *testing.T) {
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	_, ok, err := s.GetGuardState(ctx, "a", "m1")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if ok {
+		t.Fatal("no state expected initially")
+	}
+
+	st := GuardState{ParticipantAddress: "a", ModelID: "m1", ConsecutiveMisses: 1, UpdatedStageHeight: 42}
+	if err := s.UpsertGuardState(ctx, st); err != nil {
+		t.Fatalf("upsert: %v", err)
+	}
+	got, ok, err := s.GetGuardState(ctx, "a", "m1")
+	if err != nil || !ok {
+		t.Fatalf("get after upsert: ok=%v err=%v", ok, err)
+	}
+	if got.ConsecutiveMisses != 1 || got.UpdatedStageHeight != 42 {
+		t.Fatalf("state mismatch: %+v", got)
+	}
+}
+
+func TestStoreDeleteStageKeepsGuardState(t *testing.T) {
+	ctx := context.Background()
+	s := newTestStore(t)
+
+	if err := s.UpsertCheckpoints(ctx, []Checkpoint{
+		{StageHeight: 10, ParticipantAddress: "a", ModelID: "m1", EarlyCount: 5, EarlyRootHash: []byte{1}},
+	}); err != nil {
+		t.Fatalf("upsert cp: %v", err)
+	}
+	if err := s.MarkStageCaptured(ctx, 10, 3, 4, map[string]int{"m1": 1}); err != nil {
+		t.Fatalf("mark: %v", err)
+	}
+	if err := s.UpsertGuardState(ctx, GuardState{ParticipantAddress: "a", ModelID: "m1", ConsecutiveMisses: 1}); err != nil {
+		t.Fatalf("upsert state: %v", err)
+	}
+
+	if err := s.DeleteStage(ctx, 10); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+
+	cps, _ := s.GetCheckpoints(ctx, 10)
+	if len(cps) != 0 {
+		t.Fatalf("checkpoints not pruned: %d", len(cps))
+	}
+	if ok, _ := s.HasCompletedCapture(ctx, 10); ok {
+		t.Fatal("capture run not pruned")
+	}
+	// Guard state must survive stage pruning (cross-epoch streak).
+	if _, ok, _ := s.GetGuardState(ctx, "a", "m1"); !ok {
+		t.Fatal("guard state must persist across stage prune")
+	}
+}
diff --git a/decentralized-api/poc/phase.go b/decentralized-api/poc/phase.go
index dd99e22527..22095cdbbd 100644
--- a/decentralized-api/poc/phase.go
+++ b/decentralized-api/poc/phase.go
@@ -1,6 +1,8 @@
 package poc
 
 import (
+	"math"
+
 	"decentralized-api/chainphase"
 
 	"github.com/productscience/inference/x/inference/types"
@@ -94,6 +96,57 @@ func ShouldAcceptStoreCommit(epochState *chainphase.EpochState, pocStageStartHei
 	return epochState.LatestEpoch.IsPoCExchangeWindow(currentHeight)
 }
 
+// fractionPPMScale is the denominator for integer fraction arithmetic
+// (parts per million).
+const fractionPPMScale = 1_000_000
+
+// EarlyShareCaptureTarget computes the stage height and the "first fraction"
+// capture target block height for the active PoC or confirmation-PoC generation
+// window. ok is false when no generation window is active or inputs are invalid,
+// in which case the early-share guard must skip (fail open).
+//
+// The offset is computed in integer arithmetic: the configured fraction is
+// quantized to parts-per-million once, then offset = round(duration*ppm/1e6).
+// This makes the target height a pure function of (duration, ppm), identical
+// on every validator. Float spellings that agree to six decimal places (e.g.
+// the code default 1.0/3.0 and the documented config literal 0.3333333333)
+// quantize to the same ppm and therefore the same target height, which the
+// previous float multiply did not guarantee.
+//
+//   - Regular PoC: stage = PocStartBlockHeight, target = stage + offset.
+//   - Confirmation PoC: stage = event.TriggerHeight,
+//     target = event.GenerationStartHeight + offset.
+func EarlyShareCaptureTarget(epochState *chainphase.EpochState, firstFraction float64) (stageHeight int64, targetHeight int64, ok bool) {
+	if epochState.IsNilOrNotSynced() {
+		return 0, 0, false
+	}
+	ppm := int64(math.Round(firstFraction * fractionPPMScale))
+	if ppm <= 0 || ppm >= fractionPPMScale {
+		return 0, 0, false
+	}
+	duration := epochState.LatestEpoch.EpochParams.PocStageDuration
+	if duration <= 0 {
+		return 0, 0, false
+	}
+	offset := (duration*ppm + fractionPPMScale/2) / fractionPPMScale
+
+	// Confirmation PoC generation window during the inference phase.
+	if epochState.CurrentPhase == types.InferencePhase &&
+		epochState.ActiveConfirmationPoCEvent != nil &&
+		epochState.ActiveConfirmationPoCEvent.Phase == types.ConfirmationPoCPhase_CONFIRMATION_POC_GENERATION {
+		event := epochState.ActiveConfirmationPoCEvent
+		return event.TriggerHeight, event.GenerationStartHeight + offset, true
+	}
+
+	// Regular PoC generation (including the wind-down exchange window).
+	if epochState.CurrentPhase != types.PoCGeneratePhase &&
+		epochState.CurrentPhase != types.PoCGenerateWindDownPhase {
+		return 0, 0, false
+	}
+	stageHeight = epochState.LatestEpoch.PocStartBlockHeight
+	return stageHeight, stageHeight + offset, true
+}
+
 func ShouldHaveDistributedWeights(epochState *chainphase.EpochState) bool {
 	if epochState.IsNilOrNotSynced() {
 		return false
diff --git a/decentralized-api/poc/phase_test.go b/decentralized-api/poc/phase_test.go
index 130e140016..999cd4db18 100644
--- a/decentralized-api/poc/phase_test.go
+++ b/decentralized-api/poc/phase_test.go
@@ -158,6 +158,56 @@ func TestShouldAcceptValidatedArtifacts_NilOrNotSynced(t *testing.T) {
 	assert.False(t, ShouldAcceptValidatedArtifacts(notSynced))
 }
 
+func TestShouldStopValidationForStage(t *testing.T) {
+	tests := []struct {
+		name        string
+		state       *chainphase.EpochState
+		stageHeight int64
+		expect      bool
+	}{
+		{
+			name:        "nil state waits for next tracker update",
+			state:       nil,
+			stageHeight: 100,
+			expect:      false,
+		},
+		{
+			name: "transient not-synced state waits instead of cancelling",
+			state: func() *chainphase.EpochState {
+				s := createTestEpochState(types.PoCValidatePhase, 200, 100)
+				s.IsSynced = false
+				return s
+			}(),
+			stageHeight: 100,
+			expect:      false,
+		},
+		{
+			name:        "current validation stage continues",
+			state:       createTestEpochState(types.PoCValidatePhase, 200, 100),
+			stageHeight: 100,
+			expect:      false,
+		},
+		{
+			name:        "non-validation phase stops immediately",
+			state:       createTestEpochState(types.InferencePhase, 500, 100),
+			stageHeight: 100,
+			expect:      true,
+		},
+		{
+			name:        "different PoC stage stops immediately",
+			state:       createTestEpochState(types.PoCValidatePhase, 200, 120),
+			stageHeight: 100,
+			expect:      true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expect, shouldStopValidationForStage(tt.state, tt.stageHeight))
+		})
+	}
+}
+
 func TestGetCurrentPocStageHeight_RegularPoC(t *testing.T) {
 	tests := []struct {
 		name           string
diff --git a/decentralized-api/poc/proof_client.go b/decentralized-api/poc/proof_client.go
index 273202b589..bb8bcb4cff 100644
--- a/decentralized-api/poc/proof_client.go
+++ b/decentralized-api/poc/proof_client.go
@@ -28,12 +28,13 @@ var (
 	ErrProofVerificationFailed = errors.New("proof verification failed")
 	ErrDuplicateNonces         = errors.New("duplicate nonces detected")
 	ErrIncompleteCoverage      = errors.New("response does not cover all requested leaf indices")
+	ErrNonceAbsent             = errors.New("response does not cover all requested nonces")
 	ErrInvalidVectorData       = errors.New("invalid vector data detected")
 )
 
+// ProofClient fetches and verifies SMST proofs from participant APIs.
 const DefaultKDim = 12
 
-// ProofClient fetches and verifies MMR proofs from participant APIs.
 type ProofClient struct {
 	httpClient *http.Client
 	recorder   cosmosclient.CosmosMessageClient
@@ -49,6 +50,16 @@ type ProofRequest struct {
 	ParticipantAddress       string // participant whose API we're calling
 }
 
+// ProofByNonceRequest contains parameters for requesting proofs by nonce.
+type ProofByNonceRequest struct {
+	PocStageStartBlockHeight int64
+	ModelId                  string
+	RootHash                 []byte
+	Count                    uint32
+	Nonces                   []int32
+	ParticipantAddress       string // participant whose API we're calling
+}
+
 // ProofResponse is the response from the proof API.
 type ProofResponse struct {
 	Proofs []ProofItem `json:"proofs"`
@@ -177,52 +188,108 @@ func (c *ProofClient) FetchAndVerifyProofs(
 		return nil, err
 	}
 
-	// Verify each proof
 	verified := make([]VerifiedArtifact, 0, len(proofResp.Proofs))
 	for _, item := range proofResp.Proofs {
-		// Decode vector bytes
-		vectorBytes, err := base64.StdEncoding.DecodeString(item.VectorBytes)
+		artifact, err := verifyProofItem(req.RootHash, req.Count, req.ParticipantAddress, item)
 		if err != nil {
-			logging.Warn("Failed to decode vector bytes", types.PoC,
-				"participant", req.ParticipantAddress, "leafIndex", item.LeafIndex, "error", err)
-			return nil, fmt.Errorf("invalid vector_bytes encoding for leaf %d: %w", item.LeafIndex, err)
+			return nil, err
 		}
+		verified = append(verified, artifact)
+	}
 
-		// Validate FP16 vector: must be exactly DefaultKDim values, no NaN/Infinity
-		if err := ValidateFP16Vector(vectorBytes, DefaultKDim); err != nil {
-			logging.Warn("Invalid FP16 vector data", types.PoC,
-				"participant", req.ParticipantAddress, "leafIndex", item.LeafIndex, "error", err)
-			return nil, fmt.Errorf("%w: leaf %d: %v", ErrInvalidVectorData, item.LeafIndex, err)
-		}
+	logging.Debug("Verified proofs from participant", types.PoC,
+		"participant", req.ParticipantAddress, "count", len(verified))
 
-		// Decode proof hashes
-		proofHashes := make([][]byte, len(item.Proof))
-		for i, hashB64 := range item.Proof {
-			hash, err := base64.StdEncoding.DecodeString(hashB64)
-			if err != nil {
-				return nil, fmt.Errorf("invalid proof hash encoding for leaf %d: %w", item.LeafIndex, err)
-			}
-			proofHashes[i] = hash
-		}
+	return verified, nil
+}
 
-		// Build leaf data (same format as stored: nonce(LE32) || vector)
-		leafData := buildLeafData(item.NonceValue, vectorBytes)
+// FetchAndVerifyProofsByNonce fetches proofs for concrete nonces from the
+// participant's API and verifies their SMST index binding.
+func (c *ProofClient) FetchAndVerifyProofsByNonce(
+	ctx context.Context,
+	participantUrl string,
+	req ProofByNonceRequest,
+) ([]VerifiedArtifact, error) {
+	timestamp := time.Now().UnixNano()
+	validatorAddress := c.recorder.GetAccountAddress()
+	signerAddress := c.recorder.GetSignerAddress()
 
-		// Verify MMR proof
-		if !artifacts.VerifyProof(req.RootHash, req.Count, item.LeafIndex, leafData, proofHashes) {
-			logging.Warn("MMR proof verification failed", types.PoC,
-				"participant", req.ParticipantAddress, "leafIndex", item.LeafIndex)
-			return nil, fmt.Errorf("%w: leaf %d", ErrProofVerificationFailed, item.LeafIndex)
-		}
+	signPayload := buildProofByNonceSignPayload(
+		req.PocStageStartBlockHeight,
+		req.ModelId,
+		req.RootHash,
+		req.Count,
+		req.Nonces,
+		timestamp,
+		validatorAddress,
+		signerAddress,
+	)
+	signature, err := c.recorder.SignBytes(signPayload)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign request: %w", err)
+	}
 
-		verified = append(verified, VerifiedArtifact{
-			LeafIndex: item.LeafIndex,
-			Nonce:     item.NonceValue,
-			VectorB64: item.VectorBytes,
-		})
+	noncesInt := make([]int64, len(req.Nonces))
+	for i, nonce := range req.Nonces {
+		noncesInt[i] = int64(nonce)
+	}
+	requestBody := map[string]interface{}{
+		"poc_stage_start_block_height": req.PocStageStartBlockHeight,
+		"model_id":                     req.ModelId,
+		"root_hash":                    base64.StdEncoding.EncodeToString(req.RootHash),
+		"count":                        req.Count,
+		"nonces":                       noncesInt,
+		"validator_address":            validatorAddress,
+		"validator_signer_address":     signerAddress,
+		"timestamp":                    timestamp,
+		"signature":                    base64.StdEncoding.EncodeToString(signature),
 	}
 
-	logging.Debug("Verified proofs from participant", types.PoC,
+	bodyBytes, err := json.Marshal(requestBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	proofUrl, err := url.JoinPath(participantUrl, "v1/poc/proofs/by-nonce")
+	if err != nil {
+		return nil, fmt.Errorf("failed to build proof URL: %w", err)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, proofUrl, bytes.NewReader(bodyBytes))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.httpClient.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("proof by nonce request failed with status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var proofResp ProofResponse
+	if err := json.NewDecoder(resp.Body).Decode(&proofResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+	if err := validateNonceCoverage(req.Nonces, proofResp.Proofs); err != nil {
+		return nil, err
+	}
+
+	verified := make([]VerifiedArtifact, 0, len(proofResp.Proofs))
+	for _, item := range proofResp.Proofs {
+		artifact, err := verifyProofItem(req.RootHash, req.Count, req.ParticipantAddress, item)
+		if err != nil {
+			return nil, err
+		}
+		verified = append(verified, artifact)
+	}
+
+	logging.Debug("Verified by-nonce proofs from participant", types.PoC,
 		"participant", req.ParticipantAddress, "count", len(verified))
 
 	return verified, nil
@@ -273,6 +340,75 @@ func validateLeafCoverage(requested []uint32, proofs []ProofItem) error {
 	return nil
 }
 
+func validateNonceCoverage(requested []int32, proofs []ProofItem) error {
+	if len(requested) == 0 {
+		if len(proofs) == 0 {
+			return nil
+		}
+		return fmt.Errorf("%w: unexpected proof for nonce %d", ErrIncompleteCoverage, proofs[0].NonceValue)
+	}
+
+	missing := make(map[int32]struct{}, len(requested))
+	for _, nonce := range requested {
+		missing[nonce] = struct{}{}
+	}
+
+	seen := make(map[int32]struct{}, len(proofs))
+	for _, p := range proofs {
+		if _, duplicate := seen[p.NonceValue]; duplicate {
+			return fmt.Errorf("%w: duplicate nonce %d", ErrIncompleteCoverage, p.NonceValue)
+		}
+		seen[p.NonceValue] = struct{}{}
+
+		if _, ok := missing[p.NonceValue]; !ok {
+			return fmt.Errorf("%w: unexpected nonce %d", ErrIncompleteCoverage, p.NonceValue)
+		}
+		delete(missing, p.NonceValue)
+	}
+
+	for nonce := range missing {
+		return fmt.Errorf("%w: missing nonce %d", ErrNonceAbsent, nonce)
+	}
+	return nil
+}
+
+func verifyProofItem(rootHash []byte, count uint32, participantAddress string, item ProofItem) (VerifiedArtifact, error) {
+	vectorBytes, err := base64.StdEncoding.DecodeString(item.VectorBytes)
+	if err != nil {
+		logging.Warn("Failed to decode vector bytes", types.PoC,
+			"participant", participantAddress, "leafIndex", item.LeafIndex, "error", err)
+		return VerifiedArtifact{}, fmt.Errorf("invalid vector_bytes encoding for leaf %d: %w", item.LeafIndex, err)
+	}
+
+	if err := ValidateFP16Vector(vectorBytes, DefaultKDim); err != nil {
+		logging.Warn("Invalid FP16 vector data", types.PoC,
+			"participant", participantAddress, "leafIndex", item.LeafIndex, "error", err)
+		return VerifiedArtifact{}, fmt.Errorf("%w: leaf %d: %v", ErrInvalidVectorData, item.LeafIndex, err)
+	}
+
+	proofHashes := make([][]byte, len(item.Proof))
+	for i, hashB64 := range item.Proof {
+		hash, err := base64.StdEncoding.DecodeString(hashB64)
+		if err != nil {
+			return VerifiedArtifact{}, fmt.Errorf("invalid proof hash encoding for leaf %d: %w", item.LeafIndex, err)
+		}
+		proofHashes[i] = hash
+	}
+
+	leafData := buildLeafData(item.NonceValue, vectorBytes)
+	if !artifacts.VerifySMSTProofWithDenseIndex(rootHash, count, item.LeafIndex, item.NonceValue, leafData, proofHashes) {
+		logging.Warn("SMST proof verification failed", types.PoC,
+			"participant", participantAddress, "leafIndex", item.LeafIndex, "nonce", item.NonceValue)
+		return VerifiedArtifact{}, fmt.Errorf("%w: leaf %d", ErrProofVerificationFailed, item.LeafIndex)
+	}
+
+	return VerifiedArtifact{
+		LeafIndex: item.LeafIndex,
+		Nonce:     item.NonceValue,
+		VectorB64: item.VectorBytes,
+	}, nil
+}
+
 // buildProofSignPayload builds the binary payload for signature.
 // Format: hex(SHA256(
 //
@@ -319,6 +455,37 @@ func buildProofSignPayload(
 	return []byte(hex.EncodeToString(hash[:]))
 }
 
+// buildProofByNonceSignPayload mirrors the server's by-nonce request payload.
+// The leading domain tag prevents leaf-index signatures from replaying here.
+func buildProofByNonceSignPayload(
+	pocStageStartBlockHeight int64,
+	modelID string,
+	rootHash []byte,
+	count uint32,
+	nonces []int32,
+	timestamp int64,
+	validatorAddress string,
+	signerAddress string,
+) []byte {
+	buf := new(bytes.Buffer)
+
+	writeLengthPrefixedString(buf, "poc-proofs-by-nonce-v1")
+	binary.Write(buf, binary.LittleEndian, pocStageStartBlockHeight)
+	writeLengthPrefixedString(buf, modelID)
+	buf.Write(rootHash)
+	binary.Write(buf, binary.LittleEndian, count)
+	binary.Write(buf, binary.LittleEndian, uint32(len(nonces)))
+	for _, nonce := range nonces {
+		binary.Write(buf, binary.LittleEndian, nonce)
+	}
+	binary.Write(buf, binary.LittleEndian, timestamp)
+	writeLengthPrefixedString(buf, validatorAddress)
+	writeLengthPrefixedString(buf, signerAddress)
+
+	hash := sha256.Sum256(buf.Bytes())
+	return []byte(hex.EncodeToString(hash[:]))
+}
+
 // writeLengthPrefixedString writes len(s) as a LE uint32 followed by the
 // raw string bytes. Mirrors the helper in poc_handler.go on the server.
 func writeLengthPrefixedString(buf *bytes.Buffer, s string) {
@@ -326,7 +493,7 @@ func writeLengthPrefixedString(buf *bytes.Buffer, s string) {
 	buf.WriteString(s)
 }
 
-// buildLeafData builds the leaf data format used in MMR.
+// buildLeafData builds the leaf data format used in SMST proofs.
 // Format: nonce(LE32) || vector
 func buildLeafData(nonce int32, vector []byte) []byte {
 	buf := make([]byte, 4+len(vector))
diff --git a/decentralized-api/poc/proof_client_test.go b/decentralized-api/poc/proof_client_test.go
index f362c4fc52..cb60d95096 100644
--- a/decentralized-api/poc/proof_client_test.go
+++ b/decentralized-api/poc/proof_client_test.go
@@ -1,6 +1,7 @@
 package poc
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
@@ -9,7 +10,11 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	"decentralized-api/cosmosclient"
+	"decentralized-api/poc/artifacts"
+
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
@@ -94,6 +99,33 @@ func TestValidateLeafCoverage_SingleLeaf(t *testing.T) {
 	assert.NoError(t, validateLeafCoverage([]uint32{42}, []ProofItem{{LeafIndex: 42}}))
 }
 
+func TestValidateNonceCoverage_ExactMatch(t *testing.T) {
+	requested := []int32{10, 20}
+	proofs := []ProofItem{
+		{NonceValue: 20},
+		{NonceValue: 10},
+	}
+	assert.NoError(t, validateNonceCoverage(requested, proofs))
+}
+
+func TestValidateNonceCoverage_MissingNonce(t *testing.T) {
+	err := validateNonceCoverage([]int32{10, 20}, []ProofItem{{NonceValue: 10}})
+	assert.True(t, errors.Is(err, ErrNonceAbsent))
+	assert.Contains(t, err.Error(), "missing nonce")
+}
+
+func TestValidateNonceCoverage_UnexpectedNonce(t *testing.T) {
+	err := validateNonceCoverage([]int32{10}, []ProofItem{{NonceValue: 11}})
+	assert.True(t, errors.Is(err, ErrIncompleteCoverage))
+	assert.Contains(t, err.Error(), "unexpected nonce")
+}
+
+func TestValidateNonceCoverage_DuplicateNonce(t *testing.T) {
+	err := validateNonceCoverage([]int32{10}, []ProofItem{{NonceValue: 10}, {NonceValue: 10}})
+	assert.True(t, errors.Is(err, ErrIncompleteCoverage))
+	assert.Contains(t, err.Error(), "duplicate nonce")
+}
+
 func TestCheckDuplicateNonces_NoDuplicates(t *testing.T) {
 	artifacts := []VerifiedArtifact{
 		{Nonce: 1},
@@ -401,3 +433,94 @@ func TestFetchAndVerifyProofs_RejectsNaNVector(t *testing.T) {
 	// Ensure client is used to avoid unused variable warning
 	_ = client
 }
+
+func TestFetchAndVerifyProofsByNonce_Success(t *testing.T) {
+	store, err := artifacts.OpenSMST(t.TempDir())
+	require.NoError(t, err)
+	defer store.Close()
+
+	vector := make([]byte, DefaultKDim*2)
+	require.NoError(t, store.AddWithNode(42, vector, ""))
+	require.NoError(t, store.Flush())
+	count, rootHash := store.GetFlushedRoot()
+	denseIndex, vector, proof, err := store.GetArtifactAndProofByNonce(42, count)
+	require.NoError(t, err)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, "/v1/poc/proofs/by-nonce", r.URL.Path)
+
+		var req struct {
+			Nonces []int32 `json:"nonces"`
+		}
+		require.NoError(t, json.NewDecoder(r.Body).Decode(&req))
+		assert.Equal(t, []int32{42}, req.Nonces)
+
+		resp := ProofResponse{
+			Proofs: []ProofItem{{
+				LeafIndex:   denseIndex,
+				NonceValue:  42,
+				VectorBytes: base64.StdEncoding.EncodeToString(vector),
+				Proof:       proofStrings(proof),
+			}},
+		}
+		w.Header().Set("Content-Type", "application/json")
+		require.NoError(t, json.NewEncoder(w).Encode(resp))
+	}))
+	defer server.Close()
+
+	recorder := &cosmosclient.MockCosmosMessageClient{}
+	recorder.On("GetAccountAddress").Return("validator-address")
+	recorder.On("GetSignerAddress").Return("validator-signer")
+	recorder.On("SignBytes", mock.MatchedBy(func(payload []byte) bool {
+		return len(payload) == 64
+	})).Return([]byte("signature"), nil)
+
+	client := &ProofClient{httpClient: server.Client(), recorder: recorder}
+	verified, err := client.FetchAndVerifyProofsByNonce(context.Background(), server.URL, ProofByNonceRequest{
+		PocStageStartBlockHeight: 100,
+		ModelId:                  "model-a",
+		RootHash:                 rootHash,
+		Count:                    count,
+		Nonces:                   []int32{42},
+		ParticipantAddress:       "participant",
+	})
+	require.NoError(t, err)
+	require.Len(t, verified, 1)
+	assert.Equal(t, denseIndex, verified[0].LeafIndex)
+	assert.Equal(t, int32(42), verified[0].Nonce)
+	recorder.AssertExpectations(t)
+}
+
+func TestFetchAndVerifyProofsByNonce_MissingNonce(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		resp := ProofResponse{Proofs: []ProofItem{}}
+		w.Header().Set("Content-Type", "application/json")
+		require.NoError(t, json.NewEncoder(w).Encode(resp))
+	}))
+	defer server.Close()
+
+	recorder := &cosmosclient.MockCosmosMessageClient{}
+	recorder.On("GetAccountAddress").Return("validator-address")
+	recorder.On("GetSignerAddress").Return("validator-signer")
+	recorder.On("SignBytes", mock.Anything).Return([]byte("signature"), nil)
+
+	client := &ProofClient{httpClient: server.Client(), recorder: recorder}
+	_, err := client.FetchAndVerifyProofsByNonce(context.Background(), server.URL, ProofByNonceRequest{
+		PocStageStartBlockHeight: 100,
+		ModelId:                  "model-a",
+		RootHash:                 make([]byte, 32),
+		Count:                    1,
+		Nonces:                   []int32{42},
+		ParticipantAddress:       "participant",
+	})
+	assert.True(t, errors.Is(err, ErrNonceAbsent))
+	recorder.AssertExpectations(t)
+}
+
+func proofStrings(proof [][]byte) []string {
+	out := make([]string, len(proof))
+	for i, hash := range proof {
+		out[i] = base64.StdEncoding.EncodeToString(hash)
+	}
+	return out
+}
diff --git a/decentralized-api/poc/validator.go b/decentralized-api/poc/validator.go
index 7710c929e1..615e0227ab 100644
--- a/decentralized-api/poc/validator.go
+++ b/decentralized-api/poc/validator.go
@@ -6,6 +6,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"math"
 	"math/rand"
 	"net/url"
 	"slices"
@@ -17,6 +18,7 @@ import (
 	"decentralized-api/cosmosclient"
 	"decentralized-api/logging"
 	"decentralized-api/mlnodeclient"
+	"decentralized-api/poc/artifacts"
 
 	"github.com/productscience/inference/x/inference/calculations"
 	"github.com/productscience/inference/x/inference/types"
@@ -25,11 +27,13 @@ import (
 const (
 	POC_VALIDATE_GET_NODES_RETRIES     = 30
 	POC_VALIDATE_GET_NODES_RETRY_DELAY = 5 * time.Second
+	maxRetryBackoff                    = 45 * time.Second
 )
 
 // proofFetcher abstracts proof retrieval so it can be stubbed in tests.
 type proofFetcher interface {
 	FetchAndVerifyProofs(ctx context.Context, participantUrl string, req ProofRequest) ([]VerifiedArtifact, error)
+	FetchAndVerifyProofsByNonce(ctx context.Context, participantUrl string, req ProofByNonceRequest) ([]VerifiedArtifact, error)
 }
 
 // nodeBrokerFacade is the subset of broker.Broker used by OffChainValidator.
@@ -38,7 +42,7 @@ type nodeBrokerFacade interface {
 	GetNodes() ([]broker.NodeResponse, error)
 }
 
-// OffChainValidator handles off-chain PoC validation using MMR proofs.
+// OffChainValidator handles off-chain PoC validation using SMST proofs.
 type OffChainValidator struct {
 	recorder         cosmosclient.CosmosMessageClient
 	nodeBroker       nodeBrokerFacade
@@ -49,26 +53,45 @@ type OffChainValidator struct {
 	chainNodeUrl     string
 
 	config ValidationConfig
+	// guard is the optional DAPI-only early-share guard. A nil guard is a no-op.
+	guard         *EarlyShareGuard
+	artifactStore *artifacts.ManagedArtifactStore
 }
 
 // ValidationConfig contains configuration for off-chain validation.
 type ValidationConfig struct {
-	WorkerCount    int
-	RequestTimeout time.Duration
-	MaxRetries     int
-	RetryBackoff   time.Duration
+	WorkerCount        int
+	RequestTimeout     time.Duration
+	MaxRetries         int
+	RetryBackoff       time.Duration
+	PhaseCheckInterval time.Duration
 }
 
 // DefaultValidationConfig returns the default configuration.
 func DefaultValidationConfig() ValidationConfig {
 	return ValidationConfig{
-		WorkerCount:    10,
-		RequestTimeout: 20 * time.Second,
-		MaxRetries:     15,
-		RetryBackoff:   3 * time.Second,
+		WorkerCount:        10,
+		RequestTimeout:     20 * time.Second,
+		MaxRetries:         25,
+		RetryBackoff:       3 * time.Second,
+		PhaseCheckInterval: 3 * time.Second,
 	}
 }
 
+func retryBackoffDelay(base time.Duration, attempt int) time.Duration {
+	if base <= 0 {
+		base = DefaultValidationConfig().RetryBackoff
+	}
+	if attempt < 0 {
+		attempt = 0
+	}
+	delay := time.Duration(float64(base) * math.Pow(1.5, float64(attempt)))
+	if delay > maxRetryBackoff {
+		return maxRetryBackoff
+	}
+	return delay
+}
+
 // validateResult represents the outcome of validating a participant.
 type validateResult int
 
@@ -144,6 +167,8 @@ func NewOffChainValidator(
 	validatorAddress string,
 	chainNodeUrl string,
 	config ValidationConfig,
+	guard *EarlyShareGuard,
+	artifactStore *artifacts.ManagedArtifactStore,
 ) *OffChainValidator {
 	return &OffChainValidator{
 		recorder:         recorder,
@@ -154,6 +179,70 @@ func NewOffChainValidator(
 		validatorAddress: validatorAddress,
 		chainNodeUrl:     chainNodeUrl,
 		config:           config,
+		guard:            guard,
+		artifactStore:    artifactStore,
+	}
+}
+
+// MaybeCaptureEarlyShare is invoked once per block by the dispatcher. From the
+// first-fraction height until the end of the generation window it attempts the
+// early-share capture. The capture query is pinned to the exact first-fraction
+// height (see EarlyShareGuard.MaybeCapture), so a capture that runs a few
+// blocks late — after a restart, a slow query, or a transient chain error —
+// still records the identical consensus snapshot every other validator gets.
+// MaybeCapture is idempotent, so per-block re-invocation acts as a retry loop
+// that stops at the first completed capture.
+func (v *OffChainValidator) MaybeCaptureEarlyShare(epochState chainphase.EpochState) {
+	if v.artifactStore != nil {
+		v.maybeWarmEarlySnapshot(epochState)
+	}
+	if v.guard.Enabled() {
+		stage, target, ok := EarlyShareCaptureTarget(&epochState, v.guard.FirstFraction())
+		if ok && epochState.CurrentBlock.Height >= target {
+			go v.guard.MaybeCapture(context.Background(), v.recorder.NewInferenceQueryClient(), stage, target, epochState.CurrentBlock.Height)
+		}
+	}
+}
+
+func (v *OffChainValidator) maybeWarmEarlySnapshot(epochState chainphase.EpochState) {
+	// Use the guard's configured fraction so the warm-up targets the same
+	// checkpoint height validators capture at. FirstFraction is nil-safe and
+	// falls back to the default when the guard is absent.
+	stage, target, ok := EarlyShareCaptureTarget(&epochState, v.guard.FirstFraction())
+	if !ok || epochState.CurrentBlock.Height != target {
+		return
+	}
+	if v.validatorAddress == "" {
+		return
+	}
+
+	stageStores, err := v.artifactStore.GetStoresForStage(stage)
+	if err != nil || len(stageStores) == 0 {
+		return
+	}
+
+	queryClient := v.recorder.NewInferenceQueryClient()
+	for _, stageStore := range stageStores {
+		if stageStore.Store == nil {
+			continue
+		}
+		modelID := stageStore.ModelID
+		store := stageStore.Store
+		go func(modelID string, store artifacts.ArtifactStore) {
+			resp, err := queryClient.PoCV2StoreCommit(context.Background(), &types.QueryPoCV2StoreCommitRequest{
+				PocStageStartBlockHeight: stage,
+				ParticipantAddress:       v.validatorAddress,
+				ModelId:                  modelID,
+			})
+			if err != nil || !resp.Found || resp.Count == 0 {
+				if err != nil {
+					logging.Debug("OffChainValidator: early snapshot warm-up query failed", types.PoC,
+						"stage", stage, "modelId", modelID, "error", err)
+				}
+				return
+			}
+			store.WarmSnapshot(resp.Count)
+		}(modelID, store)
 	}
 }
 
@@ -238,6 +327,9 @@ func (v *OffChainValidator) ValidateAll(pocStageStartBlockHeight int64, pocStart
 	var snapshotTotalNetworkWeight int64
 	snapshotFound := false
 	modelSampling := make(map[string]*modelSamplingData)
+	// modelVotingPowers holds established per-model voting power (model_id ->
+	// participant -> voting power) for the early-share guard's weighted median.
+	modelVotingPowers := make(map[string]map[string]int64)
 	snapshotResp, err := queryClient.PoCValidationSnapshot(context.Background(),
 		&types.QueryPoCValidationSnapshotRequest{
 			PocStageStartHeight: pocStageStartBlockHeight,
@@ -254,6 +346,7 @@ func (v *OffChainValidator) ValidateAll(pocStageStartBlockHeight int64, pocStart
 		snapshotTotalNetworkWeight = snapshotResp.Snapshot.TotalNetworkWeight
 		for _, mvw := range snapshotResp.Snapshot.ModelVotingPowers {
 			weights := types.VotingPowerSliceToMap(mvw.VotingPowers)
+			modelVotingPowers[mvw.ModelId] = weights
 			entries, total := calculations.PrepareSortedEntries(weights)
 			modelSampling[mvw.ModelId] = &modelSamplingData{entries: entries, totalWeight: total}
 		}
@@ -349,13 +442,43 @@ func (v *OffChainValidator) ValidateAll(pocStageStartBlockHeight int64, pocStart
 		return
 	}
 
+	// Early-share guard: precompute per-participant decisions over the whole
+	// stage (weighted median needs the full distribution), advancing miss-streak
+	// state only for the participants this validator is assigned to. A nil
+	// runtime means the guard is disabled or skipped (fail open).
+	var gr *guardRuntime
+	if v.guard.Enabled() {
+		assigned := make(map[string]bool, len(workItems))
+		for _, item := range workItems {
+			assigned[earlyShareKey(item.address, item.modelId)] = true
+		}
+		// A confirmation PoC (CPoC) run is identified by an active confirmation
+		// event during the inference phase whose trigger height matches this
+		// stage. Only a passing CPoC clears the miss streak.
+		isConfirmation := epochState.ActiveConfirmationPoCEvent != nil &&
+			epochState.CurrentPhase == types.InferencePhase &&
+			pocStageStartBlockHeight == epochState.ActiveConfirmationPoCEvent.TriggerHeight
+		decisions := v.guard.Evaluate(context.Background(), pocStageStartBlockHeight, isConfirmation, commitsResp.Commits, modelVotingPowers, assigned)
+		if len(decisions) > 0 {
+			gr = &guardRuntime{
+				guard:             v.guard,
+				decisions:         decisions,
+				stage:             pocStageStartBlockHeight,
+				validatorPubKey:   v.pubKey,
+				samplingBlockHash: samplingBlockHash,
+			}
+		}
+	}
+
 	// Randomize order to avoid thundering herd
 	rand.Shuffle(len(workItems), func(i, j int) {
 		workItems[i], workItems[j] = workItems[j], workItems[i]
 	})
 
 	// Create proof client
-	proofClient := NewProofClient(v.recorder, ProofClientConfig{Timeout: v.config.RequestTimeout})
+	proofClient := NewProofClient(v.recorder, ProofClientConfig{
+		Timeout: v.config.RequestTimeout,
+	})
 
 	// Create work channel - buffered to allow re-queueing failed items
 	// Size: initial items + potential retries
@@ -368,9 +491,11 @@ func (v *OffChainValidator) ValidateAll(pocStageStartBlockHeight int64, pocStart
 	failCount := 0
 	pendingCount := len(workItems)
 
-	// Context for coordinating shutdown
+	// Context for coordinating shutdown. The phase watcher cancels as soon
+	// as the chain stops accepting validation results for this PoC stage.
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	v.cancelWhenValidationPhaseEnds(ctx, cancel, pocStageStartBlockHeight)
 
 	// Start workers
 	numWorkers := v.config.WorkerCount
@@ -393,6 +518,7 @@ func (v *OffChainValidator) ValidateAll(pocStageStartBlockHeight int64, pocStart
 				pocStartBlockHash,
 				pocParams,
 				sampleSize,
+				gr,
 				&statsMu,
 				&successCount,
 				&failCount,
@@ -417,6 +543,59 @@ func (v *OffChainValidator) ValidateAll(pocStageStartBlockHeight int64, pocStart
 		"failed", failCount)
 }
 
+func (v *OffChainValidator) cancelWhenValidationPhaseEnds(ctx context.Context, cancel context.CancelFunc, pocStageStartBlockHeight int64) {
+	phaseCheckInterval := v.config.PhaseCheckInterval
+	if phaseCheckInterval <= 0 {
+		phaseCheckInterval = 3 * time.Second
+	}
+
+	go func() {
+		if v.cancelIfValidationPhaseEnded(cancel, pocStageStartBlockHeight) {
+			return
+		}
+
+		ticker := time.NewTicker(phaseCheckInterval)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if v.cancelIfValidationPhaseEnded(cancel, pocStageStartBlockHeight) {
+					return
+				}
+			}
+		}
+	}()
+}
+
+func (v *OffChainValidator) cancelIfValidationPhaseEnded(cancel context.CancelFunc, pocStageStartBlockHeight int64) bool {
+	state := v.phaseTracker.GetCurrentEpochState()
+	if !shouldStopValidationForStage(state, pocStageStartBlockHeight) {
+		return false
+	}
+
+	logging.Info("OffChainValidator: validation phase ended, stopping workers", types.PoC,
+		"currentPhase", state.CurrentPhase,
+		"blockHeight", state.CurrentBlock.Height,
+		"pocStageStartBlockHeight", pocStageStartBlockHeight)
+	cancel()
+	return true
+}
+
+func shouldStopValidationForStage(state *chainphase.EpochState, pocStageStartBlockHeight int64) bool {
+	// A nil or not-synced tracker reading is transient (startup, RPC lag,
+	// catch-up), not evidence that the validation window ended. Cancelling on
+	// it would permanently abandon all in-flight validation for the stage, so
+	// treat it as "wait for the next tick" and only stop on a synced reading
+	// that positively says the phase ended or the stage changed.
+	if state.IsNilOrNotSynced() {
+		return false
+	}
+	return !ShouldAcceptValidatedArtifacts(state) || GetCurrentPocStageHeight(state) != pocStageStartBlockHeight
+}
+
 // worker processes participants from the work channel.
 // Failed items are re-queued for retry instead of blocking on retries.
 func (v *OffChainValidator) worker(
@@ -431,6 +610,7 @@ func (v *OffChainValidator) worker(
 	pocStartBlockHash string,
 	pocParams *types.PocParams,
 	sampleSize int,
+	gr *guardRuntime,
 	statsMu *sync.Mutex,
 	successCount *int,
 	failCount *int,
@@ -447,13 +627,24 @@ func (v *OffChainValidator) worker(
 				return
 			}
 
-			// Not ready yet? Put back at end of queue
+			// Not ready yet? Put back at end of queue and sleep briefly to avoid busy-wait spin.
 			if time.Now().Before(work.retryAfter) {
-				workChan <- work
+				select {
+				case workChan <- work:
+				case <-ctx.Done():
+					return
+				}
+
+				select {
+				case <-time.After(100 * time.Millisecond):
+				case <-ctx.Done():
+					return
+				}
 				continue
 			}
 
 			result := v.validateParticipant(
+				ctx,
 				workerID,
 				work,
 				proofClient,
@@ -464,6 +655,7 @@ func (v *OffChainValidator) worker(
 				pocStartBlockHash,
 				pocParams,
 				sampleSize,
+				gr,
 			)
 
 			var reportParticipant string
@@ -477,33 +669,29 @@ func (v *OffChainValidator) worker(
 			case validateFailPermanent:
 				*failCount++
 				*pendingCount--
-				// Report participant as invalid to chain
-				// Uncomment when stabilized
 				reportParticipant = work.address
 				reportModelID = work.modelId
 			case validateFailRetry:
 				// Re-queue for retry if under max attempts
 				if work.attempt < v.config.MaxRetries-1 {
 					work.attempt++
-					work.retryAfter = time.Now().Add(v.config.RetryBackoff)
-					// Non-blocking send - if channel is full, count as failed
+					delay := retryBackoffDelay(v.config.RetryBackoff, work.attempt-1)
+					work.retryAfter = time.Now().Add(delay)
 					select {
 					case workChan <- work:
 						logging.Debug("OffChainValidator: re-queued for retry", types.PoC,
-							"participant", work.address, "attempt", work.attempt)
-					default:
-						*failCount++
-						*pendingCount--
-						logging.Warn("OffChainValidator: queue full, marking as failed", types.PoC,
-							"participant", work.address)
+							"participant", work.address, "attempt", work.attempt, "delay", delay)
+					case <-ctx.Done():
+						statsMu.Unlock()
+						return
 					}
 				} else {
 					*failCount++
 					*pendingCount--
-					logging.Warn("OffChainValidator: max retries exceeded, reporting as invalid", types.PoC,
+					reportParticipant = work.address
+					reportModelID = work.modelId
+					logging.Warn("OffChainValidator: max retries exceeded for transient validation failure", types.PoC,
 						"participant", work.address, "attempts", work.attempt+1)
-					// Report participant as invalid to chain. We probably should separate only to report failed network requests.
-					// reportAddr = work.address
 				}
 			}
 
@@ -527,6 +715,7 @@ func (v *OffChainValidator) worker(
 // samplingBlockHash: fresh hash for random sampling (anti-cheat)
 // pocStartBlockHash: original PoC start block hash (must match generation for MLNode)
 func (v *OffChainValidator) validateParticipant(
+	ctx context.Context,
 	workerID int,
 	work participantWork,
 	proofClient proofFetcher,
@@ -537,8 +726,8 @@ func (v *OffChainValidator) validateParticipant(
 	pocStartBlockHash string,
 	pocParams *types.PocParams,
 	sampleSize int,
+	gr *guardRuntime,
 ) validateResult {
-	ctx := context.Background()
 	modelNodes := filterValidationNodesForModel(nodes, work.modelId)
 	if len(modelNodes) == 0 {
 		logging.Warn("OffChainValidator: no validation executors for model", types.PoC,
@@ -572,7 +761,9 @@ func (v *OffChainValidator) validateParticipant(
 		return validateFailRetry
 	}
 
-	// Check for duplicate nonces (fraud) - permanent failure
+	// Check for duplicate nonces in response (defense-in-depth).
+	// SMST proofs with index-binding structurally prevent cross-index duplication,
+	// but this guards against a malformed response returning the same artifact twice.
 	if err := CheckDuplicateNonces(verified); err != nil {
 		logging.Warn("OffChainValidator: duplicate nonces detected (fraud)", types.PoC,
 			"participant", work.address, "error", err)
@@ -588,6 +779,34 @@ func (v *OffChainValidator) validateParticipant(
 		return validateFailPermanent
 	}
 
+	// Early-share guard: compare the early checkpoint against the final
+	// commitment. The inclusion check fails immediately on a cryptographic
+	// mismatch; the low-early-share decision is miss-streak gated and was
+	// precomputed in ValidateAll. Enforcing only changes the vote in enforce mode.
+	if gr != nil && gr.guard != nil {
+		if dec, ok := gr.decisions[earlyShareKey(work.address, work.modelId)]; ok {
+			outcome, reason := gr.guard.decide(ctx, proofClient, gr.stage, work, dec, gr.validatorPubKey, gr.samplingBlockHash)
+			switch outcome {
+			case earlyGuardVoteNo:
+				if gr.guard.cfg.Enforcing() {
+					logging.Warn("OffChainValidator: early-share guard vote no (enforce)", types.PoC,
+						"participant", work.address, "modelId", work.modelId, "reason", reason)
+					return validateFailPermanent
+				}
+				logging.Info("OffChainValidator: early-share guard would vote no (observe)", types.PoC,
+					"participant", work.address, "modelId", work.modelId, "reason", reason)
+			case earlyGuardRetry:
+				if gr.guard.cfg.Enforcing() {
+					logging.Warn("OffChainValidator: early-share guard retry (enforce)", types.PoC,
+						"participant", work.address, "modelId", work.modelId, "reason", reason)
+					return validateFailRetry
+				}
+				logging.Info("OffChainValidator: early-share guard would retry (observe)", types.PoC,
+					"participant", work.address, "modelId", work.modelId, "reason", reason)
+			}
+		}
+	}
+
 	// Convert verified artifacts to ML node format
 	artifacts := make([]mlnodeclient.ArtifactV2, len(verified))
 	nonces := make([]int64, len(verified))
diff --git a/decentralized-api/poc/validator_retry_test.go b/decentralized-api/poc/validator_retry_test.go
new file mode 100644
index 0000000000..b27ae5731c
--- /dev/null
+++ b/decentralized-api/poc/validator_retry_test.go
@@ -0,0 +1,84 @@
+package poc
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestRetryBackoffDelay(t *testing.T) {
+	base := 3 * time.Second
+	want := []time.Duration{
+		3 * time.Second,
+		4500 * time.Millisecond,
+		6750 * time.Millisecond,
+		10125 * time.Millisecond,
+		15187500 * time.Microsecond,
+		22781250 * time.Microsecond,
+		34171875 * time.Microsecond,
+		45 * time.Second,
+		45 * time.Second,
+	}
+	for attempt, expected := range want {
+		if got := retryBackoffDelay(base, attempt); got != expected {
+			t.Fatalf("attempt %d: delay = %v, want %v", attempt, got, expected)
+		}
+	}
+
+	var total time.Duration
+	for attempt := 0; attempt < DefaultValidationConfig().MaxRetries-1; attempt++ {
+		total += retryBackoffDelay(base, attempt)
+	}
+	if total < 14*time.Minute || total > 15*time.Minute {
+		t.Fatalf("total retry window = %v, want about 15m", total)
+	}
+}
+
+func TestRetryQueueWaitingItemDoesNotBlockReadyItems(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	workChan := make(chan participantWork, 8)
+	waiting := participantWork{address: "waiting", retryAfter: time.Now().Add(time.Hour)}
+	ready := []participantWork{
+		{address: "ready-1"},
+		{address: "ready-2"},
+		{address: "ready-3"},
+	}
+	workChan <- waiting
+	for _, item := range ready {
+		workChan <- item
+	}
+
+	processed := make(chan string, len(ready))
+	go func() {
+		for len(processed) < len(ready) {
+			select {
+			case work := <-workChan:
+				if time.Now().Before(work.retryAfter) {
+					select {
+					case workChan <- work:
+					case <-ctx.Done():
+						return
+					}
+					time.Sleep(10 * time.Millisecond)
+					continue
+				}
+				processed <- work.address
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+
+	deadline := time.After(200 * time.Millisecond)
+	seen := map[string]bool{}
+	for len(seen) < len(ready) {
+		select {
+		case addr := <-processed:
+			seen[addr] = true
+		case <-deadline:
+			t.Fatalf("ready items were starved by waiting item; seen=%v", seen)
+		}
+	}
+}
diff --git a/decentralized-api/poc/validator_rng_test.go b/decentralized-api/poc/validator_rng_test.go
index 322c52a308..a3cf498ee6 100644
--- a/decentralized-api/poc/validator_rng_test.go
+++ b/decentralized-api/poc/validator_rng_test.go
@@ -2,13 +2,18 @@ package poc
 
 import (
 	"context"
+	"errors"
+	"sync"
 	"testing"
+	"time"
 
 	"decentralized-api/broker"
+	"decentralized-api/cosmosclient"
 	"decentralized-api/mlnodeclient"
 
 	"github.com/productscience/inference/x/inference/types"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
@@ -21,6 +26,22 @@ func (s *stubProofFetcher) FetchAndVerifyProofs(_ context.Context, _ string, _ P
 	return s.artifacts, nil
 }
 
+func (s *stubProofFetcher) FetchAndVerifyProofsByNonce(_ context.Context, _ string, _ ProofByNonceRequest) ([]VerifiedArtifact, error) {
+	return s.artifacts, nil
+}
+
+type failingProofFetcher struct {
+	err error
+}
+
+func (f *failingProofFetcher) FetchAndVerifyProofs(_ context.Context, _ string, _ ProofRequest) ([]VerifiedArtifact, error) {
+	return nil, f.err
+}
+
+func (f *failingProofFetcher) FetchAndVerifyProofsByNonce(_ context.Context, _ string, _ ProofByNonceRequest) ([]VerifiedArtifact, error) {
+	return nil, f.err
+}
+
 // stubNodeBroker implements nodeBrokerFacade for tests.
 type stubNodeBroker struct {
 	client mlnodeclient.MLNodeClient
@@ -83,10 +104,12 @@ func runValidateParticipant(t *testing.T, pocStrongerRng bool) *mlnodeclient.PoC
 
 	nodeCounter := 0
 	result := v.validateParticipant(
+		context.Background(),
 		0, work, stub,
 		[]broker.NodeResponse{testNode}, &nodeCounter,
 		1000, "sampling-hash", "start-hash",
 		pocParams, 1,
+		nil,
 	)
 
 	require.Equal(t, validateSuccess, result)
@@ -114,3 +137,75 @@ func TestValidateParticipant_StrongerRngPropagated(t *testing.T) {
 		assert.False(t, req.PocStrongerRng, "PocStrongerRng must be forwarded to GenerateV2 when disabled")
 	})
 }
+
+func TestWorkerReportsInvalidAfterRetryExhaustion(t *testing.T) {
+	recorder := &cosmosclient.MockCosmosMessageClient{}
+	recorder.On("SubmitPocValidationsV2", mock.MatchedBy(func(msg *types.MsgSubmitPocValidationsV2) bool {
+		if msg.PocStageStartBlockHeight != 1000 || len(msg.Validations) != 1 {
+			return false
+		}
+		validation := msg.Validations[0]
+		return validation.ParticipantAddress == "cosmos1unresponsive" &&
+			validation.ModelId == "test-model" &&
+			validation.ValidatedWeight == -1
+	})).Return(nil).Once()
+
+	v := &OffChainValidator{
+		recorder: recorder,
+		config: ValidationConfig{
+			MaxRetries:   1,
+			RetryBackoff: time.Millisecond,
+		},
+	}
+
+	workChan := make(chan participantWork, 1)
+	workChan <- participantWork{
+		address: "cosmos1unresponsive",
+		modelId: "test-model",
+		count:   100,
+		url:     "http://participant",
+	}
+
+	testNode := broker.NodeResponse{
+		Node: broker.Node{
+			Host:    "127.0.0.1",
+			PoCPort: 8080,
+			NodeNum: 1,
+			Models: map[string]broker.ModelArgs{
+				"test-model": {},
+			},
+		},
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	successCount := 0
+	failCount := 0
+	pendingCount := 1
+	var statsMu sync.Mutex
+
+	v.worker(
+		ctx,
+		cancel,
+		0,
+		workChan,
+		&failingProofFetcher{err: errors.New("participant unavailable")},
+		[]broker.NodeResponse{testNode},
+		1000,
+		"sampling-hash",
+		"start-hash",
+		&types.PocParams{},
+		1,
+		nil,
+		&statsMu,
+		&successCount,
+		&failCount,
+		&pendingCount,
+	)
+
+	require.Equal(t, 0, successCount)
+	require.Equal(t, 1, failCount)
+	require.Equal(t, 0, pendingCount)
+	recorder.AssertExpectations(t)
+}
diff --git a/deploy/join/docker-compose.devshard-gateway.yml b/deploy/join/docker-compose.devshard-gateway.yml
index acaa5d13a8..b4801b8b17 100644
--- a/deploy/join/docker-compose.devshard-gateway.yml
+++ b/deploy/join/docker-compose.devshard-gateway.yml
@@ -1,4 +1,67 @@
 services:
+  # Optional HTTPS frontend for standalone devshard-gateway.
+  #
+  # HTTP-01 certificate:
+  #   export DEVSHARD_GATEWAY_DOMAIN=your.domain.com
+  #
+  # Cloudflare DNS-01 certificate:
+  #   export DEVSHARD_GATEWAY_DOMAIN=your.domain.com
+  #   export CLOUDFLARE_API_TOKEN=<cloudflare token with DNS edit access>
+  #
+  # Start:
+  #   docker compose --profile ssl -f docker-compose.devshard-gateway.yml up -d
+  devshard-gateway-caddy:
+    profiles:
+      - ssl
+    container_name: ${DEVSHARD_CADDY_INSTANCE_NAME:-devshard-gateway-caddy}
+    image: gonka-devshard-gateway-caddy:local
+    build:
+      dockerfile_inline: |
+        FROM caddy:2-builder AS builder
+        RUN xcaddy build --with github.com/caddy-dns/cloudflare
+
+        FROM caddy:2
+        COPY --from=builder /usr/bin/caddy /usr/bin/caddy
+    command:
+      - sh
+      - -ec
+      - |
+        if [ -z "$${DEVSHARD_GATEWAY_DOMAIN:-}" ]; then
+          echo "DEVSHARD_GATEWAY_DOMAIN is required"
+          exit 1
+        fi
+
+        {
+          if [ -n "$${CLOUDFLARE_API_TOKEN:-}" ]; then
+            printf '{\n  acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}\n}\n\n'
+          fi
+          printf '%s {\n' "$${DEVSHARD_GATEWAY_DOMAIN}"
+          printf '  @metrics path /metrics*\n'
+          printf '  respond @metrics 404\n\n'
+          printf '  handle /grafana* {\n'
+          printf '    reverse_proxy grafana:3000\n'
+          printf '  }\n\n'
+          printf '  reverse_proxy devshard-gateway:8080\n'
+          printf '}\n'
+        } > /tmp/Caddyfile
+
+        exec caddy run --config /tmp/Caddyfile --adapter caddyfile
+    environment:
+      - DEVSHARD_GATEWAY_DOMAIN=${DEVSHARD_GATEWAY_DOMAIN:-}
+      - CLOUDFLARE_API_TOKEN=${CLOUDFLARE_API_TOKEN:-}
+    volumes:
+      - caddy_devshard_data:/data
+      - caddy_devshard_config:/config
+    ports:
+      - "${DEVSHARD_HTTPS_HTTP_PORT:-80}:80"
+      - "${DEVSHARD_HTTPS_PORT:-443}:443"
+    networks:
+      - join_default
+    depends_on:
+      devshard-gateway:
+        condition: service_started
+    restart: unless-stopped
+
   devshard-gateway:
     container_name: ${DEVSHARD_INSTANCE_NAME:-devshard-gateway}
     image: ghcr.io/gonka-ai/devshard-gateway:mainnet-v0.2.13-latest
@@ -26,3 +89,7 @@ services:
 networks:
   join_default:
     external: true
+
+volumes:
+  caddy_devshard_data:
+  caddy_devshard_config:
diff --git a/deploy/join/docker-compose.yml b/deploy/join/docker-compose.yml
index a59de817be..721bb293b7 100644
--- a/deploy/join/docker-compose.yml
+++ b/deploy/join/docker-compose.yml
@@ -122,6 +122,8 @@ services:
       - JWT_SECRET_PATH=/data/jwt/jwt.hex
       - BRIDGE_POSTBLOCK=http://api:9200/admin/v1/bridge/block
       - BRIDGE_GETADDRESSES=http://api:9000/v1/bridge/addresses
+      - BRIDGE_GETLASTBLOCK=${BRIDGE_GETLASTBLOCK:-http://api:9000/v1/bridge/block/latest}
+      - BRIDGE_CACHE_RANGES=${BRIDGE_CACHE_RANGES:-4}
       - BEACON_STATE_URL=https://beaconstate.info/
       - PERSISTENT_DB_DIR=/persistent-db
     volumes:
diff --git a/deploy/join/observability/grafana/dashboards/gonka-gateway-observability.json b/deploy/join/observability/grafana/dashboards/gonka-gateway-observability.json
new file mode 100644
index 0000000000..dd841efcc7
--- /dev/null
+++ b/deploy/join/observability/grafana/dashboards/gonka-gateway-observability.json
@@ -0,0 +1,1699 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": false,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "links": [],
+  "panels": [
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 0
+      },
+      "id": 104,
+      "panels": [],
+      "title": "Overall Gateway Health",
+      "type": "row"
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 21
+      },
+      "id": 110,
+      "panels": [],
+      "title": "Nonce Consumption",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Gateway-observed nonce-consuming actions per accepted non-cache request. This is not voting amount.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 5,
+        "x": 0,
+        "y": 22
+      },
+      "id": 111,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_slot_decisions_total{model=~\"$model\"}[$__range])) / clamp_min(sum(increase(devshard_gateway_requests_total{model=~\"$model\",outcome!~\"cached|invalid_request|model_rejected|gateway_limited\"}[$__range])), 1)",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Total nonces / accepted request",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Real participant sends per accepted non-cache request.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 5,
+        "x": 5,
+        "y": 22
+      },
+      "id": 112,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_slot_decisions_total{model=~\"$model\",decision=\"real_send\"}[$__range])) / clamp_min(sum(increase(devshard_gateway_requests_total{model=~\"$model\",outcome!~\"cached|invalid_request|model_rejected|gateway_limited\"}[$__range])), 1)",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Real sends / accepted request",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Prepared nonces where the gateway intentionally did not contact a participant.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 5,
+        "x": 10,
+        "y": 22
+      },
+      "id": 113,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_slot_decisions_total{model=~\"$model\",decision=\"ghost_no_send\"}[$__range])) / clamp_min(sum(increase(devshard_gateway_requests_total{model=~\"$model\",outcome!~\"cached|invalid_request|model_rejected|gateway_limited\"}[$__range])), 1)",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "No-send burns / accepted request",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Top nonce-consuming gateway actions by kind and reason. This uses the existing slot decision metric but labels it by nonce semantics.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 9,
+        "x": 15,
+        "y": 22
+      },
+      "id": 114,
+      "targets": [
+        {
+          "expr": "topk(10, sum(rate(devshard_gateway_slot_decisions_total{model=~\"$model\"}[$__rate_interval])) by (decision, reason))",
+          "legendFormat": "{{decision}} / {{reason}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Nonce consumption by reason",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Gateway-observed nonce-consuming actions per accepted non-cache request over time. Spikes indicate PoC/cPoC, quarantine, throttling, capability skips, or redundancy pressure. This is not voting amount.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 24,
+        "x": 0,
+        "y": 29
+      },
+      "id": 115,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_slot_decisions_total{model=~\"$model\"}[5m])) / clamp_min(sum(rate(devshard_gateway_requests_total{model=~\"$model\",outcome!~\"cached|invalid_request|model_rejected|gateway_limited\"}[5m])), 0.001)",
+          "legendFormat": "total nonces / accepted request",
+          "refId": "A"
+        }
+      ],
+      "title": "Total nonces / accepted request over time",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Prometheus scrape state for the gateway.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 0,
+          "mappings": [
+            {
+              "options": {
+                "0": {
+                  "text": "down"
+                },
+                "1": {
+                  "text": "up"
+                }
+              },
+              "type": "value"
+            }
+          ],
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 3,
+        "x": 0,
+        "y": 1
+      },
+      "id": 3,
+      "options": {
+        "colorMode": "background",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "up{job=\"devshard-gateway\"}",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Gateway Scrape",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Selected-window gateway request rate.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 4,
+        "x": 3,
+        "y": 1
+      },
+      "id": 4,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_requests_total{model=~\"$model\"}[$__range])) / $__range_s",
+          "refId": "A"
+        }
+      ],
+      "title": "Average Request Rate",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Successful or cached user requests divided by all requests.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "max": 1,
+          "min": 0,
+          "unit": "percentunit"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 4,
+        "x": 7,
+        "y": 1
+      },
+      "id": 5,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_requests_total{model=~\"$model\",outcome=~\"success|cached\"}[$__range])) / clamp_min(sum(increase(devshard_gateway_requests_total{model=~\"$model\"}[$__range])), 1)",
+          "refId": "A"
+        }
+      ],
+      "title": "Range User Success Rate",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "User-visible failures in the selected window.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 0,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 4,
+        "x": 11,
+        "y": 1
+      },
+      "id": 6,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_critical_user_failures_total{model=~\"$model\"}[$__range]))",
+          "refId": "A"
+        }
+      ],
+      "title": "Range Critical User Failures",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Cached requests divided by all requests.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "max": 1,
+          "min": 0,
+          "unit": "percentunit"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 4,
+        "x": 15,
+        "y": 1
+      },
+      "id": 7,
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "sum(increase(devshard_gateway_requests_total{model=~\"$model\",outcome=\"cached\"}[$__range])) / clamp_min(sum(increase(devshard_gateway_requests_total{model=~\"$model\"}[$__range])), 1)",
+          "refId": "A"
+        }
+      ],
+      "title": "Range Cache Hit Share",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Gateway-wide capacity scale applied to limiter caps.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "max": 1,
+          "min": 0,
+          "unit": "percentunit"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 2,
+        "x": 19,
+        "y": 1
+      },
+      "id": 73,
+      "options": {
+        "colorMode": "background",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "devshard_gateway_capacity_scale",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Gateway Capacity Scale",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Lowest capacity scale among selected models.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "max": 1,
+          "min": 0,
+          "unit": "percentunit"
+        }
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 3,
+        "x": 21,
+        "y": 1
+      },
+      "id": 74,
+      "options": {
+        "colorMode": "background",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        }
+      },
+      "targets": [
+        {
+          "expr": "min(devshard_gateway_capacity_scale_by_model{model=~\"$model\"})",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Worst Model Capacity Scale",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Final user outcomes by bounded reason.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 5
+      },
+      "id": 8,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_requests_total{model=~\"$model\"}[$__rate_interval])) by (outcome, reason)",
+          "legendFormat": "{{outcome}} / {{reason}}",
+          "refId": "A"
+        }
+      ],
+      "title": "What Users Saw by Outcome and Reason",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Top critical user-visible failure reasons.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 8,
+        "y": 5
+      },
+      "id": 9,
+      "targets": [
+        {
+          "expr": "topk(15, sum(increase(devshard_gateway_critical_user_failures_total{model=~\"$model\",reason=~\"$reason\"}[$__range])) by (reason))",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Top User-Visible Failure Reasons",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Gateway-wide chat route p95. Not participant latency.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "s"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 5
+      },
+      "id": 10,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_http_request_duration_seconds_bucket{path=~\"/v1/.+chat.+\"}[$__rate_interval])) by (le))",
+          "legendFormat": "p95 route latency",
+          "refId": "A"
+        }
+      ],
+      "title": "HTTP Chat Route p95 (gateway-wide)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Gateway limiter rejections by reason.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 13
+      },
+      "id": 11,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_limit_rejections_total[$__rate_interval])) by (reason)",
+          "legendFormat": "{{reason}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Gateway Admission Rejections by Reason (gateway-wide)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Current limiter load and effective caps.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 8,
+        "y": 13
+      },
+      "id": 12,
+      "targets": [
+        {
+          "expr": "devshard_gateway_inflight_requests",
+          "legendFormat": "inflight requests",
+          "refId": "A"
+        },
+        {
+          "expr": "devshard_gateway_effective_max_concurrent_requests",
+          "legendFormat": "request cap",
+          "refId": "B"
+        },
+        {
+          "expr": "devshard_gateway_inflight_input_tokens",
+          "legendFormat": "inflight input tokens",
+          "refId": "C"
+        },
+        {
+          "expr": "devshard_gateway_effective_max_input_tokens_in_flight",
+          "legendFormat": "input token cap",
+          "refId": "D"
+        }
+      ],
+      "title": "Active Requests and Input Tokens",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Capacity scale over time by model.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 13
+      },
+      "id": 98,
+      "targets": [
+        {
+          "expr": "devshard_gateway_capacity_scale_by_model{model=~\"$model\"}",
+          "refId": "A",
+          "legendFormat": "{{model}}"
+        }
+      ],
+      "title": "Model Capacity Scale by Model",
+      "type": "timeseries",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "percentunit"
+        }
+      }
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Successful user requests that hid participant or policy failures.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 44
+      },
+      "id": 99,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_user_requests_with_hidden_failure_total{model=~\"$model\",reason=~\"$reason\"}[$__rate_interval])) by (reason)",
+          "refId": "A",
+          "legendFormat": "{{reason}}"
+        }
+      ],
+      "title": "Successful Requests with Hidden Participant Failures by Reason",
+      "type": "timeseries",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      }
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 36
+      },
+      "id": 105,
+      "panels": [],
+      "title": "Suspect Addresses (start here)",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Address-level suspect queue. Counts are selected-window increases; rates use finished or started attempts as stated in the column header.",
+      "gridPos": {
+        "h": 12,
+        "w": 24,
+        "x": 0,
+        "y": 45
+      },
+      "id": 103,
+      "targets": [
+        {
+          "expr": "round(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "A",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(sum by (participant_key, model) (increase(devshard_gateway_attempts_terminal_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "B",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_terminal_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_terminal_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts))",
+          "refId": "C",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts))",
+          "refId": "D",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "E",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "F",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "G",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "H",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "I",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "J",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "round(((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts)))",
+          "refId": "K",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_first_content_seconds_bucket{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le)) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts))",
+          "refId": "L",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_receipt_seconds_bucket{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le)) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts))",
+          "refId": "M",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_prefill_seconds_per_input_token_bucket{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le)) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts))",
+          "refId": "N",
+          "instant": true,
+          "format": "table"
+        },
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_total_attempt_seconds_bucket{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le)) and on (participant_key, model) topk(30, ((((sum by (participant_key, model) (increase(devshard_gateway_attempt_failures_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_slot_decisions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",decision!=\"real_send\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_no_winner_attempts_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_timeout_actions_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_transport_errors_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\",path_kind=\"inference\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])))) + ((sum by (participant_key, model) (increase(devshard_gateway_participant_limit_rejections_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))) or on (participant_key, model) (0 * sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range]))))) / clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)) and on (participant_key, model) (sum by (participant_key, model) (increase(devshard_gateway_attempts_started_total{participant_key!=\"unknown\",participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) >= $min_attempts))",
+          "refId": "O",
+          "instant": true,
+          "format": "table"
+        }
+      ],
+      "title": "Suspect Address Scorecard",
+      "type": "table",
+      "fieldConfig": {
+        "defaults": {
+          "links": [
+            {
+              "title": "Drill into this address",
+              "url": "/d/gonka-gateway-observability/gonka-gateway-observability?var-model=${__data.fields.model}&var-participant_key=${__data.fields.participant_key}"
+            }
+          ]
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "participant_key"
+            },
+            "properties": [
+              {
+                "id": "custom.width",
+                "value": 360
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "model"
+            },
+            "properties": [
+              {
+                "id": "custom.width",
+                "value": 220
+              }
+            ]
+          }
+        ]
+      },
+      "transformations": [
+        {
+          "id": "merge",
+          "options": {}
+        },
+        {
+          "id": "organize",
+          "options": {
+            "excludeByName": {
+              "Time": true,
+              "__name__": true
+            },
+            "indexByName": {
+              "participant_key": 0,
+              "model": 1,
+              "Value #A": 2,
+              "Value #B": 3,
+              "Value #C": 4,
+              "Value #D": 5,
+              "Value #E": 6,
+              "Value #F": 7,
+              "Value #G": 8,
+              "Value #H": 9,
+              "Value #I": 10,
+              "Value #J": 11,
+              "Value #K": 12,
+              "Value #L": 13,
+              "Value #M": 14,
+              "Value #N": 15,
+              "Value #O": 16
+            },
+            "renameByName": {
+              "participant_key": "participant_key",
+              "model": "model",
+              "Value #A": "started_attempts\ncount",
+              "Value #B": "finished_attempts\ncount",
+              "Value #C": "failure_rate\nfailed/finished",
+              "Value #D": "issues_per_started\ncount/start",
+              "Value #E": "issue_count\ncount",
+              "Value #F": "failed_attempts\ncount",
+              "Value #G": "no_send_slots\ncount",
+              "Value #H": "no_winner_attempts\ncount",
+              "Value #I": "timeout_skipped_failed\ncount",
+              "Value #J": "inference_transport_errors\ncount",
+              "Value #K": "limit_rejections\ncount",
+              "Value #L": "p95_ttft_first_content\nseconds",
+              "Value #M": "p95_receipt\nseconds",
+              "Value #N": "p95_prefill_per_input_token\nseconds",
+              "Value #O": "p95_total_attempt\nseconds",
+              "Value": "started_attempts\ncount"
+            }
+          }
+        }
+      ]
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 57
+      },
+      "id": 106,
+      "panels": [],
+      "title": "Explain Selected Participant",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Sent attempts by role and start reason.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 58
+      },
+      "id": 14,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_attempts_started_total{participant_key=~\"$participant_key\",model=~\"$model\",reason=~\"$reason\"}[$__rate_interval])) by (role, reason)",
+          "legendFormat": "{{role}} / {{reason}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Real Attempts Started by Role and Reason",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Terminal attempt outcomes by visibility.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 8,
+        "y": 58
+      },
+      "id": 15,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_attempts_terminal_total{participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (outcome, visibility)",
+          "legendFormat": "{{outcome}} / {{visibility}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Terminal Attempts by Outcome and Visibility",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Failed attempts with reason preserved.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 58
+      },
+      "id": 16,
+      "targets": [
+        {
+          "expr": "topk(12, sum(rate(devshard_gateway_attempt_failures_total{participant_key=~\"$participant_key\",model=~\"$model\",reason=~\"$reason\"}[$__rate_interval])) by (reason, visibility))",
+          "legendFormat": "{{reason}} / {{visibility}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Failed Attempts by Reason and Visibility",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Share of attributed user-visible wins by address.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 0,
+        "y": 66
+      },
+      "id": 17,
+      "targets": [
+        {
+          "expr": "topk(20, (sum by (participant_key, model) (increase(devshard_gateway_user_visible_wins_total{participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) / clamp_min(sum by (model) (increase(devshard_gateway_user_visible_wins_total{model=~\"$model\"}[$__range])), 1)))",
+          "refId": "A",
+          "instant": true
+        }
+      ],
+      "title": "User-Visible Winner Share by Participant",
+      "type": "table",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "percentunit",
+          "decimals": 2,
+          "min": 0,
+          "max": 1
+        }
+      }
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Count of attributed user-visible wins by address.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 8,
+        "y": 66
+      },
+      "id": 76,
+      "targets": [
+        {
+          "expr": "topk(20, sum(increase(devshard_gateway_user_visible_wins_total{participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])) by (participant_key, model))",
+          "refId": "A",
+          "instant": true
+        }
+      ],
+      "title": "User-Visible Winner Count by Participant",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Receipt p95 by address and model.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 66
+      },
+      "id": 101,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_receipt_seconds_bucket{participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le))",
+          "refId": "A",
+          "legendFormat": "{{participant_key}} / {{model}}"
+        }
+      ],
+      "title": "Participant Receipt p95 by Address",
+      "type": "timeseries",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "s"
+        }
+      }
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "TTFT-equivalent first-content p95 by address and model.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "s"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 74
+      },
+      "id": 22,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_first_content_seconds_bucket{participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le))",
+          "legendFormat": "{{participant_key}} / {{model}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Participant TTFT / First Content p95 by Address",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Prefill-after-receipt p95 per input token by address and model.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 8,
+        "y": 74
+      },
+      "id": 102,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_prefill_seconds_per_input_token_bucket{participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le))",
+          "refId": "A",
+          "legendFormat": "{{participant_key}} / {{model}}"
+        }
+      ],
+      "title": "Participant Prefill per Input Token p95 by Address",
+      "type": "timeseries",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "s"
+        }
+      }
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Address-level total attempt p95.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "s"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 74
+      },
+      "id": 24,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.95, sum(rate(devshard_gateway_participant_total_attempt_seconds_bucket{participant_key=~\"$participant_key\",model=~\"$model\"}[$__rate_interval])) by (participant_key, model, le))",
+          "legendFormat": "{{participant_key}} / {{model}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Participant Total Attempt Time p95 by Address",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "No-receipt and empty-stream failures divided by finished attempts.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "max": 1,
+          "min": 0,
+          "unit": "percentunit"
+        }
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 0,
+        "y": 82
+      },
+      "id": 47,
+      "targets": [
+        {
+          "expr": "topk(20, (sum by (participant_key, model, reason) (increase(devshard_gateway_attempt_failures_total{participant_key=~\"$participant_key\",model=~\"$model\",reason=~\"no_receipt|empty_stream\"}[$__range])) / ignoring(reason) group_left clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_terminal_total{participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)))",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "No-Receipt and Empty-Stream Rates",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Transport and EOF failures divided by finished attempts.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "max": 1,
+          "min": 0,
+          "unit": "percentunit"
+        }
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 8,
+        "y": 82
+      },
+      "id": 48,
+      "targets": [
+        {
+          "expr": "topk(20, (sum by (participant_key, model, reason) (increase(devshard_gateway_attempt_failures_total{participant_key=~\"$participant_key\",model=~\"$model\",reason=~\"eof_transport|error_stream|transport_error\"}[$__range])) / ignoring(reason) group_left clamp_min(sum by (participant_key, model) (increase(devshard_gateway_attempts_terminal_total{participant_key=~\"$participant_key\",model=~\"$model\"}[$__range])), 1)))",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Transport and EOF Failure Rates",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Current quarantine or no-winner mode by address.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 16,
+        "y": 82
+      },
+      "id": 49,
+      "targets": [
+        {
+          "expr": "sum(devshard_gateway_participant_quarantine_state{participant_key=~\"$participant_key\",model=~\"$model\"}) by (participant_key, model, mode)",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Current Participant Quarantine Mode",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "User-visible winners that later recorded failures.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 0,
+        "y": 90
+      },
+      "id": 28,
+      "targets": [
+        {
+          "expr": "topk(15, sum(increase(devshard_gateway_attempt_failures_total{participant_key=~\"$participant_key\",model=~\"$model\",reason=~\"$reason\",visibility=\"user_visible_winner\"}[$__range])) by (participant_key, model, reason))",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Winner Failures After User-Visible Content",
+      "type": "table"
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 98
+      },
+      "id": 107,
+      "panels": [],
+      "title": "Global Cost and Policy Pressure",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "All real sends divided by user requests.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 99
+      },
+      "id": 18,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_attempts_started_total{model=~\"$model\"}[$__rate_interval])) / clamp_min(sum(rate(devshard_gateway_requests_total{model=~\"$model\"}[$__rate_interval])), 0.001)",
+          "legendFormat": "sent attempts / request",
+          "refId": "A"
+        }
+      ],
+      "title": "Global Sent Attempts per User Request",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Failed sends divided by successful user requests.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 8,
+        "y": 99
+      },
+      "id": 19,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_attempts_terminal_total{model=~\"$model\",outcome=~\"failed|not_finished\"}[$__rate_interval])) / clamp_min(sum(rate(devshard_gateway_requests_total{model=~\"$model\",outcome=\"success\"}[$__rate_interval])), 0.001)",
+          "legendFormat": "failed sent attempts / successful request",
+          "refId": "A"
+        }
+      ],
+      "title": "Global Failed Sends per Successful User Request",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Extra-role sends divided by user requests.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 99
+      },
+      "id": 31,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_attempts_started_total{model=~\"$model\",role=\"extra\"}[$__rate_interval])) / clamp_min(sum(rate(devshard_gateway_requests_total{model=~\"$model\"}[$__rate_interval])), 0.001)",
+          "legendFormat": "extra sends / request",
+          "refId": "A"
+        }
+      ],
+      "title": "Extra Real Sends per User Request",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "No-send slot decisions divided by user requests.",
+      "fieldConfig": {
+        "defaults": {
+          "decimals": 2,
+          "unit": "short"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 107
+      },
+      "id": 32,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_slot_decisions_total{model=~\"$model\",escrow_id=~\"$escrow_id\",decision!=\"real_send\"}[$__rate_interval])) / clamp_min(sum(rate(devshard_gateway_requests_total{model=~\"$model\"}[$__rate_interval])), 0.001)",
+          "legendFormat": "no-send slots / request",
+          "refId": "A"
+        }
+      ],
+      "title": "Ghost or No-Send Slots per User Request",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Top no-send slot reasons.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 8,
+        "y": 107
+      },
+      "id": 38,
+      "targets": [
+        {
+          "expr": "topk(20, sum(increase(devshard_gateway_slot_decisions_total{model=~\"$model\",escrow_id=~\"$escrow_id\",reason=~\"$reason\",decision!=\"real_send\"}[$__range])) by (reason, quarantine_mode))",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Top Skipped-Slot Reasons",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Expected, started, completed, skipped, and failed timeout work.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 107
+      },
+      "id": 100,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_timeout_actions_total{participant_key=~\"$participant_key\",model=~\"$model\",reason=~\"$reason\"}[$__rate_interval])) by (kind, action)",
+          "refId": "A",
+          "legendFormat": "{{kind}} / {{action}}"
+        }
+      ],
+      "title": "Timeout Actions by Kind and Action",
+      "type": "timeseries",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      }
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Skipped and failed timeout work by reason.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 115
+      },
+      "id": 58,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_timeout_actions_total{participant_key=~\"$participant_key\",model=~\"$model\",action=~\"skipped|failed\",reason=~\"$reason\"}[$__rate_interval])) by (action, reason)",
+          "legendFormat": "{{action}} / {{reason}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Timeout Skip and Failure Reasons Over Time",
+      "type": "timeseries"
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 123
+      },
+      "id": 108,
+      "panels": [],
+      "title": "Escrow and Runtime Diagnostics",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "No-send pressure by model and escrow.",
+      "gridPos": {
+        "h": 8,
+        "w": 8,
+        "x": 0,
+        "y": 124
+      },
+      "id": 53,
+      "targets": [
+        {
+          "expr": "topk(40, sum(increase(devshard_gateway_slot_decisions_total{model=~\"$model\",escrow_id=~\"$escrow_id\",decision!=\"real_send\"}[$__range])) by (model, escrow_id, reason))",
+          "instant": true,
+          "refId": "A"
+        }
+      ],
+      "title": "Model x Escrow No-Send Pressure",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Runtime picker choices by selected escrow and model.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 8,
+        "y": 124
+      },
+      "id": 54,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_picker_choice_total{model=~\"$model\",devshard_id=~\"$escrow_id\"}[$__rate_interval])) by (devshard_id, model)",
+          "legendFormat": "{{devshard_id}} / {{model}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Runtime Picker Choices by Model and Escrow",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Blocked participant count by selected escrow and model.",
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 16,
+        "y": 124
+      },
+      "id": 42,
+      "targets": [
+        {
+          "expr": "devshard_gateway_escrow_blocked_participants{model=~\"$model\",devshard_id=~\"$escrow_id\"}",
+          "legendFormat": "{{devshard_id}} / {{model}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Escrow Blocked Participant Count",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "prometheus"
+      },
+      "description": "Transport errors outside inference path, such as timeout verification, challenge receipt, gossip, or query paths.",
+      "fieldConfig": {
+        "defaults": {
+          "unit": "rps"
+        }
+      },
+      "gridPos": {
+        "h": 7,
+        "w": 8,
+        "x": 0,
+        "y": 132
+      },
+      "id": 109,
+      "targets": [
+        {
+          "expr": "sum(rate(devshard_gateway_participant_transport_errors_total{path_kind!=\"inference\"}[$__rate_interval])) by (path_kind, status)",
+          "legendFormat": "{{path_kind}} / {{status}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Non-Inference Transport Errors by Path",
+      "type": "timeseries"
+    }
+  ],
+  "refresh": "30s",
+  "schemaVersion": 39,
+  "tags": [
+    "gateway",
+    "devshard",
+    "observability"
+  ],
+  "templating": {
+    "list": [
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": "All",
+          "value": "$__all"
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "prometheus"
+        },
+        "definition": "label_values({__name__=~\"devshard_gateway_capacity_scale_by_model|devshard_gateway_requests_total|devshard_gateway_attempts_started_total|devshard_gateway_attempt_failures_total|devshard_gateway_slot_decisions_total|devshard_gateway_timeout_actions_total\"}, model)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "model",
+        "name": "model",
+        "query": {
+          "query": "label_values({__name__=~\"devshard_gateway_capacity_scale_by_model|devshard_gateway_requests_total|devshard_gateway_attempts_started_total|devshard_gateway_attempt_failures_total|devshard_gateway_slot_decisions_total|devshard_gateway_timeout_actions_total\"}, model)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 1,
+        "type": "query"
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": "All",
+          "value": "$__all"
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "prometheus"
+        },
+        "definition": "label_values({__name__=~\"devshard_gateway_attempts_started_total|devshard_gateway_attempts_terminal_total|devshard_gateway_attempt_failures_total|devshard_gateway_user_visible_wins_total|devshard_gateway_slot_decisions_total|devshard_gateway_no_winner_attempts_total|devshard_gateway_participant_quarantine_state|devshard_gateway_timeout_actions_total\",model=~\"$model\"}, participant_key)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "participant_key (optional drilldown)",
+        "name": "participant_key",
+        "query": {
+          "query": "label_values({__name__=~\"devshard_gateway_attempts_started_total|devshard_gateway_attempts_terminal_total|devshard_gateway_attempt_failures_total|devshard_gateway_user_visible_wins_total|devshard_gateway_slot_decisions_total|devshard_gateway_no_winner_attempts_total|devshard_gateway_participant_quarantine_state|devshard_gateway_timeout_actions_total\",model=~\"$model\"}, participant_key)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 1,
+        "type": "query"
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": "All",
+          "value": "$__all"
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "prometheus"
+        },
+        "definition": "label_values({__name__=~\"devshard_gateway_attempt_failures_total|devshard_gateway_user_requests_with_hidden_failure_total|devshard_gateway_slot_decisions_total|devshard_gateway_timeout_actions_total|devshard_gateway_critical_user_failures_total|devshard_gateway_no_winner_attempts_total\",model=~\"$model\"}, reason)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "reason (optional detail filter)",
+        "name": "reason",
+        "query": {
+          "query": "label_values({__name__=~\"devshard_gateway_attempt_failures_total|devshard_gateway_user_requests_with_hidden_failure_total|devshard_gateway_slot_decisions_total|devshard_gateway_timeout_actions_total|devshard_gateway_critical_user_failures_total|devshard_gateway_no_winner_attempts_total\",model=~\"$model\"}, reason)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 1,
+        "type": "query"
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "selected": true,
+          "text": "All",
+          "value": "$__all"
+        },
+        "datasource": {
+          "type": "prometheus",
+          "uid": "prometheus"
+        },
+        "definition": "label_values(devshard_gateway_slot_decisions_total{model=~\"$model\"}, escrow_id)",
+        "hide": 0,
+        "includeAll": true,
+        "label": "escrow_id",
+        "name": "escrow_id",
+        "query": {
+          "query": "label_values(devshard_gateway_slot_decisions_total{model=~\"$model\"}, escrow_id)",
+          "refId": "PrometheusVariableQueryEditor-VariableQuery"
+        },
+        "refresh": 1,
+        "type": "query"
+      },
+      {
+        "current": {
+          "selected": true,
+          "text": "20",
+          "value": "20"
+        },
+        "hide": 0,
+        "label": "min_attempts",
+        "name": "min_attempts",
+        "query": "5,10,20,50,100",
+        "type": "custom"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-6h",
+    "to": "now"
+  },
+  "timezone": "",
+  "title": "Gonka Gateway Observability",
+  "uid": "gonka-gateway-observability",
+  "version": 17,
+  "weekStart": ""
+}
diff --git a/deploy/join/observability/prometheus.yml b/deploy/join/observability/prometheus.yml
index 0f211028d9..cac325e7ad 100644
--- a/deploy/join/observability/prometheus.yml
+++ b/deploy/join/observability/prometheus.yml
@@ -19,6 +19,12 @@ scrape_configs:
       - url: http://api:9100/sd/devshardd
         refresh_interval: 15s
 
+  - job_name: devshard-gateway
+    metrics_path: /metrics
+    static_configs:
+      - targets:
+          - devshard-gateway:8080
+
   - job_name: gonka-node
     static_configs:
       - targets:
@@ -36,4 +42,3 @@ scrape_configs:
     static_configs:
       - targets:
           - cadvisor:8080
-
diff --git a/devshard/Dockerfile b/devshard/Dockerfile
index 718466cbad..2353086fc3 100644
--- a/devshard/Dockerfile
+++ b/devshard/Dockerfile
@@ -3,10 +3,12 @@
 ################################################################################
 # Build — runs on the native platform, cross-compiles via GOOS/GOARCH
 ################################################################################
-FROM --platform=$BUILDPLATFORM golang:1.24.2-alpine3.20 AS builder
+FROM --platform=$BUILDPLATFORM golang:1.24.2-alpine3.21 AS builder
 
 ARG TARGETOS
 ARG TARGETARCH
+ARG DEVSHARD_VERSION=dev
+ARG DEVSHARD_PROTOCOL_VERSION=v2
 
 WORKDIR /app
 
@@ -20,12 +22,13 @@ COPY . .
 RUN --mount=type=cache,id=go-build-cache-devshard,target=/root/.cache/go-build \
     --mount=type=cache,id=go-mod-cache-devshard,target=/go/pkg/mod \
     CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
-    go build -o /devshardctl ./cmd/devshardctl/
+    go build -ldflags "-X main.Version=${DEVSHARD_VERSION} -X devshard/types.buildStateRootProtocolVersion=${DEVSHARD_PROTOCOL_VERSION}" \
+    -o /devshardctl ./cmd/devshardctl/
 
 ################################################################################
 # Final image
 ################################################################################
-FROM alpine:3.18
+FROM alpine:3.21
 
 RUN apk add --no-cache ca-certificates curl && \
     rm -rf /var/cache/apk/*
diff --git a/devshard/bridge/config.go b/devshard/bridge/config.go
new file mode 100644
index 0000000000..a5dfae7947
--- /dev/null
+++ b/devshard/bridge/config.go
@@ -0,0 +1,39 @@
+package bridge
+
+import (
+	"devshard/logging"
+	"devshard/types"
+)
+
+// SessionConfigAtBind builds the session config from per-escrow chain fields (lane A).
+// Zero ValidationRate (older chain/dapi that omit the field) falls through to
+// types.DefaultValidationRate via SessionConfigFromEscrow.
+func SessionConfigAtBind(groupSize int, escrow *EscrowInfo) types.SessionConfig {
+	var escrowID string
+	var escrowRate uint32
+	var cfg types.SessionConfig
+	if escrow == nil {
+		cfg = types.SessionConfigFromEscrow(groupSize, types.EscrowSessionFields{})
+	} else {
+		escrowID = escrow.EscrowID
+		escrowRate = escrow.ValidationRate
+		cfg = types.SessionConfigFromEscrow(groupSize, types.EscrowSessionFields{
+			TokenPrice:                escrow.TokenPrice,
+			CreateDevshardFee:         escrow.CreateDevshardFee,
+			FeePerNonce:               escrow.FeePerNonce,
+			InferenceSealGraceNonces:  escrow.InferenceSealGraceNonces,
+			InferenceSealGraceSeconds: escrow.InferenceSealGraceSeconds,
+			AutoSealEveryNNonces:      escrow.AutoSealEveryNNonces,
+			ValidationRate:            escrow.ValidationRate,
+		})
+	}
+	logging.Debug("validation_rate_bound",
+		"subsystem", "validation",
+		"escrow_id", escrowID,
+		"escrow_validation_rate", escrowRate,
+		"applied_validation_rate", cfg.ValidationRate,
+		"default_validation_rate", types.DefaultValidationRate,
+		"used_default", escrowRate == 0,
+	)
+	return cfg
+}
diff --git a/devshard/bridge/config_test.go b/devshard/bridge/config_test.go
new file mode 100644
index 0000000000..d1f2b715a0
--- /dev/null
+++ b/devshard/bridge/config_test.go
@@ -0,0 +1,41 @@
+package bridge
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"devshard/types"
+)
+
+func TestSessionConfigAtBind_EscrowLaneA(t *testing.T) {
+	const groupSize = 16
+	escrow := &EscrowInfo{
+		TokenPrice:                1,
+		CreateDevshardFee:         10_000,
+		FeePerNonce:               1_000,
+		InferenceSealGraceNonces:  55,
+		InferenceSealGraceSeconds: 77,
+		AutoSealEveryNNonces:      16,
+		ValidationRate:            6000,
+	}
+
+	cfg := SessionConfigAtBind(groupSize, escrow)
+	require.Equal(t, uint32(55), cfg.InferenceSealGraceNonces)
+	require.Equal(t, uint32(77), cfg.InferenceSealGraceSeconds)
+	require.Equal(t, uint32(16), cfg.AutoSealEveryNNonces)
+	assert.Equal(t, uint32(6000), cfg.ValidationRate)
+}
+
+func TestSessionConfigAtBind_ZeroValidationRateUsesDefault(t *testing.T) {
+	const groupSize = 16
+	cfg := SessionConfigAtBind(groupSize, &EscrowInfo{TokenPrice: 1})
+	assert.Equal(t, types.DefaultValidationRate, cfg.ValidationRate)
+}
+
+func TestSessionConfigAtBind_NilEscrowUsesDefaults(t *testing.T) {
+	const groupSize = 16
+	cfg := SessionConfigAtBind(groupSize, nil)
+	assert.Equal(t, types.DefaultValidationRate, cfg.ValidationRate)
+}
diff --git a/devshard/bridge/interface.go b/devshard/bridge/interface.go
index e986879a4e..a194ac0ecc 100644
--- a/devshard/bridge/interface.go
+++ b/devshard/bridge/interface.go
@@ -27,17 +27,18 @@ type SessionBindParamsBridge interface {
 }
 
 type EscrowInfo struct {
-	EscrowID       string
-	Amount         uint64
-	CreatorAddress string
-	AppHash        []byte
-	Slots          []string // host addresses, len == DevshardGroupSize
+	EscrowID                  string
+	Amount                    uint64
+	CreatorAddress            string
+	AppHash                   []byte
+	Slots                     []string // host addresses, len == DevshardGroupSize
 	TokenPrice                uint64
 	CreateDevshardFee         uint64
 	FeePerNonce               uint64
 	InferenceSealGraceNonces  uint32
 	InferenceSealGraceSeconds uint32
 	AutoSealEveryNNonces      uint32
+	ValidationRate            uint32
 	// EpochID is the chain epoch_index recorded on the on-chain DevshardEscrow.
 	// Storage uses it as the partition/pruning key.
 	EpochID uint64
diff --git a/devshard/bridge/rest.go b/devshard/bridge/rest.go
index 8ef0041591..cd10e9e5a4 100644
--- a/devshard/bridge/rest.go
+++ b/devshard/bridge/rest.go
@@ -61,6 +61,7 @@ type escrowResponse struct {
 		InferenceSealGraceNonces  uint32 `json:"inference_seal_grace_nonces"`
 		InferenceSealGraceSeconds uint32 `json:"inference_seal_grace_seconds"`
 		AutoSealEveryNNonces      uint32 `json:"auto_seal_every_n_nonces"`
+		ValidationRate            uint32 `json:"validation_rate"`
 	} `json:"escrow"`
 	Found bool `json:"found"`
 }
@@ -157,6 +158,7 @@ func (b *RESTBridge) GetEscrow(escrowID string) (*EscrowInfo, error) {
 		InferenceSealGraceNonces:  resp.Escrow.InferenceSealGraceNonces,
 		InferenceSealGraceSeconds: resp.Escrow.InferenceSealGraceSeconds,
 		AutoSealEveryNNonces:      resp.Escrow.AutoSealEveryNNonces,
+		ValidationRate:            resp.Escrow.ValidationRate,
 		EpochID:                   resp.Escrow.EpochIndex,
 	}, nil
 }
diff --git a/devshard/bridge/rest_test.go b/devshard/bridge/rest_test.go
index 02ff3aabe8..762b993f91 100644
--- a/devshard/bridge/rest_test.go
+++ b/devshard/bridge/rest_test.go
@@ -30,6 +30,7 @@ func TestGetEscrow_HappyPath(t *testing.T) {
 				"inference_seal_grace_nonces":  160,
 				"inference_seal_grace_seconds": 3600,
 				"auto_seal_every_n_nonces":     150,
+				"validation_rate":              6000,
 			},
 			"found": true,
 		})
@@ -50,6 +51,7 @@ func TestGetEscrow_HappyPath(t *testing.T) {
 	assert.Equal(t, uint32(160), info.InferenceSealGraceNonces)
 	assert.Equal(t, uint32(3600), info.InferenceSealGraceSeconds)
 	assert.Equal(t, uint32(150), info.AutoSealEveryNNonces)
+	assert.Equal(t, uint32(6000), info.ValidationRate)
 }
 
 func TestGetEscrow_GraceFieldsNumeric(t *testing.T) {
@@ -95,6 +97,7 @@ func TestGetEscrow_FeesMissingKeysDecodeZero(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, uint64(0), info.CreateDevshardFee)
 	assert.Equal(t, uint64(0), info.FeePerNonce)
+	assert.Equal(t, uint32(0), info.ValidationRate, "missing validation_rate decodes as zero (unset)")
 }
 
 func TestGetEscrow_DoesNotQueryParams(t *testing.T) {
diff --git a/devshard/cmd/devshardctl/capacity_state.go b/devshard/cmd/devshardctl/capacity_state.go
index 21040fa108..8e7b40722d 100644
--- a/devshard/cmd/devshardctl/capacity_state.go
+++ b/devshard/cmd/devshardctl/capacity_state.go
@@ -44,7 +44,7 @@ type CapacityState struct {
 	// outside PoC (steady-state baseline). currentWeights is the
 	// latest poll (matches fullWeights outside PoC, may be reduced
 	// during PoC). Only the keys we have actually observed appear in
-	// each map; absence means "unknown" -> fall back to 1.0.
+	// each map; absence means "unknown" -> weight 0.
 	fullWeights    map[string]float64
 	currentWeights map[string]float64
 
@@ -193,6 +193,36 @@ func (m *CapacityState) SetHostWeightsByModel(weights map[string]map[string]floa
 	}
 }
 
+// SetHostWeightViews replaces the current and full capacity views atomically.
+// Use this when the chain response contains enough data to compute both the
+// PoC-filtered current view and the all-node full baseline in the same poll.
+func (m *CapacityState) SetHostWeightViews(currentWeights, fullWeights map[string]float64, currentWeightsByModel, fullWeightsByModel map[string]map[string]float64) {
+	if m == nil {
+		return
+	}
+	current := cleanHostWeights(currentWeights)
+	full := cleanHostWeights(fullWeights)
+	currentByModel := cleanModelWeights(currentWeightsByModel)
+	fullByModel := cleanModelWeights(fullWeightsByModel)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.currentWeights = current
+	m.fullWeights = full
+	m.currentWeightsByModel = currentByModel
+	m.fullWeightsByModel = fullByModel
+}
+
+func cleanHostWeights(weights map[string]float64) map[string]float64 {
+	clean := make(map[string]float64, len(weights))
+	for k, w := range weights {
+		if k == "" || w < 0 {
+			continue
+		}
+		clean[k] = w
+	}
+	return clean
+}
+
 func cleanModelWeights(weights map[string]map[string]float64) map[string]map[string]float64 {
 	clean := make(map[string]map[string]float64, len(weights))
 	for rawModel, hostWeights := range weights {
@@ -286,13 +316,12 @@ func (m *CapacityState) hostAvailableLocked(host string) bool {
 }
 
 // hostCurrentWeightLocked returns the current raw poc_weight capacity for the
-// host or 1.0 if the state has no entry (best-effort fallback so
-// routing still works before the first chain fetch lands).
+// host or 0 if the state has no entry.
 func (m *CapacityState) hostCurrentWeightLocked(host string) float64 {
 	if w, ok := m.currentWeights[host]; ok {
 		return w
 	}
-	return 1.0
+	return 0
 }
 
 func (m *CapacityState) hostCurrentWeightForModelLocked(host, model string) float64 {
@@ -308,12 +337,12 @@ func (m *CapacityState) hostCurrentWeightForModelLocked(host, model string) floa
 }
 
 // hostFullWeightLocked returns the steady-state raw poc_weight capacity for the
-// host or 1.0 if no Inference-phase observation has landed yet.
+// host or 0 if no observation has landed yet.
 func (m *CapacityState) hostFullWeightLocked(host string) float64 {
 	if w, ok := m.fullWeights[host]; ok {
 		return w
 	}
-	return 1.0
+	return 0
 }
 
 func (m *CapacityState) hostFullWeightForModelLocked(host, model string) float64 {
diff --git a/devshard/cmd/devshardctl/capacity_state_test.go b/devshard/cmd/devshardctl/capacity_state_test.go
index 2643ad4927..8a48e68f71 100644
--- a/devshard/cmd/devshardctl/capacity_state_test.go
+++ b/devshard/cmd/devshardctl/capacity_state_test.go
@@ -49,11 +49,13 @@ func TestCapacityStateLiveAvailabilityScalesWeights(t *testing.T) {
 	require.InDelta(t, 1.0, m.EscrowWeight("X"), 1e-9)
 }
 
-func TestCapacityStateMissingHostFallsBackToWeightOne(t *testing.T) {
+func TestCapacityStateMissingHostHasZeroWeight(t *testing.T) {
 	m := NewCapacityState()
 	m.SetEscrowMembership("X", map[string]int{"A": 1})
-	// No SetHostWeights call - never observed -> fallback to 1.
-	require.InDelta(t, 1.0, m.EscrowWeight("X"), 1e-9)
+	// Unknown capacity must stay zero; inventing weight here breaks
+	// capacity-derived concurrency on cold starts during PoC/CPoC.
+	require.InDelta(t, 0.0, m.EscrowWeight("X"), 1e-9)
+	require.InDelta(t, 0.0, m.BaselineWeight(), 1e-9)
 }
 
 func TestCapacityStateBaselineFromFullWeightsNotFrozen(t *testing.T) {
@@ -118,6 +120,27 @@ func TestCapacityStateUsesModelSpecificPoCWeights(t *testing.T) {
 	require.InDelta(t, 90.0/300.0, m.ScaleFactorAcrossModels(), 1e-9)
 }
 
+func TestCapacityStateCanSeedFullBaselineDuringPoCColdStart(t *testing.T) {
+	m := NewCapacityState()
+	m.SetEscrowMembership("X", map[string]int{"A": 1, "B": 1})
+
+	m.SetHostWeightViews(
+		map[string]float64{"A": 40, "B": 0},
+		map[string]float64{"A": 100, "B": 50},
+		map[string]map[string]float64{
+			"Model/A": {"A": 40, "B": 0},
+		},
+		map[string]map[string]float64{
+			"Model/A": {"A": 100, "B": 50},
+		},
+	)
+	m.SetPoCPreserved([]string{"A"})
+
+	require.InDelta(t, 40.0, m.TotalWeightForModel("Model/A"), 1e-9)
+	require.InDelta(t, 150.0, m.BaselineWeightForModel("Model/A"), 1e-9)
+	require.InDelta(t, 40.0/150.0, m.ScaleFactorForModel("Model/A"), 1e-9)
+}
+
 func TestGatewayLimiterModelScalesUseIndependentModelCapacity(t *testing.T) {
 	g := NewGateway(nil, NewGatewayLimiter(4, 100), "Model/A")
 	g.limiter.UpdateLimits(4, 100, []GatewayModelLimitSettings{
@@ -307,9 +330,14 @@ func TestGatewaySelectsPoCWeightConcurrencyRate(t *testing.T) {
 	require.InDelta(t, 5.0, regular.MaxConcurrentPer10000Weight, 1e-9)
 
 	g.phaseGate = &ChainPhaseGate{}
-	g.phaseGate.storeSnapshot(ChainPhaseSnapshot{BlockReason: "confirmation_poc"})
+	g.phaseGate.storeSnapshot(ChainPhaseSnapshot{EpochPhase: epochPhasePoCGenerate, BlockReason: "poc"})
+	t.Cleanup(func() { setPoCPhaseState(false, "") })
 	poc := g.limiterCapacityForModel("Model/A")
 	require.InDelta(t, 10.0, poc.MaxConcurrentPer10000Weight, 1e-9)
+
+	g.phaseGate.storeSnapshot(ChainPhaseSnapshot{ConfirmationPoCPhase: confirmationPoCGeneration, BlockReason: "confirmation_poc"})
+	confirmationPoc := g.limiterCapacityForModel("Model/A")
+	require.InDelta(t, 10.0, confirmationPoc.MaxConcurrentPer10000Weight, 1e-9)
 }
 
 func TestGatewayLimiterAcquireBlocksWhenScaledToZero(t *testing.T) {
@@ -344,7 +372,7 @@ func TestGatewayLimiterUnlimitedBaselinePreservedUnderScale(t *testing.T) {
 
 func TestDevshardRuntimeLoadIsActivePerWeight(t *testing.T) {
 	rt := &devshardRuntime{}
-	rt.activeRequests.Store(2)
+	rt.activeUserRequests.Store(2)
 	rt.reservedTokens.Store(3) // reserved tokens no longer factor in.
 
 	require.InDelta(t, 0.5, rt.load(4.0), 1e-9)
diff --git a/devshard/cmd/devshardctl/chain_tx_rest.go b/devshard/cmd/devshardctl/chain_tx_rest.go
index c4fd182ddc..bf1e8ee1f2 100644
--- a/devshard/cmd/devshardctl/chain_tx_rest.go
+++ b/devshard/cmd/devshardctl/chain_tx_rest.go
@@ -3,7 +3,9 @@ package main
 import (
 	"bytes"
 	"context"
+	"crypto/sha256"
 	"encoding/base64"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -113,7 +115,49 @@ func NewRESTChainTxClient(cfg RESTChainTxConfig) (*RESTChainTxClient, error) {
 	}, nil
 }
 
-func (c *RESTChainTxClient) CreateDevshardEscrow(ctx context.Context, signer *signing.Secp256k1Signer, amount uint64, modelID string) (*CreateDevshardEscrowResult, error) {
+// txHashFromBytes returns the cosmos tx hash (uppercase-hex SHA-256 of the tx
+// bytes), computable before broadcast and equal to the hash the node returns.
+func txHashFromBytes(txBytes []byte) string {
+	sum := sha256.Sum256(txBytes)
+	return strings.ToUpper(hex.EncodeToString(sum[:]))
+}
+
+// errTxNotFound marks a tx that is not on chain (404) — distinct from one that
+// committed but failed. The tx may still land until its unordered TTL elapses.
+var errTxNotFound = errors.New("tx not found on chain")
+
+// GetTxEscrowID resolves a create tx hash to its escrow_id in one lookup;
+// found=false when the tx is absent or failed (no escrow), error when unreachable.
+func (c *RESTChainTxClient) GetTxEscrowID(ctx context.Context, txHash string) (uint64, bool, error) {
+	var lastErr error
+	hasNotFoundError := false
+	for _, baseURL := range c.txQueryBaseURLs() {
+		var payload txResponseEnvelope
+		err := c.getJSONFromBaseURL(ctx, baseURL, "/cosmos/tx/v1beta1/txs/"+url.PathEscape(txHash), &payload)
+		if err != nil {
+			if isNotFoundError(err) {
+				hasNotFoundError = true // this endpoint lacks it; try the fallback before deciding
+				continue
+			}
+			lastErr = fmt.Errorf("%s: %w", baseURL, err)
+			continue
+		}
+		if payload.TxResponse.Code != 0 {
+			return 0, false, nil // tx committed but failed → no escrow created
+		}
+		if escrowID, ok := payload.TxResponse.createdEscrowID(); ok {
+			return escrowID, true, nil
+		}
+		lastErr = fmt.Errorf("tx %s committed via %s but escrow_id event was not found", txHash, baseURL)
+	}
+	// Only conclude "not on chain" when every reachable endpoint agreed on 404.
+	if lastErr == nil && hasNotFoundError {
+		return 0, false, errTxNotFound
+	}
+	return 0, false, lastErr
+}
+
+func (c *RESTChainTxClient) CreateDevshardEscrow(ctx context.Context, signer *signing.Secp256k1Signer, amount uint64, modelID string, onPrepared func(txHash string) error) (*CreateDevshardEscrowResult, error) {
 	if c == nil {
 		return nil, fmt.Errorf("chain tx client is nil")
 	}
@@ -145,10 +189,20 @@ func (c *RESTChainTxClient) CreateDevshardEscrow(ctx context.Context, signer *si
 	if err != nil {
 		return nil, err
 	}
-	txHash, err := c.broadcastTx(ctx, txBytes)
+	// Record the intent (precomputed hash) before the irreversible broadcast; abort if it fails.
+	txHash := txHashFromBytes(txBytes)
+	if onPrepared != nil {
+		if err := onPrepared(txHash); err != nil {
+			return nil, fmt.Errorf("record escrow create intent before broadcast: %w", err)
+		}
+	}
+	broadcastHash, err := c.broadcastTx(ctx, txBytes)
 	if err != nil {
 		return nil, err
 	}
+	if !strings.EqualFold(broadcastHash, txHash) {
+		return nil, fmt.Errorf("tx hash mismatch: precomputed %s, node returned %s", txHash, broadcastHash)
+	}
 	escrowID, err := c.waitForCreatedEscrowID(ctx, txHash)
 	if err != nil {
 		return nil, err
@@ -315,6 +369,28 @@ func (c *RESTChainTxClient) getJSON(ctx context.Context, path string, out any) e
 	return c.getJSONFromBaseURL(ctx, c.baseURL, path, out)
 }
 
+// chainHTTPError is returned by getJSONFromBaseURL on non-200 responses.
+type chainHTTPError struct {
+	method string
+	path   string
+	status int
+	body   string
+}
+
+func (e *chainHTTPError) Error() string {
+	if e == nil {
+		return "chain HTTP error"
+	}
+	return fmt.Sprintf("%s %s status %d: %s", e.method, e.path, e.status, e.body)
+}
+
+func (e *chainHTTPError) StatusCode() int {
+	if e == nil {
+		return 0
+	}
+	return e.status
+}
+
 func (c *RESTChainTxClient) getJSONFromBaseURL(ctx context.Context, baseURL, path string, out any) error {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+path, nil)
 	if err != nil {
@@ -327,11 +403,23 @@ func (c *RESTChainTxClient) getJSONFromBaseURL(ctx context.Context, baseURL, pat
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
-		return fmt.Errorf("GET %s status %d: %s", path, resp.StatusCode, strings.TrimSpace(string(body)))
+		return &chainHTTPError{
+			method: http.MethodGet,
+			path:   path,
+			status: resp.StatusCode,
+			body:   strings.TrimSpace(string(body)),
+		}
 	}
 	return json.NewDecoder(resp.Body).Decode(out)
 }
 
+// isNotFoundError reports whether a chain GET failed with HTTP 404 rather than
+// a transient error.
+func isNotFoundError(err error) bool {
+	var httpErr *chainHTTPError
+	return errors.As(err, &httpErr) && httpErr.StatusCode() == http.StatusNotFound
+}
+
 func (c *RESTChainTxClient) postJSON(ctx context.Context, path string, in any, out any) error {
 	data, err := json.Marshal(in)
 	if err != nil {
diff --git a/devshard/cmd/devshardctl/chain_tx_rest_test.go b/devshard/cmd/devshardctl/chain_tx_rest_test.go
index 2798720727..b538192b65 100644
--- a/devshard/cmd/devshardctl/chain_tx_rest_test.go
+++ b/devshard/cmd/devshardctl/chain_tx_rest_test.go
@@ -3,6 +3,7 @@ package main
 import (
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -20,6 +21,7 @@ func TestRESTChainTxClient_CreateDevshardEscrow(t *testing.T) {
 	require.NoError(t, err)
 
 	var broadcastSeen bool
+	var expectedHash string
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/cosmos/auth/v1beta1/accounts/" + signer.Address():
@@ -44,18 +46,20 @@ func TestRESTChainTxClient_CreateDevshardEscrow(t *testing.T) {
 			require.NotEmpty(t, txBytes)
 			assertUnorderedTx(t, txBytes)
 			broadcastSeen = true
+			// A real node returns SHA-256(txBytes); the client precomputes the same.
+			expectedHash = txHashFromBytes(txBytes)
 			writeTestJSON(t, w, map[string]any{
 				"tx_response": map[string]any{
 					"code":   0,
-					"txhash": "ABC123",
+					"txhash": expectedHash,
 				},
 			})
-		case "/cosmos/tx/v1beta1/txs/ABC123":
+		case "/cosmos/tx/v1beta1/txs/" + expectedHash:
 			require.True(t, broadcastSeen)
 			writeTestJSON(t, w, map[string]any{
 				"tx_response": map[string]any{
 					"code":   0,
-					"txhash": "ABC123",
+					"txhash": expectedHash,
 					"events": []map[string]any{{
 						"type": "devshard_escrow_created",
 						"attributes": []map[string]string{{
@@ -81,10 +85,11 @@ func TestRESTChainTxClient_CreateDevshardEscrow(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	result, err := client.CreateDevshardEscrow(t.Context(), signer, 1_000_000, "Qwen/Test")
+	result, err := client.CreateDevshardEscrow(t.Context(), signer, 1_000_000, "Qwen/Test", nil)
 	require.NoError(t, err)
 	require.Equal(t, uint64(42), result.EscrowID)
-	require.Equal(t, "ABC123", result.TxHash)
+	require.NotEmpty(t, expectedHash)
+	require.Equal(t, expectedHash, result.TxHash)
 	require.Equal(t, signer.Address(), result.Creator)
 }
 
@@ -93,6 +98,7 @@ func TestRESTChainTxClient_CreateDevshardEscrowUsesTxQueryFallback(t *testing.T)
 	require.NoError(t, err)
 
 	var broadcastSeen bool
+	var expectedHash string
 	broadcastServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch r.URL.Path {
 		case "/cosmos/auth/v1beta1/accounts/" + signer.Address():
@@ -116,13 +122,14 @@ func TestRESTChainTxClient_CreateDevshardEscrowUsesTxQueryFallback(t *testing.T)
 			require.NoError(t, err)
 			assertUnorderedTx(t, txBytes)
 			broadcastSeen = true
+			expectedHash = txHashFromBytes(txBytes)
 			writeTestJSON(t, w, map[string]any{
 				"tx_response": map[string]any{
 					"code":   0,
-					"txhash": "FALLBACK123",
+					"txhash": expectedHash,
 				},
 			})
-		case "/cosmos/tx/v1beta1/txs/FALLBACK123":
+		case "/cosmos/tx/v1beta1/txs/" + expectedHash:
 			http.Error(w, `{"code":2,"message":"transaction indexing is disabled"}`, http.StatusInternalServerError)
 		default:
 			http.NotFound(w, r)
@@ -131,12 +138,12 @@ func TestRESTChainTxClient_CreateDevshardEscrowUsesTxQueryFallback(t *testing.T)
 	defer broadcastServer.Close()
 
 	queryServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(t, "/cosmos/tx/v1beta1/txs/FALLBACK123", r.URL.Path)
+		require.Equal(t, "/cosmos/tx/v1beta1/txs/"+expectedHash, r.URL.Path)
 		require.True(t, broadcastSeen)
 		writeTestJSON(t, w, map[string]any{
 			"tx_response": map[string]any{
 				"code":   0,
-				"txhash": "FALLBACK123",
+				"txhash": expectedHash,
 				"events": []map[string]any{{
 					"type": "devshard_escrow_created",
 					"attributes": []map[string]string{{
@@ -160,13 +167,124 @@ func TestRESTChainTxClient_CreateDevshardEscrowUsesTxQueryFallback(t *testing.T)
 	})
 	require.NoError(t, err)
 
-	result, err := client.CreateDevshardEscrow(t.Context(), signer, 1_000_000, "Qwen/Test")
+	result, err := client.CreateDevshardEscrow(t.Context(), signer, 1_000_000, "Qwen/Test", nil)
 	require.NoError(t, err)
 	require.Equal(t, uint64(43), result.EscrowID)
-	require.Equal(t, "FALLBACK123", result.TxHash)
+	require.NotEmpty(t, expectedHash)
+	require.Equal(t, expectedHash, result.TxHash)
 	require.Equal(t, signer.Address(), result.Creator)
 }
 
+// escrowIDQueryServer returns a query endpoint that replies with a committed
+// create tx carrying an escrow_id event for txHash, and 404 for anything else.
+func escrowIDQueryServer(t *testing.T, txHash string, escrowID uint64) *httptest.Server {
+	t.Helper()
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cosmos/tx/v1beta1/txs/"+txHash {
+			http.NotFound(w, r)
+			return
+		}
+		writeTestJSON(t, w, map[string]any{
+			"tx_response": map[string]any{
+				"code":   0,
+				"txhash": txHash,
+				"events": []map[string]any{{
+					"type":       "devshard_escrow_created",
+					"attributes": []map[string]string{{"key": "escrow_id", "value": fmt.Sprintf("%d", escrowID)}},
+				}},
+			},
+		})
+	}))
+}
+
+func TestIsNotFoundError_Status404(t *testing.T) {
+	err := fmt.Errorf("http://primary: %w", &chainHTTPError{
+		method: http.MethodGet,
+		path:   "/cosmos/tx/v1beta1/txs/ABC",
+		status: http.StatusNotFound,
+		body:   "tx not found",
+	})
+	require.True(t, isNotFoundError(err))
+}
+
+func TestIsNotFoundError_500WithNotFoundBody(t *testing.T) {
+	err := fmt.Errorf("http://fallback: %w", &chainHTTPError{
+		method: http.MethodGet,
+		path:   "/cosmos/tx/v1beta1/txs/ABC",
+		status: http.StatusInternalServerError,
+		body:   `{"message":"tx not found"}`,
+	})
+	require.False(t, isNotFoundError(err))
+
+	var httpErr *chainHTTPError
+	require.True(t, errors.As(err, &httpErr))
+	require.Equal(t, http.StatusInternalServerError, httpErr.StatusCode())
+}
+
+// TestRESTChainTxClient_GetTxEscrowIDTriesFallbackOn404 pins the recovery path:
+// when the primary node has not indexed the create tx (404), the escrow_id must
+// still be resolved from the fallback query URL rather than reported missing.
+func TestRESTChainTxClient_GetTxEscrowIDTriesFallbackOn404(t *testing.T) {
+	const txHash = "ABC123"
+	primary := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.NotFound(w, r) // primary hasn't indexed the tx yet
+	}))
+	defer primary.Close()
+	fallback := escrowIDQueryServer(t, txHash, 77)
+	defer fallback.Close()
+
+	client, err := NewRESTChainTxClient(RESTChainTxConfig{BaseURL: primary.URL, TxQueryURL: fallback.URL, ChainID: "gonka-test"})
+	require.NoError(t, err)
+
+	escrowID, found, err := client.GetTxEscrowID(t.Context(), txHash)
+	require.NoError(t, err)
+	require.True(t, found)
+	require.Equal(t, uint64(77), escrowID)
+}
+
+// TestRESTChainTxClient_GetTxEscrowIDNotFoundWhenAllEndpoints404 confirms the
+// only-after-all-endpoints semantics: errTxNotFound is returned solely when
+// every reachable endpoint agrees the tx is absent.
+func TestRESTChainTxClient_GetTxEscrowIDNotFoundWhenAllEndpoints404(t *testing.T) {
+	notFound := func() *httptest.Server {
+		return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.NotFound(w, r) }))
+	}
+	primary := notFound()
+	defer primary.Close()
+	fallback := notFound()
+	defer fallback.Close()
+
+	client, err := NewRESTChainTxClient(RESTChainTxConfig{BaseURL: primary.URL, TxQueryURL: fallback.URL, ChainID: "gonka-test"})
+	require.NoError(t, err)
+
+	_, found, err := client.GetTxEscrowID(t.Context(), "ABC123")
+	require.False(t, found)
+	require.ErrorIs(t, err, errTxNotFound)
+}
+
+// TestRESTChainTxClient_GetTxEscrowIDInconclusiveOnFallbackError guards against
+// orphaning: a 404 on the primary plus a real error on the fallback is
+// inconclusive, so a non-errTxNotFound error is returned and the caller keeps
+// the commitment for a later retry instead of clearing it.
+func TestRESTChainTxClient_GetTxEscrowIDInconclusiveOnFallbackError(t *testing.T) {
+	primary := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.NotFound(w, r)
+	}))
+	defer primary.Close()
+	fallback := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, `{"message":"transaction indexing is disabled"}`, http.StatusInternalServerError)
+	}))
+	defer fallback.Close()
+
+	client, err := NewRESTChainTxClient(RESTChainTxConfig{BaseURL: primary.URL, TxQueryURL: fallback.URL, ChainID: "gonka-test"})
+	require.NoError(t, err)
+
+	_, found, err := client.GetTxEscrowID(t.Context(), "ABC123")
+	require.False(t, found)
+	require.Error(t, err)
+	require.NotErrorIs(t, err, errTxNotFound)
+}
+
 func TestRESTChainTxClient_SettleDevshardEscrow(t *testing.T) {
 	signer, err := signing.GenerateKey()
 	require.NoError(t, err)
diff --git a/devshard/cmd/devshardctl/escrow_recovery_test.go b/devshard/cmd/devshardctl/escrow_recovery_test.go
new file mode 100644
index 0000000000..695e0b7666
--- /dev/null
+++ b/devshard/cmd/devshardctl/escrow_recovery_test.go
@@ -0,0 +1,318 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// The root-cause layer: the gateway store must open in WAL with a busy timeout
+// so concurrent writes wait instead of failing with "database is locked".
+func TestGatewayStoreUsesWALAndBusyTimeout(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, store.Close()) })
+
+	var journalMode string
+	require.NoError(t, store.db.QueryRow("PRAGMA journal_mode").Scan(&journalMode))
+	assert.Equal(t, "wal", strings.ToLower(journalMode))
+
+	var busyTimeout int
+	require.NoError(t, store.db.QueryRow("PRAGMA busy_timeout").Scan(&busyTimeout))
+	assert.Equal(t, 5000, busyTimeout)
+}
+
+func TestWithDBRetry_RespectsCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	var attempts atomic.Int32
+	go func() {
+		time.Sleep(50 * time.Millisecond)
+		cancel()
+	}()
+
+	err := withDBRetry(ctx, func() error {
+		attempts.Add(1)
+		return errors.New("database is locked")
+	})
+	require.ErrorIs(t, err, context.Canceled)
+	require.Less(t, int(attempts.Load()), escrowWriteRetries)
+}
+
+func recoveryTestSettings() GatewaySettings {
+	return GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		EscrowRotation: EscrowRotationSettings{
+			Enabled:           true,
+			SettlementEnabled: true,
+			Models: []EscrowRotationModelSettings{{
+				ModelID:       "Qwen/Test",
+				TempCount:     1,
+				TargetCount:   1,
+				Amount:        1000,
+				PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY",
+			}},
+		},
+	}.WithTuningDefaults()
+}
+
+func stubRuntimeBuilder(t *testing.T) {
+	t.Helper()
+	saved := gatewayRuntimeBuilder
+	gatewayRuntimeBuilder = func(cfg RuntimeConfig, _, _ string, _ *PerfTracker) (*devshardRuntime, error) {
+		return &devshardRuntime{id: cfg.ID, model: cfg.Model}, nil
+	}
+	t.Cleanup(func() { gatewayRuntimeBuilder = saved })
+}
+
+// stubCreateOnChain replaces the on-chain create with a fake that mimics the real
+// flow: it invokes onPrepared(txHash) (so the commitment is written) and aborts
+// without a result if that fails — exactly as CreateDevshardEscrow does.
+func stubCreateOnChain(t *testing.T, txHash string, escrowID uint64) {
+	t.Helper()
+	saved := gatewayCreateEscrowOnChain
+	gatewayCreateEscrowOnChain = func(_ *Gateway, _ context.Context, _ GatewaySettings, _ EscrowRotationModelSettings, onPrepared func(string) error) (*CreateDevshardEscrowResult, error) {
+		if onPrepared != nil {
+			if err := onPrepared(txHash); err != nil {
+				return nil, err
+			}
+		}
+		return &CreateDevshardEscrowResult{EscrowID: escrowID, TxHash: txHash}, nil
+	}
+	t.Cleanup(func() { gatewayCreateEscrowOnChain = saved })
+}
+
+func stubQueryTxEscrowID(t *testing.T, fn func(string) (uint64, bool, error)) {
+	t.Helper()
+	saved := gatewayQueryTxEscrowID
+	gatewayQueryTxEscrowID = func(_ context.Context, _ GatewaySettings, txHash string) (uint64, bool, error) {
+		return fn(txHash)
+	}
+	t.Cleanup(func() { gatewayQueryTxEscrowID = saved })
+}
+
+func newRecoveryGateway(t *testing.T) (*Gateway, *GatewayStore, GatewaySettings) {
+	t.Helper()
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+	settings := recoveryTestSettings()
+	require.NoError(t, store.Initialize(settings, nil))
+	stubRuntimeBuilder(t)
+	g := &Gateway{store: store, runtimes: map[string]*devshardRuntime{}}
+	return g, store, settings
+}
+
+func devshardIDs(t *testing.T, store *GatewayStore) map[string]GatewayDevshardState {
+	t.Helper()
+	state, ok, err := store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+	return gatewayDevshardsByID(state.Devshards)
+}
+
+// Happy path: intent commitment is written before the chain tx, the escrow is
+// persisted, and the commitment is cleared.
+func TestCreateRotationEscrowIntentFirstThenPersistAndClear(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	stubCreateOnChain(t, "TXAAA", 777)
+	model := normalizedEscrowRotationModels(settings)[0]
+
+	_, err := g.createRotationEscrow(context.Background(), settings, model, rotationRoleTemp, 10)
+	require.NoError(t, err)
+
+	require.Contains(t, devshardIDs(t, store), "777", "escrow persisted")
+	commitments, err := store.LoadCommitments()
+	require.NoError(t, err)
+	assert.Empty(t, commitments, "commitment cleared after persist")
+}
+
+// Rotation-created escrows inherit the protocol version implied by the
+// gateway-wide route prefix (DEVSHARD_ROUTE_PREFIX), both on the direct
+// persist path and through commitment recovery.
+func TestCreateRotationEscrowCarriesProtocolVersionFromRoutePrefix(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	stubCreateOnChain(t, "TXPV1", 555)
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/devshard/v3")
+	model := normalizedEscrowRotationModels(settings)[0]
+
+	_, err := g.createRotationEscrow(context.Background(), settings, model, rotationRoleTemp, 10)
+	require.NoError(t, err)
+
+	record := devshardIDs(t, store)["555"]
+	assert.Equal(t, "3", record.ProtocolVersion, "persisted escrow inherits protocol from route prefix")
+}
+
+// A route prefix whose version segment is not a protocol version (e.g. a named
+// versiond runtime) keeps the empty/v1-default behavior; semver-like versions
+// map by their major component.
+func TestRotationEscrowProtocolVersionRouteMapping(t *testing.T) {
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/devshard/mainnet-canary")
+	assert.Empty(t, rotationEscrowProtocolVersion())
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/devshard/v3")
+	assert.Equal(t, "3", rotationEscrowProtocolVersion())
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/devshard/v2.1.0")
+	assert.Equal(t, "2", rotationEscrowProtocolVersion())
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/devshard/3")
+	assert.Equal(t, "3", rotationEscrowProtocolVersion())
+}
+
+func TestReconcileCommitmentsCarriesProtocolVersion(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	require.NoError(t, store.SaveCommitment(GatewayEscrowCommitment{
+		TxHash: "TXPV2", Model: "Qwen/Test", Role: rotationRoleTemp, Epoch: 11,
+		PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY", ProtocolVersion: "3",
+	}))
+
+	commitments, err := store.LoadCommitments()
+	require.NoError(t, err)
+	require.Len(t, commitments, 1)
+	assert.Equal(t, "3", commitments[0].ProtocolVersion, "commitment round-trips protocol version")
+
+	stubQueryTxEscrowID(t, func(string) (uint64, bool, error) { return 556, true, nil })
+	g.reconcileCommitments(context.Background(), settings)
+
+	record := devshardIDs(t, store)["556"]
+	assert.Equal(t, "3", record.ProtocolVersion, "recovered escrow keeps protocol version")
+}
+
+// If the intent commitment cannot be written, no chain tx is broadcast and no
+// escrow is created — the safe failure.
+func TestCreateRotationEscrowAbortsWhenCommitmentWriteFails(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	stubCreateOnChain(t, "TXBBB", 778)
+	model := normalizedEscrowRotationModels(settings)[0]
+
+	// Make every write fail, as a locked/read-only DB would.
+	_, err := store.db.Exec("PRAGMA query_only=ON")
+	require.NoError(t, err)
+
+	_, err = g.createRotationEscrow(context.Background(), settings, model, rotationRoleTemp, 10)
+	require.Error(t, err)
+
+	_, _ = store.db.Exec("PRAGMA query_only=OFF")
+	assert.NotContains(t, devshardIDs(t, store), "778", "no escrow created when intent write fails")
+	commitments, _ := store.LoadCommitments()
+	assert.Empty(t, commitments)
+}
+
+// If the post-create persist fails, the commitment survives and reconcile later
+// recovers the escrow from chain by its tx hash — escrow_id is never lost.
+func TestCreateRotationEscrowPersistFailureRecoversViaCommitment(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	stubCreateOnChain(t, "TXCCC", 888)
+	model := normalizedEscrowRotationModels(settings)[0]
+
+	// Force the persist to fail (runtime build error) on the create path.
+	savedBuilder := gatewayRuntimeBuilder
+	gatewayRuntimeBuilder = func(RuntimeConfig, string, string, *PerfTracker) (*devshardRuntime, error) {
+		return nil, errors.New("persist boom")
+	}
+	_, err := g.createRotationEscrow(context.Background(), settings, model, rotationRoleTemp, 10)
+	require.Error(t, err)
+	gatewayRuntimeBuilder = savedBuilder // restore (stubRuntimeBuilder's success)
+
+	require.NotContains(t, devshardIDs(t, store), "888", "not persisted yet")
+	commitments, err := store.LoadCommitments()
+	require.NoError(t, err)
+	require.Len(t, commitments, 1, "commitment kept for recovery")
+	assert.Equal(t, "TXCCC", commitments[0].TxHash)
+
+	// Reconcile: chain resolves the tx hash to the escrow_id.
+	stubQueryTxEscrowID(t, func(txHash string) (uint64, bool, error) {
+		assert.Equal(t, "TXCCC", txHash)
+		return 888, true, nil
+	})
+	g.reconcileCommitments(context.Background(), settings)
+
+	assert.Contains(t, devshardIDs(t, store), "888", "recovered via commitment")
+	commitments, _ = store.LoadCommitments()
+	assert.Empty(t, commitments, "commitment cleared after recovery")
+}
+
+// Reconcile persists an escrow for a pending commitment and clears it.
+func TestReconcileCommitmentsRecoversFromChain(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	require.NoError(t, store.SaveCommitment(GatewayEscrowCommitment{
+		TxHash: "TXDDD", Model: "Qwen/Test", Role: rotationRoleTemp, Epoch: 11, PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY",
+	}))
+	stubQueryTxEscrowID(t, func(string) (uint64, bool, error) { return 999, true, nil })
+
+	g.reconcileCommitments(context.Background(), settings)
+
+	assert.Contains(t, devshardIDs(t, store), "999")
+	commitments, _ := store.LoadCommitments()
+	assert.Empty(t, commitments)
+}
+
+// A commitment whose tx committed but failed (no escrow created) is cleared
+// immediately — the failure is final, the tx can never produce an escrow.
+func TestReconcileCommitmentsClearsWhenTxCommittedFailed(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	require.NoError(t, store.SaveCommitment(GatewayEscrowCommitment{TxHash: "TXEEE", Model: "Qwen/Test", Role: rotationRoleTemp}))
+	stubQueryTxEscrowID(t, func(string) (uint64, bool, error) { return 0, false, nil })
+
+	g.reconcileCommitments(context.Background(), settings)
+
+	commitments, _ := store.LoadCommitments()
+	assert.Empty(t, commitments, "commitment cleared when tx committed but created no escrow")
+}
+
+// A fresh commitment whose tx is not (yet) on chain must be KEPT: an unordered
+// tx can still land until its TTL elapses, and a fresh 404 is usually mempool /
+// index lag, not a failed broadcast. Clearing now would orphan a real escrow.
+func TestReconcileCommitmentsKeepsFreshTxNotFound(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	require.NoError(t, store.SaveCommitment(GatewayEscrowCommitment{TxHash: "TXFRESH", Model: "Qwen/Test", Role: rotationRoleTemp}))
+	stubQueryTxEscrowID(t, func(string) (uint64, bool, error) { return 0, false, errTxNotFound })
+
+	g.reconcileCommitments(context.Background(), settings)
+
+	commitments, err := store.LoadCommitments()
+	require.NoError(t, err)
+	require.Len(t, commitments, 1, "fresh not-found commitment retained until its tx can no longer land")
+	assert.Equal(t, "TXFRESH", commitments[0].TxHash)
+}
+
+// Once the commitment is older than the unordered-tx window, a not-found tx can
+// never land — only then is it safe to clear.
+func TestReconcileCommitmentsClearsExpiredTxNotFound(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	require.NoError(t, store.SaveCommitment(GatewayEscrowCommitment{
+		TxHash:    "TXOLD",
+		Model:     "Qwen/Test",
+		Role:      rotationRoleTemp,
+		CreatedAt: time.Now().UTC().Add(-1 * time.Hour),
+	}))
+	stubQueryTxEscrowID(t, func(string) (uint64, bool, error) { return 0, false, errTxNotFound })
+
+	g.reconcileCommitments(context.Background(), settings)
+
+	commitments, _ := store.LoadCommitments()
+	assert.Empty(t, commitments, "commitment cleared once the unordered tx can no longer land")
+}
+
+// A transient chain error leaves the commitment for the next pass.
+func TestReconcileCommitmentsKeepsCommitmentOnChainError(t *testing.T) {
+	g, store, settings := newRecoveryGateway(t)
+	require.NoError(t, store.SaveCommitment(GatewayEscrowCommitment{TxHash: "TXFFF", Model: "Qwen/Test", Role: rotationRoleTemp}))
+	stubQueryTxEscrowID(t, func(string) (uint64, bool, error) { return 0, false, errors.New("chain unreachable") })
+
+	g.reconcileCommitments(context.Background(), settings)
+
+	commitments, err := store.LoadCommitments()
+	require.NoError(t, err)
+	require.Len(t, commitments, 1, "commitment retained when chain cannot be queried")
+	assert.Equal(t, "TXFFF", commitments[0].TxHash)
+}
diff --git a/devshard/cmd/devshardctl/escrow_rotator.go b/devshard/cmd/devshardctl/escrow_rotator.go
index 0f8ee95c5f..5293c72b7a 100644
--- a/devshard/cmd/devshardctl/escrow_rotator.go
+++ b/devshard/cmd/devshardctl/escrow_rotator.go
@@ -5,10 +5,12 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
 
+	devshardpkg "devshard"
 	"devshard/types"
 )
 
@@ -17,16 +19,29 @@ const (
 	rotationRoleTemp    = "temp"
 
 	defaultEscrowRotationInterval = 15 * time.Second
+
+	rotationBreakerMaxCooldownTicks = 4
+
+	escrowWriteRetries      = 10
+	escrowWriteRetryBackoff = 200 * time.Millisecond
 )
 
 var (
 	errDevshardBusy                   = errors.New("devshard has active requests")
-	errEscrowRotationCreateSuppressed = errors.New("escrow rotation create already failed for this epoch")
+	errDevshardAlreadyExists          = errors.New("devshard already exists")
+	errEscrowRotationCreateSuppressed = errors.New("escrow rotation create suppressed (backoff)")
 	gatewayCreateRotationEscrow       = (*Gateway).createRotationEscrow
+	gatewayCreateEscrowOnChain        = (*Gateway).createEscrowOnChain
 	gatewayCreateDepletionEscrow      func(*Gateway, context.Context, GatewaySettings, EscrowRotationModelSettings, string, uint64) (*CreateDevshardEscrowResult, error)
 	gatewaySettleDevshardOnChain      = (*Gateway).settleDevshardOnChain
+	gatewayQueryTxEscrowID            = defaultQueryTxEscrowID
 )
 
+type rotationBreaker struct {
+	consecutiveFailures int
+	cooldownTicks       int
+}
+
 func (g *Gateway) startEscrowRotatorIfEnabled() {
 	g.mu.Lock()
 	defer g.mu.Unlock()
@@ -66,27 +81,32 @@ func (g *Gateway) stopEscrowRotatorLocked() {
 
 func (g *Gateway) runEscrowRotator(stopCh <-chan struct{}, doneCh chan<- struct{}) {
 	defer close(doneCh)
-	g.rotateEscrowsOnce()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	g.rotateEscrowsOnce(ctx)
 
 	ticker := time.NewTicker(defaultEscrowRotationInterval)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-ticker.C:
-			g.rotateEscrowsOnce()
+			g.rotateEscrowsOnce(ctx)
 		case <-stopCh:
+			cancel()
 			return
 		}
 	}
 }
 
-func (g *Gateway) rotateEscrowsOnce() {
+func (g *Gateway) rotateEscrowsOnce(ctx context.Context) {
 	if g == nil || g.phaseGate == nil || g.store == nil {
 		return
 	}
 	g.mu.Lock()
 	settings := g.settings
 	g.mu.Unlock()
+	g.reconcileCommitments(ctx, settings)
 	rotation := settings.EscrowRotation
 	if !rotation.Enabled {
 		return
@@ -104,18 +124,18 @@ func (g *Gateway) rotateEscrowsOnce() {
 	blocksToEpochSwitch := snapshot.epochSwitchBlockHeight - snapshot.BlockHeight
 
 	if blocksToEpochSwitch >= 0 && blocksToEpochSwitch <= rotation.PrePoCBlocks {
-		g.prepareBridgeEscrows(snapshot, settings)
+		g.prepareBridgeEscrows(ctx, snapshot, settings)
 		return
 	}
 	if !pocActive {
-		g.finishBridgeEscrows(snapshot, settings)
+		g.finishBridgeEscrows(ctx, snapshot, settings)
 	}
 }
 
-func (g *Gateway) prepareBridgeEscrows(snapshot ChainPhaseSnapshot, settings GatewaySettings) {
+func (g *Gateway) prepareBridgeEscrows(ctx context.Context, snapshot ChainPhaseSnapshot, settings GatewaySettings) {
 	epoch := snapshot.EpochIndex
 	for _, model := range normalizedEscrowRotationModels(settings) {
-		ensure, err := g.ensureRotationEscrows(context.Background(), settings, model, rotationRoleTemp, epoch, model.TempCount)
+		ensure, err := g.ensureRotationEscrows(ctx, settings, model, rotationRoleTemp, epoch, model.TempCount)
 		if err != nil {
 			log.Printf("escrow_rotation_temp_create_failed epoch=%d model=%q error=%v", epoch, model.ModelID, err)
 			promoted, promoteErr := g.promoteActiveRegularEscrowsToTemp(model.ModelID, epoch)
@@ -147,7 +167,7 @@ func (g *Gateway) prepareBridgeEscrows(snapshot ChainPhaseSnapshot, settings Gat
 			if devshard.RotationRole == rotationRoleTemp || !devshard.Active || strings.TrimSpace(devshard.Model) != model.ModelID {
 				continue
 			}
-			settledOnChain, err := g.retireRotatedDevshard(context.Background(), devshard.ID, "escrow rotation regular retired", settings)
+			settledOnChain, err := g.retireRotatedDevshard(ctx, devshard.ID, "escrow rotation regular retired", settings)
 			if err != nil {
 				log.Printf("escrow_rotation_regular_retire_failed epoch=%d model=%q escrow=%s error=%v", epoch, model.ModelID, devshard.ID, err)
 				settleFailed++
@@ -170,7 +190,7 @@ func (g *Gateway) prepareBridgeEscrows(snapshot ChainPhaseSnapshot, settings Gat
 	}
 }
 
-func (g *Gateway) finishBridgeEscrows(snapshot ChainPhaseSnapshot, settings GatewaySettings) {
+func (g *Gateway) finishBridgeEscrows(ctx context.Context, snapshot ChainPhaseSnapshot, settings GatewaySettings) {
 	epoch := snapshot.EpochIndex
 	for _, model := range normalizedEscrowRotationModels(settings) {
 		state, ok, err := g.store.LoadState()
@@ -188,7 +208,7 @@ func (g *Gateway) finishBridgeEscrows(snapshot ChainPhaseSnapshot, settings Gate
 		if !hasBridgeEscrows {
 			continue
 		}
-		ensure, err := g.ensureRotationEscrows(context.Background(), settings, model, rotationRoleRegular, epoch, model.TargetCount)
+		ensure, err := g.ensureRotationEscrows(ctx, settings, model, rotationRoleRegular, epoch, model.TargetCount)
 		if err != nil {
 			log.Printf("escrow_rotation_regular_create_failed epoch=%d model=%q error=%v", epoch, model.ModelID, err)
 			g.saveRotationStatus(GatewayRotationStatus{
@@ -215,7 +235,7 @@ func (g *Gateway) finishBridgeEscrows(snapshot ChainPhaseSnapshot, settings Gate
 			if devshard.RotationRole != rotationRoleTemp || devshard.RotationEpoch > epoch || !devshard.Active || strings.TrimSpace(devshard.Model) != model.ModelID {
 				continue
 			}
-			settledOnChain, err := g.retireRotatedDevshard(context.Background(), devshard.ID, "escrow rotation temp retired", settings)
+			settledOnChain, err := g.retireRotatedDevshard(ctx, devshard.ID, "escrow rotation temp retired", settings)
 			if err != nil {
 				log.Printf("escrow_rotation_temp_retire_failed epoch=%d model=%q escrow=%s error=%v", epoch, model.ModelID, devshard.ID, err)
 				settleFailed++
@@ -263,21 +283,44 @@ func (g *Gateway) ensureRotationEscrows(ctx context.Context, settings GatewaySet
 		}
 	}
 	result.ExistingCount = count
-	if count < target && g.rotationCreateFailed(model.ModelID, role, epoch) {
+	if count < target {
+		if served, known := g.rotationModelServedByNetwork(model.ModelID); known && !served {
+			log.Printf("escrow_rotation_skip_model_absent role=%s epoch=%d model=%q reason=model_not_in_network", role, epoch, model.ModelID)
+			return result, nil
+		}
+	}
+	if count < target && g.rotationCreateGated(model.ModelID, role) {
 		return result, errEscrowRotationCreateSuppressed
 	}
 	for count < target {
 		if _, err := gatewayCreateRotationEscrow(g, ctx, settings, model, role, epoch); err != nil {
-			g.recordRotationCreateFailure(model.ModelID, role, epoch)
+			g.recordRotationCreateFailure(model.ModelID, role)
 			return result, err
 		}
 		count++
 		result.CreatedCount++
 	}
+	g.resetRotationBreaker(model.ModelID, role)
 	return result, nil
 }
 
-func (g *Gateway) createRotationEscrow(ctx context.Context, settings GatewaySettings, model EscrowRotationModelSettings, role string, epoch uint64) (*CreateDevshardEscrowResult, error) {
+// rotationModelServedByNetwork reports whether the model is served; known is false on cold start (empty model set) so callers don't skip a genuinely-served model.
+func (g *Gateway) rotationModelServedByNetwork(modelID string) (served bool, known bool) {
+	if g == nil || g.capacity == nil {
+		return false, false
+	}
+	networkModels := g.capacity.Models()
+	if len(networkModels) == 0 {
+		return false, false
+	}
+	modelID = strings.TrimSpace(modelID)
+	if slices.Contains(networkModels, modelID) {
+		return true, true
+	}
+	return false, true
+}
+
+func (g *Gateway) createEscrowOnChain(ctx context.Context, settings GatewaySettings, model EscrowRotationModelSettings, onPrepared func(txHash string) error) (*CreateDevshardEscrowResult, error) {
 	signer, _, err := signerFromRequestKey("", model.PrivateKeyEnv)
 	if err != nil {
 		return nil, err
@@ -286,32 +329,88 @@ func (g *Gateway) createRotationEscrow(ctx context.Context, settings GatewaySett
 	if err != nil {
 		return nil, err
 	}
-	result, err := txClient.CreateDevshardEscrow(ctx, signer, model.Amount, model.ModelID)
+	return txClient.CreateDevshardEscrow(ctx, signer, model.Amount, model.ModelID, onPrepared)
+}
+
+func (g *Gateway) createRotationEscrow(ctx context.Context, settings GatewaySettings, model EscrowRotationModelSettings, role string, epoch uint64) (*CreateDevshardEscrowResult, error) {
+	protocolVersion := rotationEscrowProtocolVersion()
+	commitment := GatewayEscrowCommitment{
+		Model:           model.ModelID,
+		Role:            role,
+		Epoch:           epoch,
+		PrivateKeyEnv:   model.PrivateKeyEnv,
+		ProtocolVersion: protocolVersion,
+		BlockHeight:     g.currentBlockHeight(),
+	}
+	// Intent-first: persist the commitment (with the precomputed tx hash) before broadcast.
+	onPrepared := func(txHash string) error {
+		c := commitment
+		c.TxHash = txHash
+		return withDBRetry(ctx, func() error { return g.store.SaveCommitment(c) })
+	}
+	result, err := gatewayCreateEscrowOnChain(g, ctx, settings, model, onPrepared)
 	if err != nil {
 		return nil, err
 	}
-	record := GatewayDevshardState{
+	if err := g.persistRotationEscrow(ctx, result.EscrowID, model.ModelID, role, epoch, model.PrivateKeyEnv, protocolVersion); err != nil {
+		// Escrow is on chain; commitment survives -> reconcile recovers it by tx hash.
+		log.Printf("escrow_rotation_persist_failed escrow=%d tx=%s model=%q error=%v recover_via_commitment=true", result.EscrowID, result.TxHash, model.ModelID, err)
+		return nil, err
+	}
+	g.clearCommitment(ctx, result.TxHash)
+	log.Printf("escrow_rotation_created role=%s epoch=%d model=%q escrow=%d tx_hash=%s", role, epoch, model.ModelID, result.EscrowID, result.TxHash)
+	return result, nil
+}
+
+func newRotationDevshardState(result *CreateDevshardEscrowResult, model EscrowRotationModelSettings, role string, epoch uint64) GatewayDevshardState {
+	return GatewayDevshardState{
 		RuntimeConfig: RuntimeConfig{
-			ID:            strconv.FormatUint(result.EscrowID, 10),
-			PrivateKeyEnv: strings.TrimSpace(model.PrivateKeyEnv),
-			Model:         model.ModelID,
+			ID:              strconv.FormatUint(result.EscrowID, 10),
+			PrivateKeyEnv:   strings.TrimSpace(model.PrivateKeyEnv),
+			Model:           strings.TrimSpace(model.ModelID),
+			ProtocolVersion: rotationEscrowProtocolVersion(),
 		},
 		Active:        true,
 		RotationRole:  role,
 		RotationEpoch: epoch,
 	}
-	if _, err := g.addCreatedEscrowRuntime(record); err != nil {
-		return nil, err
+}
+
+// rotationEscrowProtocolVersion is the protocol version stamped on escrows
+// created by rotation/depletion. It is derived from the gateway-wide route
+// prefix (DEVSHARD_ROUTE_PREFIX / build version), so a gateway serving
+// /devshard/v3 mints protocol-v3 escrows. Semver-like route versions map by
+// major (v2.1.0 -> v2), relying on the same naming convention that ties a
+// route version to its protocol. An unparseable version segment (e.g. a
+// named versiond runtime) falls back to the v1 default, matching the
+// pre-existing behavior for explicit registrations without a protocol.
+func rotationEscrowProtocolVersion() string {
+	routePrefix, err := resolveGatewayRoutePrefix()
+	if err != nil {
+		log.Printf("escrow_rotation_protocol_version_fallback reason=route_prefix_unresolved error=%v", err)
+		return ""
 	}
-	log.Printf("escrow_rotation_created role=%s epoch=%d model=%q escrow=%d tx_hash=%s", role, epoch, model.ModelID, result.EscrowID, result.TxHash)
-	return result, nil
+	_, version, err := devshardpkg.ResolveRoutePrefix(routePrefix)
+	if err != nil {
+		log.Printf("escrow_rotation_protocol_version_fallback route_prefix=%q reason=version_segment_unresolved error=%v", routePrefix, err)
+		return ""
+	}
+	normalized := strings.TrimSpace(version)
+	if i := strings.IndexByte(normalized, '.'); i > 0 {
+		normalized = normalized[:i] // e.g. v2.1.0 -> v2
+	}
+	pv, err := types.ParseProtocolVersion(normalized)
+	if err != nil {
+		log.Printf("escrow_rotation_protocol_version_fallback route_prefix=%q version=%q reason=unparseable_protocol error=%v", routePrefix, version, err)
+		return ""
+	}
+	return string(pv)
 }
 
 func normalizedEscrowRotationModels(settings GatewaySettings) []EscrowRotationModelSettings {
 	models := make([]EscrowRotationModelSettings, 0, len(settings.EscrowRotation.Models))
 	for _, model := range settings.EscrowRotation.Models {
 		model.ModelID = strings.TrimSpace(model.ModelID)
-		model.PrivateKeyEnv = strings.TrimSpace(model.PrivateKeyEnv)
 		models = append(models, model)
 	}
 	return models
@@ -353,42 +452,234 @@ func (g *Gateway) saveRotationStatus(status GatewayRotationStatus) {
 	}
 }
 
-func (g *Gateway) rotationFailureKey(modelID, role string, epoch uint64) string {
-	return fmt.Sprintf("%s|%s|%d", strings.TrimSpace(modelID), role, epoch)
+func rotationBreakerKey(modelID, role string) string {
+	return strings.TrimSpace(modelID) + "|" + role
 }
 
-func (g *Gateway) recordRotationCreateFailure(modelID, role string, epoch uint64) {
+// rotationCreateGated reports whether create is in backoff; decrements one tick.
+func (g *Gateway) rotationCreateGated(modelID, role string) bool {
 	g.mu.Lock()
 	defer g.mu.Unlock()
-	if g.rotationFailures == nil {
-		g.rotationFailures = make(map[string]struct{})
+	breaker := g.rotationBreakers[rotationBreakerKey(modelID, role)]
+	if breaker == nil || breaker.cooldownTicks <= 0 {
+		return false
 	}
-	g.rotationFailures[g.rotationFailureKey(modelID, role, epoch)] = struct{}{}
+	breaker.cooldownTicks--
+	return true
 }
 
-func (g *Gateway) rotationCreateFailed(modelID, role string, epoch uint64) bool {
+// recordRotationCreateFailure grows the per-(model,role) backoff after a failure.
+func (g *Gateway) recordRotationCreateFailure(modelID, role string) {
 	g.mu.Lock()
 	defer g.mu.Unlock()
-	_, ok := g.rotationFailures[g.rotationFailureKey(modelID, role, epoch)]
-	return ok
+	if g.rotationBreakers == nil {
+		g.rotationBreakers = make(map[string]*rotationBreaker)
+	}
+	key := rotationBreakerKey(modelID, role)
+	breaker := g.rotationBreakers[key]
+	if breaker == nil {
+		breaker = &rotationBreaker{}
+		g.rotationBreakers[key] = breaker
+	}
+	breaker.consecutiveFailures++
+	cooldown := 1 << (breaker.consecutiveFailures - 1)
+	if cooldown > rotationBreakerMaxCooldownTicks {
+		cooldown = rotationBreakerMaxCooldownTicks
+	}
+	breaker.cooldownTicks = cooldown
+}
+
+// resetRotationBreaker clears the backoff for a (model, role) after success.
+func (g *Gateway) resetRotationBreaker(modelID, role string) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	delete(g.rotationBreakers, rotationBreakerKey(modelID, role))
+}
+
+func (g *Gateway) currentBlockHeight() uint64 {
+	if g == nil || g.phaseGate == nil {
+		return 0
+	}
+	height := g.phaseGate.Snapshot().BlockHeight
+	if height < 0 {
+		return 0
+	}
+	return uint64(height)
+}
+
+// withDBRetry retries a DB write with backoff to ride out a transient lock.
+func withDBRetry(ctx context.Context, fn func() error) error {
+	var err error
+	for attempt := 0; attempt < escrowWriteRetries; attempt++ {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		if err = fn(); err == nil {
+			return nil
+		}
+		if attempt < escrowWriteRetries-1 {
+			timer := time.NewTimer(escrowWriteRetryBackoff)
+			select {
+			case <-ctx.Done():
+				timer.Stop()
+				return ctx.Err()
+			case <-timer.C:
+			}
+		}
+	}
+	return err
+}
+
+// persistRotationEscrow persists + registers a created escrow ("already exists" = ok).
+func (g *Gateway) persistRotationEscrow(ctx context.Context, escrowID uint64, modelID, role string, epoch uint64, keyEnv, protocolVersion string) error {
+	record := GatewayDevshardState{
+		RuntimeConfig: RuntimeConfig{
+			ID:              strconv.FormatUint(escrowID, 10),
+			PrivateKeyEnv:   keyEnv,
+			Model:           modelID,
+			ProtocolVersion: strings.TrimSpace(protocolVersion),
+		},
+		Active:        true,
+		RotationRole:  role,
+		RotationEpoch: epoch,
+	}
+	return withDBRetry(ctx, func() error {
+		if _, err := g.addCreatedEscrowRuntime(record); err != nil {
+			if errors.Is(err, errDevshardAlreadyExists) {
+				return nil
+			}
+			return err
+		}
+		return nil
+	})
+}
+
+func (g *Gateway) clearCommitment(ctx context.Context, txHash string) {
+	if g == nil || g.store == nil || strings.TrimSpace(txHash) == "" {
+		return
+	}
+	if err := withDBRetry(ctx, func() error { return g.store.DeleteCommitment(txHash) }); err != nil {
+		log.Printf("escrow_rotation_commitment_clear_failed tx=%s error=%v", txHash, err)
+	}
+}
+
+// commitmentReconcileGrace is how long a not-found tx is given before the
+// commitment is cleared: the unordered-tx TTL plus margin for index lag. Until
+// it elapses, a 404 may be a pending/unindexed tx that still creates an escrow.
+const commitmentReconcileGrace = defaultUnorderedTxTTL + 2*time.Minute
+
+// reconcileCommitments recovers escrows from pending commitments via tx hash:
+// found → persist + clear; committed-failed → clear; not-found → clear only once
+// the tx can no longer land; chain error → keep for next pass.
+func (g *Gateway) reconcileCommitments(ctx context.Context, settings GatewaySettings) {
+	if g == nil || g.store == nil {
+		return
+	}
+	commitments, err := g.store.LoadCommitments()
+	if err != nil {
+		log.Printf("escrow_commitments_load_failed error=%v", err)
+		return
+	}
+	for _, c := range commitments {
+		escrowID, found, err := gatewayQueryTxEscrowID(ctx, settings, c.TxHash)
+		if errors.Is(err, errTxNotFound) {
+			// Tx not on chain. An unordered tx can still land until its TTL
+			// elapses, so a fresh 404 is likely mempool/index lag — keep it.
+			if commitmentTxMayStillLand(c) {
+				log.Printf("escrow_commitment_tx_pending tx=%s model=%q", c.TxHash, c.Model)
+				continue
+			}
+			log.Printf("escrow_commitment_no_escrow tx=%s model=%q clearing=true", c.TxHash, c.Model)
+			g.clearCommitment(ctx, c.TxHash)
+			continue
+		}
+		if err != nil {
+			log.Printf("escrow_commitment_tx_query_failed tx=%s model=%q error=%v", c.TxHash, c.Model, err)
+			continue // chain unreachable — retry next pass
+		}
+		if !found {
+			log.Printf("escrow_commitment_tx_failed tx=%s model=%q clearing=true", c.TxHash, c.Model)
+			g.clearCommitment(ctx, c.TxHash)
+			continue
+		}
+		if err := g.persistRotationEscrow(ctx, escrowID, c.Model, c.Role, c.Epoch, c.PrivateKeyEnv, c.ProtocolVersion); err != nil {
+			log.Printf("escrow_commitment_persist_failed tx=%s escrow=%d model=%q error=%v", c.TxHash, escrowID, c.Model, err)
+			continue // keep commitment — retry next pass
+		}
+		g.clearCommitment(ctx, c.TxHash)
+		g.resetRotationBreaker(c.Model, c.Role)
+		log.Printf("escrow_commitment_recovered tx=%s escrow=%d model=%q role=%s", c.TxHash, escrowID, c.Model, c.Role)
+	}
+}
+
+// commitmentTxMayStillLand reports whether a not-found tx could yet be committed
+// (within the unordered-tx window) — if so, the commitment must be kept. A zero
+// timestamp is treated as still-pending so we never clear too early.
+func commitmentTxMayStillLand(c GatewayEscrowCommitment) bool {
+	if c.CreatedAt.IsZero() {
+		return true
+	}
+	return time.Since(c.CreatedAt) <= commitmentReconcileGrace
+}
+
+func defaultQueryTxEscrowID(ctx context.Context, settings GatewaySettings, txHash string) (uint64, bool, error) {
+	txClient, err := newGatewayRESTChainTxClient(settings, "", "", 0, 0)
+	if err != nil {
+		return 0, false, err
+	}
+	return txClient.GetTxEscrowID(ctx, txHash)
 }
 
 func (g *Gateway) settleDevshardOnChain(ctx context.Context, id string, req adminSettleEscrowRequest) (*SettleDevshardEscrowResult, error) {
 	log.Printf("devshard_settle_start escrow=%s", id)
 	g.mu.Lock()
 	rt, ok := g.runtimes[id]
-	if ok && rt.activeRequests.Load() > 0 {
+	if ok && rt.escrowHasBackgroundWork() {
 		g.mu.Unlock()
-		log.Printf("devshard_settle_blocked escrow=%s reason=active_requests count=%d", id, rt.activeRequests.Load())
+		log.Printf("devshard_settle_blocked escrow=%s reason=background_work active_requests=%d pending_race_cleanup=%d", id, rt.activeUserRequests.Load(), rt.pendingRaceCleanup.Load())
 		return nil, errDevshardBusy
 	}
 	if ok {
 		rt.active.Store(false)
 	}
 	g.mu.Unlock()
+	wasResident := ok
 	if !ok {
-		log.Printf("devshard_settle_failed escrow=%s stage=runtime_lookup error=%q", id, "devshard is not active")
-		return nil, fmt.Errorf("devshard %s is not active", id)
+		// Non-resident devshard (inactive/settled): rehydrate a full runtime
+		// (with chain access) solely to build and broadcast this settlement,
+		// then release it. Concurrent settlement of the same id is guarded by
+		// the caller: auto/reconcile paths hold settlementInFlight[id] via
+		// scheduleAutoSettlement, and the chain rejects any duplicate settle
+		// broadcast, so no additional in-flight guard is taken here (taking
+		// one would deadlock the auto path, which already holds it).
+		cfg, known, cfgErr := g.lazyRuntimeConfig(id)
+		if cfgErr != nil {
+			log.Printf("devshard_settle_failed escrow=%s stage=lazy_config error=%q", id, cfgErr.Error())
+			return nil, cfgErr
+		}
+		if !known {
+			log.Printf("devshard_settle_failed escrow=%s stage=runtime_lookup error=%q", id, "devshard is not active")
+			return nil, fmt.Errorf("devshard %s is not active", id)
+		}
+		g.mu.Lock()
+		settings := g.settings
+		g.mu.Unlock()
+		built, buildErr := gatewayRuntimeBuilder(cfg, settings.ChainREST, settings.DefaultModel, g.perf)
+		if buildErr != nil {
+			log.Printf("devshard_settle_failed escrow=%s stage=rehydrate error=%q", id, buildErr.Error())
+			return nil, fmt.Errorf("rehydrate devshard %s for settlement: %w", id, buildErr)
+		}
+		built.active.Store(false)
+		rt = built
+		log.Printf("devshard_settle_rehydrated escrow=%s (transient, non-resident)", id)
+		defer func() {
+			// Flush a final snapshot: Finalize advances the nonce, so a later
+			// read-only rebuild of this settled escrow would otherwise replay
+			// the diff tail. retireClose captures the finalized state once.
+			if closeErr := rt.retireClose("settled-transient"); closeErr != nil {
+				log.Printf("devshard_settle_transient_close_error escrow=%s error=%v", id, closeErr)
+			}
+		}()
 	}
 	if err := g.store.SetDevshardActive(id, false); err != nil {
 		log.Printf("devshard_settle_failed escrow=%s stage=persist_deactivate error=%q", id, err.Error())
@@ -440,5 +731,12 @@ func (g *Gateway) settleDevshardOnChain(ctx context.Context, id string, req admi
 		return nil, err
 	}
 	log.Printf("devshard_settle_submitted escrow=%s tx_hash=%s settler=%s", id, result.TxHash, result.Settler)
+	// A settled escrow is terminal: drop the resident runtime so its memory
+	// (state machine, inference map, SQLite handles) is released now rather
+	// than lingering until the next restart. Transient runtimes are closed by
+	// their own deferred cleanup above.
+	if wasResident {
+		g.retireRuntime(id, "settled")
+	}
 	return result, nil
 }
diff --git a/devshard/cmd/devshardctl/filtercore/scoping.go b/devshard/cmd/devshardctl/filtercore/scoping.go
new file mode 100644
index 0000000000..c9a9b71a9d
--- /dev/null
+++ b/devshard/cmd/devshardctl/filtercore/scoping.go
@@ -0,0 +1,13 @@
+// Package filtercore holds primitives shared between paramvalidators (top-level
+// request fields) and messagevalidators (per-message shape rules). Both layers
+// dispatch behavior on the routed model id; the dispatch primitive lives here
+// so the two packages do not reimplement it.
+package filtercore
+
+import "slices"
+
+// MatchesModel reports whether routedModel equals any entry in models. Empty
+// models slice always returns false.
+func MatchesModel(routedModel string, models []string) bool {
+	return slices.Contains(models, routedModel)
+}
diff --git a/devshard/cmd/devshardctl/filtercore/scoping_test.go b/devshard/cmd/devshardctl/filtercore/scoping_test.go
new file mode 100644
index 0000000000..fc506fe5b0
--- /dev/null
+++ b/devshard/cmd/devshardctl/filtercore/scoping_test.go
@@ -0,0 +1,25 @@
+package filtercore
+
+import "testing"
+
+func TestMatchesModel(t *testing.T) {
+	cases := []struct {
+		name        string
+		routed      string
+		models      []string
+		want        bool
+	}{
+		{name: "empty list", routed: "model-a", models: nil, want: false},
+		{name: "single match", routed: "model-a", models: []string{"model-a"}, want: true},
+		{name: "no match", routed: "model-a", models: []string{"model-b"}, want: false},
+		{name: "match in multi", routed: "model-b", models: []string{"model-a", "model-b", "model-c"}, want: true},
+		{name: "case sensitive", routed: "Model-A", models: []string{"model-a"}, want: false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := MatchesModel(c.routed, c.models); got != c.want {
+				t.Fatalf("MatchesModel(%q, %v) = %v, want %v", c.routed, c.models, got, c.want)
+			}
+		})
+	}
+}
diff --git a/devshard/cmd/devshardctl/gateway.go b/devshard/cmd/devshardctl/gateway.go
index d9fc324824..a90d9a0a45 100644
--- a/devshard/cmd/devshardctl/gateway.go
+++ b/devshard/cmd/devshardctl/gateway.go
@@ -10,9 +10,11 @@ import (
 	"log"
 	"math"
 	"net/http"
+	"net/http/pprof"
 	"net/url"
 	"os"
 	"path/filepath"
+	"runtime"
 	"slices"
 	"strconv"
 	"strings"
@@ -52,10 +54,11 @@ type Gateway struct {
 	perfStore             *PerfStore
 	chatCache             *chatResponseCache
 	apiKeys               map[string]struct{}
+	suspiciousHosts       map[string]struct{}
 	baseStorageDir        string
 	rotatorStop           chan struct{}
 	rotatorDone           chan struct{}
-	rotationFailures      map[string]struct{}
+	rotationBreakers      map[string]*rotationBreaker
 	finalizeMu            sync.Mutex
 	settlementMu          sync.Mutex
 	settlementInFlight    map[string]struct{}
@@ -79,13 +82,33 @@ type devshardRuntime struct {
 	// same escrow.
 	participantSlotCounts map[string]int
 
-	active         atomic.Bool
-	activeRequests atomic.Int64
-	reservedTokens atomic.Int64
+	active             atomic.Bool
+	activeUserRequests atomic.Int64
+	reservedTokens     atomic.Int64
+
+	// pendingRaceCleanup counts background race cleanups (refund + loser-signature persistence) still in flight
+	pendingRaceCleanup atomic.Int64
+
+	// settlementPending marks an escrow that has been deactivated and must
+	// be settled once its in-flight requests drain. settlementReason is
+	// written before the flag and read after it in the lock-free drain hook;
+	// the atomic Store→Load pair supplies the happens-before.
+	settlementPending atomic.Bool
+	settlementReason  string
+
+	// retirePending marks a runtime whose retirement was deferred because a
+	// request was still in flight;
+	retirePending atomic.Bool
+	retireReason  string
 
 	activeConfigured bool
 }
 
+// escrowHasBackgroundWork reports whether foreground requests or background race cleanups are in flight; settle and store-close must wait until it is false.
+func (rt *devshardRuntime) escrowHasBackgroundWork() bool {
+	return rt.activeUserRequests.Load() > 0 || rt.pendingRaceCleanup.Load() > 0
+}
+
 type runtimeStatus struct {
 	ID                   string `json:"id"`
 	Model                string `json:"model"`
@@ -96,6 +119,7 @@ type runtimeStatus struct {
 	ProtocolVersion      string `json:"protocol_version,omitempty"`
 	ActiveRequests       int64  `json:"active_requests"`
 	ReservedTokens       int64  `json:"reserved_tokens"`
+	SettlementPending    bool   `json:"settlement_pending,omitempty"`
 	ChainPhase           string `json:"chain_phase,omitempty"`
 	ConfirmationPoCPhase string `json:"confirmation_poc_phase,omitempty"`
 	RequestsBlocked      bool   `json:"requests_blocked"`
@@ -206,6 +230,7 @@ func newRuntimeMux(proxy *Proxy) http.Handler {
 	mux.HandleFunc("GET /v1/state", proxy.handleState)
 	mux.HandleFunc("GET /v1/debug/pending", proxy.handleDebugPending)
 	mux.HandleFunc("GET /v1/debug/state", proxy.handleDebugState)
+	mux.HandleFunc("GET /v1/debug/inferences", proxy.handleDebugInferences)
 	mux.HandleFunc("GET /v1/debug/perf", proxy.handleDebugPerf)
 	mux.HandleFunc("GET /v1/debug/pairwise", proxy.handleDebugPairwise)
 	mux.HandleFunc("GET /v1/debug/signatures", proxy.handleDebugSignatures)
@@ -247,14 +272,21 @@ func buildRuntime(cfg RuntimeConfig, chainREST, defaultModel string, perf *PerfT
 	if err := migrateGatewayLegacyStorage(cfg.StoragePath, legacyStoragePath, cfg.ID, br); err != nil {
 		return nil, fmt.Errorf("runtime %s: migrate legacy storage: %w", cfg.ID, err)
 	}
-	routePrefix := devshardpkg.ResolveHostRoutePrefix(pv, os.Getenv("DEVSHARD_ROUTE_PREFIX"))
+	routePrefix, routePrefixErr := resolveGatewayRoutePrefix()
+	if routePrefixErr != nil {
+		return nil, fmt.Errorf("runtime %s: %w", cfg.ID, routePrefixErr)
+	}
+	participantAdmission := modelScopedParticipantAdmission{
+		limiter: sharedParticipantRequestLimiter,
+		modelID: model,
+	}
 	session, sm, err := user.NewHTTPSession(user.HTTPSessionConfig{
 		PrivateKeyHex:    keyHex,
 		EscrowID:         cfg.ID,
 		Bridge:           br,
 		StoragePath:      cfg.StoragePath,
 		RoutePrefix:      routePrefix,
-		RequestAdmission: sharedParticipantRequestLimiter,
+		RequestAdmission: participantAdmission,
 		ProtocolVersion:  pv,
 	})
 	if err != nil {
@@ -269,7 +301,9 @@ func buildRuntime(cfg RuntimeConfig, chainREST, defaultModel string, perf *PerfT
 		perf,
 		len(session.Clients()),
 		model,
-		sharedParticipantRequestLimiter.IsBlocked,
+		func(participantKey string) bool {
+			return sharedParticipantRequestLimiter.IsBlockedForModel(participantKey, model)
+		},
 	)
 	redundancy.participantLimiter = sharedParticipantRequestLimiter
 	proxy := &Proxy{
@@ -295,8 +329,202 @@ func buildRuntime(cfg RuntimeConfig, chainREST, defaultModel string, perf *PerfT
 	return rt, nil
 }
 
+// defaultMaxConcurrentRuntimeBuilds caps parallel runtime builds at startup: a
+// small keep-alive pool against the shared node LCD, big enough to hide startup
+// latency, small enough to avoid a 429 storm. Overridable per deployment.
+const defaultMaxConcurrentRuntimeBuilds = 16
+
+// resolveMaxConcurrentRuntimeBuilds is the startup build fan-out limit,
+// overridable via DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS (must be >= 1).
+func resolveMaxConcurrentRuntimeBuilds() int {
+	raw := strings.TrimSpace(os.Getenv("DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS"))
+	if raw == "" {
+		return defaultMaxConcurrentRuntimeBuilds
+	}
+	n, err := strconv.Atoi(raw)
+	if err != nil || n < 1 {
+		log.Printf("invalid DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS=%q (must be >= 1), using default %d", raw, defaultMaxConcurrentRuntimeBuilds)
+		return defaultMaxConcurrentRuntimeBuilds
+	}
+	return n
+}
+
+// buildRuntimeBridgeClient returns the HTTP client for chain-LCD queries, sized
+// so the bounded build fan-out reuses keep-alive connections instead of churning
+// them (the default MaxIdleConnsPerHost is only 2).
+func buildRuntimeBridgeClient(limit int) *http.Client {
+	transport := http.DefaultTransport.(*http.Transport).Clone()
+	transport.MaxIdleConns = limit
+	transport.MaxIdleConnsPerHost = limit
+	return &http.Client{Timeout: 10 * time.Second, Transport: transport}
+}
+
+var (
+	runtimeBridgeClientOnce sync.Once
+	runtimeBridgeClient     *http.Client
+)
+
+func sharedRuntimeBridgeClient() *http.Client {
+	runtimeBridgeClientOnce.Do(func() {
+		runtimeBridgeClient = buildRuntimeBridgeClient(resolveMaxConcurrentRuntimeBuilds())
+	})
+	return runtimeBridgeClient
+}
+
+// buildReadOnlyRuntime rehydrates a transient, read-only runtime from local
+// storage without contacting the chain. It is used to serve debug/state
+// endpoints for devshards that are not resident in memory (inactive or
+// settled escrows). The runtime has no host clients and no redundancy: it can
+// answer read queries but must never route inferences. Callers own the
+// returned runtime and must close() it once the response is served.
+func buildReadOnlyRuntime(cfg RuntimeConfig, defaultModel string, perf *PerfTracker) (*devshardRuntime, error) {
+	keyHex := strings.TrimSpace(cfg.PrivateKeyHex)
+	if keyHex == "" && cfg.PrivateKeyEnv != "" {
+		keyHex = strings.TrimSpace(os.Getenv(cfg.PrivateKeyEnv))
+	}
+	if keyHex == "" {
+		return nil, fmt.Errorf("runtime %s: %w", cfg.ID, errRuntimePrivateKeyMissing)
+	}
+	model := cfg.Model
+	if model == "" {
+		model = defaultModel
+	}
+	cfg.StoragePath = normalizeStorageDir(cfg.StoragePath)
+	pv, pvErr := types.ParseProtocolVersion(cfg.ProtocolVersion)
+	if pvErr != nil {
+		return nil, fmt.Errorf("runtime %s: %w", cfg.ID, pvErr)
+	}
+	if perf == nil {
+		perf = NewPerfTracker(nil)
+	}
+	session, sm, err := user.NewLocalSession(user.LocalSessionConfig{
+		PrivateKeyHex:   keyHex,
+		EscrowID:        cfg.ID,
+		StoragePath:     cfg.StoragePath,
+		ProtocolVersion: pv,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("runtime %s: rehydrate local session: %w", cfg.ID, err)
+	}
+	proxy := &Proxy{
+		session:  session,
+		sm:       sm,
+		escrowID: cfg.ID,
+		model:    model,
+		perf:     perf,
+	}
+	rt := &devshardRuntime{
+		id:              cfg.ID,
+		model:           model,
+		handler:         newRuntimeMux(proxy),
+		proxy:           proxy,
+		session:         session,
+		participantKeys: session.ParticipantKeys(),
+	}
+	rt.active.Store(false)
+	rt.activeConfigured = true
+	return rt, nil
+}
+
+// lazyRuntimeConfig resolves a non-resident devshard's runtime config from the
+// registry store, applying the same finalization (storage path, default
+// model) used at boot. It returns false when the devshard is unknown.
+func (g *Gateway) lazyRuntimeConfig(id string) (RuntimeConfig, bool, error) {
+	if g.store == nil {
+		return RuntimeConfig{}, false, fmt.Errorf("gateway state store unavailable")
+	}
+	record, ok, err := g.store.GetDevshard(id)
+	if err != nil {
+		return RuntimeConfig{}, false, err
+	}
+	if !ok {
+		return RuntimeConfig{}, false, nil
+	}
+	g.mu.Lock()
+	defaultModel := g.settings.DefaultModel
+	baseStorageDir := g.baseStorageDir
+	g.mu.Unlock()
+	cfgs, err := finalizeRuntimeConfigs([]RuntimeConfig{record.RuntimeConfig}, defaultModel, baseStorageDir)
+	if err != nil {
+		return RuntimeConfig{}, false, err
+	}
+	return cfgs[0], true, nil
+}
+
+// hydrateReadOnlyRuntime builds a transient read-only runtime for a
+// non-resident devshard, serving from local storage only (no chain). Returns
+// (nil, false, nil) when the devshard is unknown to the registry.
+func (g *Gateway) hydrateReadOnlyRuntime(id string) (*devshardRuntime, bool, error) {
+	cfg, ok, err := g.lazyRuntimeConfig(id)
+	if err != nil || !ok {
+		return nil, ok, err
+	}
+	rt, err := buildReadOnlyRuntime(cfg, g.settings.DefaultModel, g.perf)
+	if err != nil {
+		return nil, true, err
+	}
+	return rt, true, nil
+}
+
+// isReadOnlyDevshardPath reports whether an inner devshard path may be served
+// by a transient read-only (no-chain, no-clients) runtime. Only idempotent
+// GET reads qualify; anything that dispatches inferences or mutates state is
+// excluded so it never runs against a client-less runtime.
+func isReadOnlyDevshardPath(method, innerPath string) bool {
+	if method != http.MethodGet && method != http.MethodHead {
+		return false
+	}
+	switch innerPath {
+	case "/v1/status",
+		"/v1/state",
+		"/v1/finalize",
+		"/v1/models",
+		"/v1/debug/pending",
+		"/v1/debug/state",
+		"/v1/debug/inferences",
+		"/v1/debug/perf",
+		"/v1/debug/pairwise",
+		"/v1/debug/signatures":
+		return true
+	}
+	return strings.HasPrefix(innerPath, "/v1/requests/")
+}
+
 func newRESTBridgeForProtocol(chainREST string, pv types.ProtocolVersion) *bridge.RESTBridge {
-	return bridge.NewRESTBridge(chainREST)
+	return bridge.NewRESTBridge(chainREST, bridge.WithHTTPClient(sharedRuntimeBridgeClient()))
+}
+
+func resolveGatewayRoutePrefix() (string, error) {
+	routePrefix := strings.TrimSpace(os.Getenv("DEVSHARD_ROUTE_PREFIX"))
+	if routePrefix == "" {
+		version := strings.TrimSpace(Version)
+		if version == "" {
+			version = "dev"
+		}
+		routePrefix = devshardpkg.VersionedRoutePrefix(version)
+	}
+	normalized, _, err := devshardpkg.ResolveRoutePrefix(routePrefix)
+	if err != nil {
+		return "", err
+	}
+	return normalized, nil
+}
+
+func gatewayHostRoutePrefix(override string) string {
+	override = strings.TrimSpace(override)
+	if override != "" {
+		return override
+	}
+	version := strings.TrimSpace(Version)
+	if version == "" {
+		version = "dev"
+	}
+	return devshardpkg.VersionedRoutePrefix(version)
+}
+
+func validateGatewayHostRoutePrefix(routePrefix string) error {
+	_, _, err := devshardpkg.ResolveRoutePrefix(routePrefix)
+	return err
 }
 
 // hostSlotCounts builds a slot-count map from a per-slot participant
@@ -320,6 +548,21 @@ func (rt *devshardRuntime) close() error {
 	return nil
 }
 
+// retireClose flushes a final state snapshot at the current (now frozen) nonce
+// so the escrow can later be rebuilt -- read-only for debug/state or fully on
+// reactivation -- without replaying the diff tail accumulated since the last
+// periodic snapshot, then closes the runtime. Use only on retire paths
+// (deactivate, settle, rotation); plain close() is for transient read-only
+// runtimes and build-failure cleanup, where no snapshot flush is wanted.
+func (rt *devshardRuntime) retireClose(reason string) error {
+	if rt.session != nil {
+		if err := rt.session.FlushSnapshot(); err != nil {
+			log.Printf("runtime_retire_snapshot_error escrow=%s reason=%q error=%v", rt.id, reason, err)
+		}
+	}
+	return rt.close()
+}
+
 func (rt *devshardRuntime) acceptsNewInferences() (bool, string) {
 	if rt == nil || !rt.active.Load() {
 		return false, "inactive"
@@ -377,18 +620,18 @@ func sessionPhaseLabel(phase types.SessionPhase) string {
 
 func (rt *devshardRuntime) snapshot() runtimeStatus {
 	status := runtimeStatus{
-		ID:             rt.id,
-		Model:          rt.model,
-		Active:         rt.active.Load(),
-		ActiveRequests: rt.activeRequests.Load(),
-		ReservedTokens: rt.reservedTokens.Load(),
+		ID:                rt.id,
+		Model:             rt.model,
+		Active:            rt.active.Load(),
+		ActiveRequests:    rt.activeUserRequests.Load(),
+		ReservedTokens:    rt.reservedTokens.Load(),
+		SettlementPending: rt.settlementPending.Load(),
 	}
 	if rt.proxy != nil && rt.proxy.sm != nil && rt.proxy.session != nil {
 		phase := rt.proxy.sm.Phase()
 		status.Phase = sessionPhaseLabel(phase)
-		st := rt.proxy.sm.SnapshotState()
 		status.Nonce = rt.proxy.session.Nonce()
-		status.Balance = st.Balance
+		status.Balance = rt.proxy.sm.Balance()
 		status.ProtocolVersion = string(rt.proxy.sm.ProtocolVersion())
 	}
 	if rt.proxy != nil && rt.proxy.phaseGate != nil {
@@ -401,8 +644,8 @@ func (rt *devshardRuntime) snapshot() runtimeStatus {
 	return status
 }
 
-// TODO: the (reservedTokens*1000 + activeRequests) formula is missleading,
-// let's just leave activeRequests here, and leave a todo comment, that
+// TODO: the (reservedTokens*1000 + activeUserRequests) formula is missleading,
+// let's just leave activeUserRequests here, and leave a todo comment, that
 // we might need to change it, so that if limits for tokens or cuncurrent
 // requests are set, we need to measure if the escrow is further from
 // the limists
@@ -410,8 +653,8 @@ func (rt *devshardRuntime) snapshot() runtimeStatus {
 // load returns the capacity-aware load score for this runtime. Lower
 // is better; the picker selects the runtime with the smallest load.
 //
-// Score is simply activeRequests / W(e):
-//   - activeRequests is the live count of in-flight inferences this
+// Score is simply activeUserRequests / W(e):
+//   - activeUserRequests is the live count of in-flight inferences this
 //     runtime owns (incremented on dispatch, decremented on
 //     completion). It's the most direct, low-latency signal of "is
 //     this runtime busy right now".
@@ -434,7 +677,7 @@ func (rt *devshardRuntime) load(weight float64) float64 {
 	if weight <= 0 {
 		return math.Inf(+1)
 	}
-	return float64(rt.activeRequests.Load()) / weight
+	return float64(rt.activeUserRequests.Load()) / weight
 }
 
 func NewGateway(runtimes []*devshardRuntime, limiter *GatewayLimiter, defaultModel string) *Gateway {
@@ -453,11 +696,12 @@ func NewGateway(runtimes []*devshardRuntime, limiter *GatewayLimiter, defaultMod
 		participantLimiter: sharedParticipantRequestLimiter,
 		metrics:            NewDevshardMetrics(),
 		capacity:           NewCapacityState(),
-		chatCache:          newChatResponseCache(chatResponseCacheTTL),
+		chatCache:          newChatResponseCache(chatResponseCacheTTL, readInt64Env("DEVSHARD_CHAT_CACHE_MAX_BYTES", defaultChatCacheMaxBytes)),
+		suspiciousHosts:    make(map[string]struct{}),
 		settings: GatewaySettings{
 			DefaultModel: defaultModel,
 		},
-		rotationFailures:   make(map[string]struct{}),
+		rotationBreakers:   make(map[string]*rotationBreaker),
 		settlementInFlight: make(map[string]struct{}),
 	}
 	g.participantLimiter.SetMetrics(g.metrics)
@@ -476,6 +720,13 @@ func NewManagedGateway(runtimes []*devshardRuntime, limiter *GatewayLimiter, set
 	g.settings = settings
 	g.baseStorageDir = baseStorageDir
 	g.store = store
+	if store != nil {
+		if hosts, err := store.LoadSuspiciousHosts(); err != nil {
+			log.Printf("load suspicious hosts: %v", err)
+		} else {
+			g.replaceSuspiciousHosts(hosts)
+		}
+	}
 	if len(perfArgs) > 0 && perfArgs[0] != nil {
 		g.perf = perfArgs[0]
 	}
@@ -498,7 +749,12 @@ func NewManagedGateway(runtimes []*devshardRuntime, limiter *GatewayLimiter, set
 	for _, rt := range g.runtimeOrder {
 		g.attachEscrowChecker(rt)
 	}
+	go g.reconcileCommitments(context.Background(), settings)
 	g.startEscrowRotatorIfEnabled()
+	// Settle escrows left pending by a pre-restart drain. Runs synchronously
+	// so the store read completes before the gateway serves traffic; the
+	// settlements it schedules run in their own goroutines.
+	g.reconcilePendingSettlements()
 	go g.balanceCheckLoop()
 	return g
 }
@@ -512,9 +768,13 @@ func (g *Gateway) attachRuntimeSharedState(rt *devshardRuntime) {
 		limits := g.outputTokenLimitsForModel(firstNonEmpty(rt.model, g.settings.DefaultModel))
 		rt.proxy.defaultRequestMaxTokens = limits.DefaultMaxTokens
 		rt.proxy.requestMaxTokensCap = limits.MaxTokensCap
+		if rt.proxy.redundancy != nil {
+			rt.proxy.redundancy.suspiciousParticipant = g.isSuspiciousParticipant
+		}
 	}
 	g.attachMetrics(rt)
 	g.attachEscrowChecker(rt)
+	g.attachRaceCleanupBarrier(rt)
 	if g.capacity != nil {
 		g.capacity.SetEscrowMembership(rt.id, rt.participantSlotCounts)
 	}
@@ -716,6 +976,37 @@ func (g *Gateway) requestHasAPIKey(r *http.Request) bool {
 	return ok
 }
 
+func (g *Gateway) isSuspiciousParticipant(participantKey string) bool {
+	if g == nil {
+		return false
+	}
+	participantKey = strings.TrimSpace(participantKey)
+	if participantKey == "" {
+		return false
+	}
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	_, ok := g.suspiciousHosts[participantKey]
+	return ok
+}
+
+func (g *Gateway) replaceSuspiciousHosts(hosts []GatewaySuspiciousHost) {
+	if g == nil {
+		return
+	}
+	next := make(map[string]struct{}, len(hosts))
+	for _, host := range hosts {
+		key := strings.TrimSpace(host.ParticipantKey)
+		if key == "" {
+			continue
+		}
+		next[key] = struct{}{}
+	}
+	g.mu.Lock()
+	g.suspiciousHosts = next
+	g.mu.Unlock()
+}
+
 func bearerToken(r *http.Request) (string, bool) {
 	if r == nil {
 		return "", false
@@ -866,12 +1157,22 @@ func (g *Gateway) currentMaxConcurrentPer10000Weight() float64 {
 	g.mu.Lock()
 	settings := g.settings.WithTuningDefaults()
 	g.mu.Unlock()
-	if g.pocOrConfirmationPoCActive() {
+	if g.pocGenerationActive() {
 		return settings.PoCMaxConcurrentPer10000Weight
 	}
 	return settings.MaxConcurrentPer10000Weight
 }
 
+func (g *Gateway) pocGenerationActive() bool {
+	if g != nil && g.phaseGate != nil {
+		snap := g.phaseGate.Snapshot()
+		if rawPoCGenerationState(snap.EpochPhase, snap.ConfirmationPoCPhase) {
+			return true
+		}
+	}
+	return false
+}
+
 func (g *Gateway) pocOrConfirmationPoCActive() bool {
 	if g != nil && g.phaseGate != nil {
 		switch g.phaseGate.Snapshot().BlockReason {
@@ -998,21 +1299,61 @@ func (g *Gateway) Handler() http.Handler {
 	mux.HandleFunc("/v1/admin/devshards", g.handleAdminDevshards)
 	mux.HandleFunc("/v1/admin/devshards/", g.handleAdminDevshardAction)
 	mux.HandleFunc("/v1/admin/escrows", g.handleAdminEscrows)
+	mux.HandleFunc("/v1/admin/suspicious-hosts", g.handleAdminSuspiciousHosts)
 	mux.HandleFunc("/v1/admin/participants/unquarantine", g.handleAdminUnquarantine)
 	mux.HandleFunc("/v1/debug/rotation", g.handleDebugRotation)
 	mux.HandleFunc("/v1/finalize", g.handleSingleOnly)
 	mux.HandleFunc("/v1/state", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/pending", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/state", g.handleSingleOnly)
+	mux.HandleFunc("/v1/debug/inferences", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/perf", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/pairwise", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/signatures", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/signatures/collect", g.handleSingleOnly)
 	mux.HandleFunc("/v1/debug/sync-hosts", g.handleSingleOnly)
+	mux.HandleFunc("/v1/debug/memstats", g.handleDebugMemStats)
+	// Runtime profiling, admin-gated (see isAdminPath). Mounted at the
+	// canonical /debug/pprof/ path so pprof.Index's sub-profile links resolve.
+	mux.HandleFunc("/debug/pprof/", pprof.Index)
+	mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
+	mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
+	mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
+	mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
 	mux.HandleFunc("/devshard/", g.handleDevshard)
 	return mux
 }
 
+// handleDebugMemStats reports Go runtime memory statistics so operators can
+// distinguish live heap (HeapInuse) from memory the runtime has reclaimed but
+// not yet returned to the OS (HeapReleased), which explains RSS that stays high
+// after garbage collection. Admin-gated via the /v1/debug/ prefix.
+func (g *Gateway) handleDebugMemStats(w http.ResponseWriter, r *http.Request) {
+	if !allowGetOrHead(w, r) {
+		return
+	}
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	g.mu.Lock()
+	loadedRuntimes := len(g.runtimeOrder)
+	g.mu.Unlock()
+	writeJSON(w, map[string]any{
+		"loaded_runtimes": loadedRuntimes,
+		"num_goroutine":   runtime.NumGoroutine(),
+		"heap_inuse":      m.HeapInuse,
+		"heap_alloc":      m.HeapAlloc,
+		"heap_sys":        m.HeapSys,
+		"heap_idle":       m.HeapIdle,
+		"heap_released":   m.HeapReleased,
+		"heap_objects":    m.HeapObjects,
+		"stack_inuse":     m.StackInuse,
+		"sys":             m.Sys,
+		"next_gc":         m.NextGC,
+		"num_gc":          m.NumGC,
+		"gc_cpu_fraction": m.GCCPUFraction,
+	})
+}
+
 func (g *Gateway) handlePooledModels(w http.ResponseWriter, r *http.Request) {
 	if !allowGetOrHead(w, r) {
 		return
@@ -1073,6 +1414,7 @@ func (g *Gateway) handlePooledChat(w http.ResponseWriter, r *http.Request) {
 	body, model, inputTokens, err := g.parseChatReservation(r, g.settings.DefaultModel)
 	if err != nil {
 		logRequestStage(ctx, "gateway_parse_failed", "error", err)
+		g.recordGatewayRequestOutcome(firstNonEmpty(model, g.settings.DefaultModel), "invalid_request", "invalid_request")
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), chatRequestErrorStatus(err, http.StatusBadRequest))
 		return
 	}
@@ -1082,11 +1424,13 @@ func (g *Gateway) handlePooledChat(w http.ResponseWriter, r *http.Request) {
 	requestModel := firstNonEmpty(model, g.settings.DefaultModel)
 	if err := g.validatePooledRequestedModel(requestModel); err != nil {
 		logRequestStage(ctx, "gateway_model_rejected", "model", requestModel, "error", err)
+		g.recordGatewayRequestOutcome(requestModel, "model_rejected", "model_rejected")
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), gatewayStatusCodeForError(err))
 		return
 	}
 	if err := g.modelAccessError(r, requestModel); err != nil {
 		logRequestStage(ctx, "gateway_model_temporarily_unavailable", "model", requestModel, "error", err)
+		g.recordGatewayRequestOutcome(requestModel, "model_rejected", "model_access_rejected")
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), gatewayStatusCodeForError(err))
 		return
 	}
@@ -1096,6 +1440,7 @@ func (g *Gateway) handlePooledChat(w http.ResponseWriter, r *http.Request) {
 	if entry, ok := g.chatCache.Get(cacheKey, time.Now()); ok {
 		logRequestStage(ctx, "gateway_cache_hit", "escrow", entry.EscrowID, "model", requestModel, "stream", stream)
 		g.recordCachedAccountingAlias(ctx, entry)
+		g.recordGatewayRequestOutcome(requestModel, "cached", "cache_hit")
 		serveCachedChatResponse(w, r, entry)
 		return
 	}
@@ -1105,8 +1450,10 @@ func (g *Gateway) handlePooledChat(w http.ResponseWriter, r *http.Request) {
 		g.refreshCapacityScale()
 		limitModel := requestModel
 		if err := g.limiter.AcquireForModelWithCapacity(limitModel, inputTokens, g.limiterCapacityForModel(limitModel)); err != nil {
-			g.metrics.RecordLimitRejection(limiterReasonLabel(err))
-			logRequestStage(ctx, "gateway_limiter_rejected", "reason", limiterReasonLabel(err), "input_tokens", inputTokens)
+			reason := limiterReasonLabel(err)
+			g.metrics.RecordLimitRejection(reason)
+			g.recordGatewayRequestOutcome(limitModel, "gateway_limited", reason)
+			logRequestStage(ctx, "gateway_limiter_rejected", "reason", reason, "input_tokens", inputTokens)
 			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusTooManyRequests)
 			return
 		}
@@ -1120,8 +1467,9 @@ func (g *Gateway) handlePooledChat(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		logRequestStage(ctx, "gateway_runtime_select_failed", "error", err)
 		if isParticipantRateLimitError(err) {
-			g.metrics.RecordParticipantLimitRejection("pooled_route")
+			g.metrics.RecordParticipantLimitRejection("", requestModel, "pooled_route")
 		}
+		g.recordGatewayRequestOutcome(requestModel, "runtime_unavailable", gatewayRuntimeUnavailableReason(err))
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), gatewayStatusCodeForError(err))
 		return
 	}
@@ -1130,9 +1478,9 @@ func (g *Gateway) handlePooledChat(w http.ResponseWriter, r *http.Request) {
 
 	if capture := g.serveChatToRuntime(rt, "/v1/chat/completions", body, w, r); capture != nil {
 		sourceRequestID, _ := requestLogFromContext(ctx)
-		if entry, ok := capture.cacheEntry(rt.id, stream, sourceRequestID); ok {
+		if entry, ok := capture.cacheEntry(rt.id, stream, sourceRequestID, r.Context().Err()); ok {
 			g.chatCache.Set(cacheKey, entry, time.Now())
-			logRequestStage(ctx, "gateway_cache_stored", "escrow", rt.id, "model", requestModel, "stream", stream, "bytes", len(entry.Body))
+			logRequestStage(ctx, "gateway_cache_stored", "escrow", rt.id, "model", requestModel, "stream", stream, "status", entry.StatusCode, "content_type", entry.ContentType, "bytes", len(entry.Body))
 		}
 	}
 }
@@ -1173,6 +1521,28 @@ func (g *Gateway) handleDevshard(w http.ResponseWriter, r *http.Request) {
 	rt, ok := g.runtimes[devshardID]
 	g.mu.Unlock()
 	if !ok {
+		// Non-resident devshard (inactive/settled). Read-only debug and state
+		// endpoints can be served from a transient runtime rehydrated from
+		// local storage (no chain, no host clients), then released
+		// immediately. Inference and other mutating paths are never
+		// lazy-loaded.
+		//
+		// Rehydration replays diffs and loads a snapshot into a fresh runtime.
+		// That is cheap per call, but an unauthenticated caller could hammer
+		// inactive escrow IDs to inflate gateway memory/CPU. So the hydrating
+		// read paths are admin-only for non-resident devshards; non-admin
+		// callers only get cheap registry metadata (model/active flag) that
+		// needs neither snapshot nor state, and everything else looks unknown.
+		if isReadOnlyDevshardPath(r.Method, innerPath) {
+			if requestHasAdminAuth(r) {
+				g.serveReadOnlyDevshard(w, r, devshardID, innerPath)
+				return
+			}
+			if g.serveInactiveDevshardMetadata(w, r, devshardID, innerPath) {
+				return
+			}
+			logRequestStage(ctx, "gateway_devshard_readonly_requires_admin", "escrow", devshardID, "path", innerPath)
+		}
 		logRequestStage(ctx, "gateway_devshard_not_found", "escrow", devshardID)
 		http.Error(w, fmt.Sprintf(`{"error":{"message":"unknown devshard %s"}}`, devshardID), http.StatusNotFound)
 		return
@@ -1181,23 +1551,27 @@ func (g *Gateway) handleDevshard(w http.ResponseWriter, r *http.Request) {
 	if innerPath == "/v1/chat/completions" {
 		if ok, reason := rt.acceptsNewInferences(); !ok {
 			logRequestStage(ctx, "gateway_devshard_unavailable", "escrow", devshardID, "reason", reason)
+			g.recordGatewayRequestOutcome(firstNonEmpty(rt.model, g.settings.DefaultModel), "runtime_unavailable", runtimeSkipReasonKey(reason))
 			http.Error(w, fmt.Sprintf(`{"error":{"message":"devshard %s is unavailable for new inferences: %s"}}`, devshardID, reason), http.StatusConflict)
 			return
 		}
 		body, model, inputTokens, err := g.parseChatReservation(r, firstNonEmpty(rt.model, g.settings.DefaultModel))
 		if err != nil {
 			logRequestStage(ctx, "gateway_devshard_parse_failed", "escrow", devshardID, "error", err)
+			g.recordGatewayRequestOutcome(firstNonEmpty(model, rt.model, g.settings.DefaultModel), "invalid_request", "invalid_request")
 			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), chatRequestErrorStatus(err, http.StatusBadRequest))
 			return
 		}
 		if err := rt.validateRequestedModel(model); err != nil {
 			logRequestStage(ctx, "gateway_devshard_model_rejected", "escrow", devshardID, "model", model, "error", err)
+			g.recordGatewayRequestOutcome(firstNonEmpty(model, rt.model, g.settings.DefaultModel), "model_rejected", "model_rejected")
 			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), gatewayStatusCodeForError(err))
 			return
 		}
 		limitModel := firstNonEmpty(model, rt.model, g.settings.DefaultModel)
 		if err := g.modelAccessError(r, limitModel); err != nil {
 			logRequestStage(ctx, "gateway_devshard_model_temporarily_unavailable", "escrow", devshardID, "model", limitModel, "error", err)
+			g.recordGatewayRequestOutcome(limitModel, "model_rejected", "model_access_rejected")
 			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), gatewayStatusCodeForError(err))
 			return
 		}
@@ -1206,6 +1580,7 @@ func (g *Gateway) handleDevshard(w http.ResponseWriter, r *http.Request) {
 		if entry, ok := g.chatCache.Get(cacheKey, time.Now()); ok {
 			logRequestStage(ctx, "gateway_devshard_cache_hit", "escrow", entry.EscrowID, "model", limitModel, "stream", stream)
 			g.recordCachedAccountingAlias(ctx, entry)
+			g.recordGatewayRequestOutcome(limitModel, "cached", "cache_hit")
 			serveCachedChatResponse(w, r, entry)
 			return
 		}
@@ -1213,8 +1588,10 @@ func (g *Gateway) handleDevshard(w http.ResponseWriter, r *http.Request) {
 		if capacityAwareLimitsEnabled() || !relaxedPoCBypassActive() {
 			g.refreshCapacityScale()
 			if err := g.limiter.AcquireForModelWithCapacity(limitModel, inputTokens, g.limiterCapacityForModel(limitModel)); err != nil {
-				g.metrics.RecordLimitRejection(limiterReasonLabel(err))
-				logRequestStage(ctx, "gateway_devshard_limiter_rejected", "escrow", devshardID, "reason", limiterReasonLabel(err), "input_tokens", inputTokens)
+				reason := limiterReasonLabel(err)
+				g.metrics.RecordLimitRejection(reason)
+				g.recordGatewayRequestOutcome(limitModel, "gateway_limited", reason)
+				logRequestStage(ctx, "gateway_devshard_limiter_rejected", "escrow", devshardID, "reason", reason, "input_tokens", inputTokens)
 				http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusTooManyRequests)
 				return
 			}
@@ -1230,15 +1607,15 @@ func (g *Gateway) handleDevshard(w http.ResponseWriter, r *http.Request) {
 
 		if capture := g.serveChatToRuntime(rt, innerPath, body, w, r); capture != nil {
 			sourceRequestID, _ := requestLogFromContext(ctx)
-			if entry, ok := capture.cacheEntry(rt.id, stream, sourceRequestID); ok {
+			if entry, ok := capture.cacheEntry(rt.id, stream, sourceRequestID, r.Context().Err()); ok {
 				g.chatCache.Set(cacheKey, entry, time.Now())
-				logRequestStage(ctx, "gateway_devshard_cache_stored", "escrow", rt.id, "model", limitModel, "stream", stream, "bytes", len(entry.Body))
+				logRequestStage(ctx, "gateway_devshard_cache_stored", "escrow", rt.id, "model", limitModel, "stream", stream, "status", entry.StatusCode, "content_type", entry.ContentType, "bytes", len(entry.Body))
 			}
 		}
 		return
 	}
 	if innerPath == "/v1/finalize" && r.Method == http.MethodPost {
-		if rt.activeRequests.Load() > 0 {
+		if rt.escrowHasBackgroundWork() {
 			http.Error(w, fmt.Sprintf(`{"error":{"message":"devshard %s has active requests"}}`, devshardID), http.StatusConflict)
 			return
 		}
@@ -1287,6 +1664,91 @@ func (w *gatewayStatusResponseWriter) statusCode() int {
 	return w.status
 }
 
+// serveReadOnlyDevshard rehydrates a transient read-only runtime for a
+// non-resident devshard, serves a single read request against it, then closes
+// it. Each call loads and releases its own runtime (no caching, no
+// refcounting), so concurrent reads simply build independent transient
+// runtimes over the same on-disk storage.
+func (g *Gateway) serveReadOnlyDevshard(w http.ResponseWriter, r *http.Request, devshardID, innerPath string) {
+	ctx := r.Context()
+	rt, known, err := g.hydrateReadOnlyRuntime(devshardID)
+	if err != nil {
+		logRequestStage(ctx, "gateway_devshard_readonly_hydrate_failed", "escrow", devshardID, "error", err)
+		http.Error(w, fmt.Sprintf(`{"error":{"message":"devshard %s could not be loaded: %s"}}`, devshardID, err.Error()), http.StatusBadGateway)
+		return
+	}
+	if !known {
+		logRequestStage(ctx, "gateway_devshard_not_found", "escrow", devshardID)
+		http.Error(w, fmt.Sprintf(`{"error":{"message":"unknown devshard %s"}}`, devshardID), http.StatusNotFound)
+		return
+	}
+	defer func() {
+		if closeErr := rt.close(); closeErr != nil {
+			log.Printf("gateway_devshard_readonly_close_error escrow=%s error=%v", devshardID, closeErr)
+		}
+	}()
+	logRequestStage(ctx, "gateway_devshard_readonly_served", "escrow", devshardID, "path", innerPath)
+	req := cloneRequestWithBody(r, nil)
+	req.URL.Path = innerPath
+	req.URL.RawPath = innerPath
+	req.RequestURI = innerPath
+	w.Header().Set("X-Devshard-ID", devshardID)
+	w.Header().Set("X-Devshard-Readonly", "1")
+	rt.handler.ServeHTTP(w, req)
+}
+
+// serveInactiveDevshardMetadata answers the read-only devshard endpoints that
+// can be satisfied purely from cheap registry metadata -- no snapshot or state
+// load -- so an unauthenticated caller cannot use them to inflate gateway
+// memory. It returns true when it handled the request; false leaves the caller
+// to refuse (the devshard looks unknown to non-admins).
+//
+// Only /v1/models and a deliberately state-free /v1/status are
+// metadata-serviceable. Every other read-only path (e.g. /v1/requests/*, and
+// the admin-gated /v1/state and /v1/debug/*) needs a hydrated runtime and is
+// therefore admin-only for a non-resident devshard.
+func (g *Gateway) serveInactiveDevshardMetadata(w http.ResponseWriter, r *http.Request, devshardID, innerPath string) bool {
+	switch innerPath {
+	case "/v1/models", "/v1/status":
+	default:
+		return false
+	}
+	if g.store == nil {
+		return false
+	}
+	record, ok, err := g.store.GetDevshard(devshardID)
+	if err != nil || !ok {
+		return false
+	}
+	g.mu.Lock()
+	defaultModel := g.settings.DefaultModel
+	g.mu.Unlock()
+	model := firstNonEmpty(record.Model, defaultModel)
+
+	w.Header().Set("X-Devshard-ID", devshardID)
+	w.Header().Set("X-Devshard-Readonly", "1")
+	w.Header().Set("X-Devshard-Metadata-Only", "1")
+	switch innerPath {
+	case "/v1/models":
+		writeModelList(w, []string{model}, RequestMaxTokensCap)
+	case "/v1/status":
+		// State-free subset only: nonce/balance/phase would require loading
+		// the snapshot + replaying diffs, which is exactly what we are
+		// refusing to do for unauthenticated callers.
+		writeJSON(w, map[string]any{
+			"id":                 devshardID,
+			"model":              model,
+			"active":             record.Active,
+			"resident":           false,
+			"settlement_pending": record.SettlementPending,
+			"rotation_role":      record.RotationRole,
+			"rotation_epoch":     record.RotationEpoch,
+			"metadata_only":      true,
+		})
+	}
+	return true
+}
+
 func (g *Gateway) markDevshardInactiveAfterFinalize(id string, rt *devshardRuntime) {
 	rt.active.Store(false)
 	if g.store == nil {
@@ -1309,6 +1771,28 @@ func (g *Gateway) serveChatToRuntime(rt *devshardRuntime, path string, body []by
 	return capture
 }
 
+func (g *Gateway) recordGatewayRequestOutcome(model, outcome, reason string) {
+	if g == nil || g.metrics == nil {
+		return
+	}
+	g.metrics.RecordGatewayRequest(model, outcome, reason)
+	switch outcome {
+	case "failed", "runtime_unavailable", "gateway_limited", "invalid_request", "model_rejected", "gateway_disabled":
+		g.metrics.RecordCriticalUserFailure(model, reason)
+	}
+}
+
+func gatewayRuntimeUnavailableReason(err error) string {
+	switch {
+	case err == nil:
+		return "runtime_unavailable"
+	case isParticipantRateLimitError(err):
+		return "participant_limited"
+	default:
+		return "runtime_unavailable"
+	}
+}
+
 func (g *Gateway) recordCachedAccountingAlias(ctx context.Context, entry cachedChatResponse) {
 	requestID, ok := requestLogFromContext(ctx)
 	if !ok || requestID == "" || entry.SourceRequestID == "" || entry.EscrowID == "" {
@@ -1460,7 +1944,7 @@ func (g *Gateway) formatCandidateWeightsLocked(candidates []*devshardRuntime, re
 // Fallback rules:
 //   - No capacity state attached, or escrow not registered with the
 //     state (no slot/membership info): use neutral weight 1.0 so the
-//     picker degrades to a pure activeRequests comparison.
+//     picker degrades to a pure activeUserRequests comparison.
 //   - Escrow registered but W(e) == 0 (every host is PoC-excluded or
 //     fully throttled): honor the 0 so the runtime drops to +Inf load
 //     and stops receiving traffic until at least one host recovers.
@@ -1478,13 +1962,45 @@ func (g *Gateway) reserveRuntime(rt *devshardRuntime, inputTokens int64) {
 }
 
 func (g *Gateway) reserveRuntimeLocked(rt *devshardRuntime, inputTokens int64) {
-	rt.activeRequests.Add(1)
+	rt.activeUserRequests.Add(1)
 	rt.reservedTokens.Add(inputTokens)
 }
 
 func (g *Gateway) releaseRuntime(rt *devshardRuntime, inputTokens int64) {
-	rt.activeRequests.Add(-1)
+	remaining := rt.activeUserRequests.Add(-1)
 	rt.reservedTokens.Add(-inputTokens)
+	// Stay non-quiet while a background race cleanup is still refunding/persisting; its own releaseRaceCleanup re-checks the drain (whichever hits zero last fires; dedup makes a double-fire harmless).
+	if remaining != 0 || rt.pendingRaceCleanup.Load() != 0 {
+		return
+	}
+	g.runtimeDrained(rt)
+}
+
+// runtimeDrained fires the deferred settle/retire once a runtime is quiet; scheduleAutoSettlement/retireRuntime dedup, so a double-fire from the two drain paths is harmless.
+func (g *Gateway) runtimeDrained(rt *devshardRuntime) {
+	if rt.settlementPending.Load() {
+		log.Printf("settlement_drain_complete escrow=%s reason=%s", rt.id, rt.settlementReason)
+		g.scheduleAutoSettlement(rt.id, rt.settlementReason)
+		return
+	}
+	if rt.retirePending.Load() {
+		log.Printf("runtime_retire_drain_complete escrow=%s reason=%s", rt.id, rt.retireReason)
+		g.retireRuntime(rt.id, rt.retireReason)
+	}
+}
+
+// startRaceCleanup registers a background race cleanup against the drain barrier; it must run synchronously before the cleanup goroutine spawns (and before the winning handler returns).
+func (g *Gateway) startRaceCleanup(rt *devshardRuntime) {
+	rt.pendingRaceCleanup.Add(1)
+}
+
+// releaseRaceCleanup clears a race cleanup from the barrier and fires the deferred settle/retire if the runtime is now quiet.
+func (g *Gateway) releaseRaceCleanup(rt *devshardRuntime) {
+	remaining := rt.pendingRaceCleanup.Add(-1)
+	if remaining != 0 || rt.activeUserRequests.Load() != 0 {
+		return
+	}
+	g.runtimeDrained(rt)
 }
 
 func (rt *devshardRuntime) validateRequestedModel(requestModel string) error {
@@ -1890,6 +2406,12 @@ type adminSettleEscrowRequest struct {
 	GasLimit      uint64 `json:"gas_limit,omitempty"`
 }
 
+type adminSuspiciousHostsRequest struct {
+	ParticipantKey  string   `json:"participant_key,omitempty"`
+	ParticipantKeys []string `json:"participant_keys,omitempty"`
+	Note            string   `json:"note,omitempty"`
+}
+
 type adminSettingsRequest struct {
 	ChainREST                      *string                          `json:"chain_rest,omitempty"`
 	PublicAPI                      *string                          `json:"public_api,omitempty"`
@@ -2008,10 +2530,11 @@ func (g *Gateway) handleAdminState(w http.ResponseWriter, r *http.Request) {
 		views = append(views, view)
 	}
 	writeJSON(w, map[string]any{
-		"settings":  state.Settings,
-		"devshards": views,
-		"limiter":   g.limiter.SnapshotWithModelCapacities(g.limiterModelCapacities(models, modelRuntimeStatuses)),
-		"capacity":  g.capacityStatus(models, modelRuntimeStatuses),
+		"settings":         state.Settings,
+		"devshards":        views,
+		"suspicious_hosts": state.SuspiciousHosts,
+		"limiter":          g.limiter.SnapshotWithModelCapacities(g.limiterModelCapacities(models, modelRuntimeStatuses)),
+		"capacity":         g.capacityStatus(models, modelRuntimeStatuses),
 	})
 }
 
@@ -2128,6 +2651,59 @@ func (g *Gateway) handleAdminSettings(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func (g *Gateway) handleAdminSuspiciousHosts(w http.ResponseWriter, r *http.Request) {
+	if g.store == nil {
+		http.Error(w, `{"error":{"message":"gateway state store unavailable"}}`, http.StatusServiceUnavailable)
+		return
+	}
+	switch r.Method {
+	case http.MethodGet:
+		hosts, err := g.store.LoadSuspiciousHosts()
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusInternalServerError)
+			return
+		}
+		g.replaceSuspiciousHosts(hosts)
+		writeJSON(w, map[string]any{"suspicious_hosts": hosts})
+	case http.MethodPost:
+		var req adminSuspiciousHostsRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadRequest)
+			return
+		}
+		hosts, err := g.store.UpsertSuspiciousHosts(adminSuspiciousParticipantKeys(req), req.Note)
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadRequest)
+			return
+		}
+		g.replaceSuspiciousHosts(hosts)
+		writeJSON(w, map[string]any{"suspicious_hosts": hosts})
+	case http.MethodDelete:
+		var req adminSuspiciousHostsRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadRequest)
+			return
+		}
+		hosts, err := g.store.DeleteSuspiciousHosts(adminSuspiciousParticipantKeys(req))
+		if err != nil {
+			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadRequest)
+			return
+		}
+		g.replaceSuspiciousHosts(hosts)
+		writeJSON(w, map[string]any{"suspicious_hosts": hosts})
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func adminSuspiciousParticipantKeys(req adminSuspiciousHostsRequest) []string {
+	keys := append([]string(nil), req.ParticipantKeys...)
+	if strings.TrimSpace(req.ParticipantKey) != "" {
+		keys = append(keys, req.ParticipantKey)
+	}
+	return normalizeParticipantKeys(keys)
+}
+
 func (g *Gateway) handleDebugRotation(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
@@ -2506,7 +3082,7 @@ func (g *Gateway) handleAdminEscrows(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadRequest)
 		return
 	}
-	result, err := txClient.CreateDevshardEscrow(r.Context(), signer, req.Amount, modelID)
+	result, err := txClient.CreateDevshardEscrow(r.Context(), signer, req.Amount, modelID, nil)
 	if err != nil {
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadGateway)
 		return
@@ -2586,7 +3162,7 @@ func (g *Gateway) addCreatedEscrowRuntime(record GatewayDevshardState) (GatewayD
 		return record, fmt.Errorf("gateway state is not initialized")
 	}
 	if _, exists := g.runtimes[record.ID]; exists {
-		return record, fmt.Errorf("devshard %s already exists", record.ID)
+		return record, fmt.Errorf("devshard %s: %w", record.ID, errDevshardAlreadyExists)
 	}
 	if record.Model == "" {
 		record.Model = state.Settings.DefaultModel
@@ -2631,6 +3207,10 @@ func (g *Gateway) handleAdminDevshardAction(w http.ResponseWriter, r *http.Reque
 		g.handleAdminDeactivateDevshard(w, r, id)
 		return
 	}
+	if len(parts) == 2 && parts[1] == "activate" && r.Method == http.MethodPost {
+		g.handleAdminActivateDevshard(w, r, id)
+		return
+	}
 	if len(parts) == 2 && parts[1] == "settle" && r.Method == http.MethodPost {
 		g.handleAdminSettleDevshard(w, r, id)
 		return
@@ -2662,7 +3242,7 @@ func (g *Gateway) handleAdminDevshardParticipants(w http.ResponseWriter, r *http
 	}
 	model := rt.model
 	active := rt.active.Load()
-	activeRequests := rt.activeRequests.Load()
+	activeUserRequests := rt.activeUserRequests.Load()
 	participantKeys := runtimeParticipantKeys(rt)
 	slotCounts := make(map[string]int, len(rt.participantSlotCounts))
 	for key, count := range rt.participantSlotCounts {
@@ -2707,7 +3287,7 @@ func (g *Gateway) handleAdminDevshardParticipants(w http.ResponseWriter, r *http
 		"id":                id,
 		"model":             model,
 		"active":            active,
-		"active_requests":   activeRequests,
+		"active_requests":   activeUserRequests,
 		"participant_count": len(participants),
 		"available_count":   availableCount,
 		"blocked_count":     blockedCount,
@@ -3032,24 +3612,90 @@ func (g *Gateway) handleAdminDeactivateDevshard(w http.ResponseWriter, r *http.R
 		return
 	}
 	g.mu.Lock()
-	defer g.mu.Unlock()
-
 	rt, ok := g.runtimes[id]
 	if !ok {
+		g.mu.Unlock()
 		http.Error(w, fmt.Sprintf(`{"error":{"message":"devshard %s is not active"}}`, id), http.StatusNotFound)
 		return
 	}
 	if err := g.store.SetDevshardActive(id, false); err != nil {
+		g.mu.Unlock()
 		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusInternalServerError)
 		return
 	}
 	rt.active.Store(false)
+	// Retire from memory so the deactivated runtime stops consuming RAM.
+	// retireRuntimeLocked is drain-safe: if requests are still in flight it
+	// only marks the runtime retire-pending and returns nil, and the drain
+	// hook in releaseRuntime completes the retirement once the last request
+	// finishes. When idle it returns the runtime for us to close outside the
+	// lock. We hold g.mu here, so we must use the *Locked variant (the plain
+	// retireRuntime re-acquires g.mu and would deadlock).
+	retired := g.retireRuntimeLocked(id, "deactivated")
+	g.mu.Unlock()
+	if retired != nil {
+		if err := retired.retireClose("deactivated"); err != nil {
+			log.Printf("deactivate_retire_close_error escrow=%s error=%v", id, err)
+		}
+	}
 	writeJSON(w, map[string]any{
 		"id":     id,
 		"active": false,
 	})
 }
 
+// handleAdminActivateDevshard brings a non-resident (inactive) devshard back
+// into the memory-resident routing pool. It builds a full runtime with chain
+// access and registers it. If the devshard is already resident it simply flips
+// the active flag. This is the reverse of deactivate and the recovery path for
+// devshards demoted at boot or after finalize.
+func (g *Gateway) handleAdminActivateDevshard(w http.ResponseWriter, r *http.Request, id string) {
+	if g.store == nil {
+		http.Error(w, `{"error":{"message":"gateway state store unavailable"}}`, http.StatusServiceUnavailable)
+		return
+	}
+
+	g.mu.Lock()
+	if rt, ok := g.runtimes[id]; ok {
+		if err := g.store.SetDevshardActive(id, true); err != nil {
+			g.mu.Unlock()
+			http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusInternalServerError)
+			return
+		}
+		rt.active.Store(true)
+		g.mu.Unlock()
+		writeJSON(w, map[string]any{
+			"id":               id,
+			"active":           true,
+			"already_resident": true,
+		})
+		return
+	}
+	g.mu.Unlock()
+
+	record, ok, err := g.store.GetDevshard(id)
+	if err != nil {
+		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusInternalServerError)
+		return
+	}
+	if !ok {
+		http.Error(w, fmt.Sprintf(`{"error":{"message":"devshard %s not found"}}`, id), http.StatusNotFound)
+		return
+	}
+	record.Active = true
+	record, err = g.addCreatedEscrowRuntime(record)
+	if err != nil {
+		http.Error(w, fmt.Sprintf(`{"error":{"message":%q}}`, err.Error()), http.StatusBadGateway)
+		return
+	}
+	log.Printf("devshard_activated escrow=%s model=%s storage=%s", record.ID, record.Model, record.StoragePath)
+	writeJSON(w, map[string]any{
+		"id":     record.ID,
+		"model":  record.Model,
+		"active": true,
+	})
+}
+
 func (g *Gateway) handleAdminCleanDevshard(w http.ResponseWriter, r *http.Request, id string) {
 	if g.store == nil {
 		http.Error(w, `{"error":{"message":"gateway state store unavailable"}}`, http.StatusServiceUnavailable)
@@ -3077,7 +3723,7 @@ func (g *Gateway) handleAdminCleanDevshard(w http.ResponseWriter, r *http.Reques
 		return
 	}
 	if rt, ok := g.runtimes[id]; ok {
-		if rt.activeRequests.Load() > 0 {
+		if rt.escrowHasBackgroundWork() {
 			http.Error(w, fmt.Sprintf(`{"error":{"message":"devshard %s has active requests"}}`, id), http.StatusConflict)
 			return
 		}
@@ -3150,6 +3796,49 @@ func removeRuntime(runtimes []*devshardRuntime, id string) []*devshardRuntime {
 	return out
 }
 
+// retireRuntime drops a runtime from the in-memory registry and closes it,
+// releasing its user session and the per-runtime SQLite handles that session owns.
+func (g *Gateway) retireRuntime(id, reason string) bool {
+	g.mu.Lock()
+	rt := g.retireRuntimeLocked(id, reason)
+	g.mu.Unlock()
+	if rt == nil {
+		return false
+	}
+	// Close the per-runtime SQLite store outside g.mu: it is disk I/O and must
+	// not block other gateway operations that contend for the lock. retireClose
+	// also flushes a final snapshot so the frozen escrow rebuilds replay-free.
+	if err := rt.retireClose(reason); err != nil {
+		log.Printf("runtime_retire_close_error escrow=%s reason=%q error=%v", id, reason, err)
+	}
+	log.Printf("runtime_retired escrow=%s reason=%q", id, reason)
+	return true
+}
+
+// retireRuntimeLocked removes the runtime from the registry and returns it so
+// the caller can close it outside the lock. It returns nil when nothing was
+// retired: the runtime is unknown, or its retirement was deferred because
+// requests are still in flight. Callers must hold g.mu.
+func (g *Gateway) retireRuntimeLocked(id, reason string) *devshardRuntime {
+	rt, ok := g.runtimes[id]
+	if !ok {
+		log.Printf("runtime_retire_skipped escrow=%s reason=%q cause=not_registered", id, reason)
+		return nil
+	}
+	if rt.escrowHasBackgroundWork() {
+		rt.retireReason = reason
+		rt.retirePending.Store(true)
+		log.Printf("runtime_retire_deferred escrow=%s reason=%q active_requests=%d pending_race_cleanup=%d", id, reason, rt.activeUserRequests.Load(), rt.pendingRaceCleanup.Load())
+		return nil
+	}
+	delete(g.runtimes, id)
+	g.runtimeOrder = removeRuntime(g.runtimeOrder, id)
+	if g.capacity != nil {
+		g.capacity.RemoveEscrow(id)
+	}
+	return rt
+}
+
 func (g *Gateway) sortRuntimeOrderLocked() {
 	slices.SortFunc(g.runtimeOrder, func(a, b *devshardRuntime) int {
 		return strings.Compare(a.id, b.id)
@@ -3164,6 +3853,15 @@ func (g *Gateway) attachMetrics(rt *devshardRuntime) {
 	rt.proxy.redundancy.devshardID = rt.id
 }
 
+// attachRaceCleanupBarrier wires the runtime's background race cleanups into the drain barrier so settle/store-close wait for them, not just for foreground requests.
+func (g *Gateway) attachRaceCleanupBarrier(rt *devshardRuntime) {
+	if g == nil || rt == nil || rt.proxy == nil || rt.proxy.redundancy == nil {
+		return
+	}
+	rt.proxy.redundancy.onRaceCleanupStart = func() { g.startRaceCleanup(rt) }
+	rt.proxy.redundancy.onRaceCleanupDone = func() { g.releaseRaceCleanup(rt) }
+}
+
 func (g *Gateway) attachEscrowChecker(rt *devshardRuntime) {
 	if g == nil || rt == nil || rt.proxy == nil || rt.proxy.redundancy == nil {
 		return
@@ -3174,12 +3872,15 @@ func (g *Gateway) attachEscrowChecker(rt *devshardRuntime) {
 		rt.proxy.redundancy.onEscrowMissing = func() {
 			go g.escrowChecker.TriggerCheck(escrowID, func() {
 				g.deactivateDevshardByID(escrowID)
+				// Escrow no longer exists on chain -- nothing to settle.
+				g.retireRuntime(escrowID, "escrow confirmed missing on chain")
 			})
 		}
 	}
 	rt.proxy.redundancy.onBalanceExhausted = func() {
 		if !g.escrowRotationEnabled() {
 			g.deactivateDevshardByIDWithReason(escrowID, "escrow balance exhausted")
+			g.retireRuntime(escrowID, "escrow balance exhausted")
 			return
 		}
 		log.Printf("gateway_replacing_exhausted_escrow escrow=%s", escrowID)
@@ -3220,24 +3921,116 @@ func (g *Gateway) deactivateDevshardByIDWithReason(id, reason string) bool {
 	return true
 }
 
+// deactivateAndSettleDevshardByID stops new traffic to an escrow and settles
+// it. If requests are still in flight it marks the escrow settlement-pending
+// and returns; the drain hook in releaseRuntime settles once the last request
+// finishes. Otherwise it settles immediately.
 func (g *Gateway) deactivateAndSettleDevshardByID(id, reason string) {
 	if !g.deactivateDevshardByIDWithReason(id, reason) {
 		return
 	}
+	g.markSettlementPending(id, reason)
+
+	g.mu.Lock()
+	rt, ok := g.runtimes[id]
+	g.mu.Unlock()
+	if ok && rt.escrowHasBackgroundWork() {
+		log.Printf("settlement_queued_waiting_for_drain escrow=%s reason=%s active_requests=%d pending_race_cleanup=%d",
+			id, reason, rt.activeUserRequests.Load(), rt.pendingRaceCleanup.Load())
+		return
+	}
 	g.scheduleAutoSettlement(id, reason)
 }
 
+// markSettlementPending records that an escrow must be settled once its
+// in-flight requests drain. The reason is stored before the flag so the
+// lock-free drain hook in releaseRuntime reads a consistent value.
+func (g *Gateway) markSettlementPending(id, reason string) {
+	g.mu.Lock()
+	rt, ok := g.runtimes[id]
+	if ok {
+		rt.settlementReason = reason
+		rt.settlementPending.Store(true)
+	}
+	g.mu.Unlock()
+	if g.store != nil {
+		if err := g.store.SetDevshardSettlementPending(id, true); err != nil {
+			log.Printf("settlement_pending_persist_failed escrow=%s error=%v", id, err)
+		}
+	}
+}
+
+// reconcilePendingSettlements settles escrows that were marked pending before
+// a restart. After a restart no requests are in flight, so each such escrow
+// can settle immediately. Hydrates the in-memory marker too.
+func (g *Gateway) reconcilePendingSettlements() {
+	if g.store == nil {
+		return
+	}
+	state, ok, err := g.store.LoadState()
+	if err != nil || !ok {
+		if err != nil {
+			log.Printf("settlement_reconcile_load_failed error=%v", err)
+		}
+		return
+	}
+	// Honor the operator's config: when settlement is disabled, never settle on
+	// startup. Leave the marker intact so a later re-enable still settles it.
+	if !state.Settings.EscrowRotation.SettlementEnabled {
+		for _, devshard := range state.Devshards {
+			if !devshard.Active && devshard.SettlementPending {
+				log.Printf("settlement_reconcile_skipped escrow=%s reason=settlement_disabled", devshard.ID)
+			}
+		}
+		return
+	}
+	for _, devshard := range state.Devshards {
+		if devshard.Active || !devshard.SettlementPending {
+			continue
+		}
+		g.mu.Lock()
+		if rt, exists := g.runtimes[devshard.ID]; exists {
+			rt.settlementReason = "startup_reconcile"
+			rt.settlementPending.Store(true)
+		}
+		g.mu.Unlock()
+		// Non-resident pending devshards are still settled: scheduleAutoSettlement
+		// drives settleDevshardOnChain, which rehydrates a transient full runtime
+		// from local storage when the devshard is not resident in memory.
+		log.Printf("settlement_reconcile_queued escrow=%s", devshard.ID)
+		g.scheduleAutoSettlement(devshard.ID, "startup_reconcile")
+	}
+}
+
+// clearSettlementPending is called after a successful settlement so a
+// restart-time reconcile does not re-settle the escrow.
+func (g *Gateway) clearSettlementPending(id string) {
+	g.mu.Lock()
+	rt, ok := g.runtimes[id]
+	if ok {
+		rt.settlementPending.Store(false)
+	}
+	g.mu.Unlock()
+	if g.store != nil {
+		if err := g.store.SetDevshardSettlementPending(id, false); err != nil {
+			log.Printf("settlement_pending_clear_failed escrow=%s error=%v", id, err)
+		}
+	}
+}
+
 func (g *Gateway) retireRotatedDevshard(ctx context.Context, id, reason string, settings GatewaySettings) (bool, error) {
 	if !settings.EscrowRotation.SettlementEnabled {
 		if g.deactivateDevshardByIDWithReason(id, reason) {
 			log.Printf("escrow_rotation_deactivated_without_settlement escrow=%s reason=%q", id, reason)
 		}
+		g.retireRuntime(id, reason)
 		return false, nil
 	}
 	log.Printf("escrow_rotation_settling escrow=%s reason=%q", id, reason)
 	if _, err := gatewaySettleDevshardOnChain(g, ctx, id, adminSettleEscrowRequest{}); err != nil {
 		return false, err
 	}
+	g.retireRuntime(id, reason)
 	return true, nil
 }
 
@@ -3302,6 +4095,7 @@ func (g *Gateway) replaceDepletedEscrow(ctx context.Context, id, modelID, reason
 		id, result.EscrowID, model.ModelID, reason, result.TxHash)
 	if !settings.EscrowRotation.SettlementEnabled {
 		g.deactivateDevshardByIDWithReason(id, reason)
+		g.retireRuntime(id, reason)
 	} else {
 		g.deactivateAndSettleDevshardByID(id, reason)
 	}
@@ -3350,13 +4144,19 @@ func (g *Gateway) scheduleAutoSettlement(id, reason string) {
 			result, err := gatewaySettleDevshardOnChain(g, ctx, id, adminSettleEscrowRequest{})
 			cancel()
 			if err == nil {
+				g.clearSettlementPending(id)
 				log.Printf("auto_settle_submitted escrow=%s reason=%s tx_hash=%s settler=%s",
 					id, reason, result.TxHash, result.Settler)
+				g.retireRuntime(id, reason)
 				return
 			}
 			log.Printf("auto_settle_failed escrow=%s reason=%s attempt=%d/%d error=%v",
 				id, reason, attempt, autoSettlementMaxAttempts, err)
 			if attempt == autoSettlementMaxAttempts {
+				// Settlement exhausted its retries; free the in-memory runtime
+				// anyway so a permanently-unsettleable escrow cannot leak its
+				// SQLite store. On-disk state is preserved for manual recovery.
+				g.retireRuntime(id, reason)
 				return
 			}
 			time.Sleep(autoSettlementRetryInterval)
diff --git a/devshard/cmd/devshardctl/gateway_inactive_access_test.go b/devshard/cmd/devshardctl/gateway_inactive_access_test.go
new file mode 100644
index 0000000000..19f46873ed
--- /dev/null
+++ b/devshard/cmd/devshardctl/gateway_inactive_access_test.go
@@ -0,0 +1,124 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// newInactiveDevshardGateway builds a store-backed gateway that knows about a
+// single non-resident (not in memory), inactive devshard "77". Because no
+// runtime is registered, any /devshard/77/... read takes the non-resident
+// branch of handleDevshard.
+func newInactiveDevshardGateway(t *testing.T) *Gateway {
+	t.Helper()
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, store.Close()) })
+
+	settings := GatewaySettings{DefaultModel: "m"}
+	devshards := []GatewayDevshardState{{
+		RuntimeConfig: RuntimeConfig{
+			ID:            "77",
+			PrivateKeyHex: "secret",
+			Model:         "m",
+			StoragePath:   filepath.Join(t.TempDir(), "escrow-77"),
+		},
+		Active: false,
+	}}
+	require.NoError(t, store.Initialize(settings, devshards))
+
+	return NewManagedGateway(nil, NewGatewayLimiter(0, 0), settings, t.TempDir(), store)
+}
+
+// A non-admin caller may read a non-resident devshard's /v1/status, but only
+// the cheap, state-free metadata subset -- no snapshot/state is loaded.
+func TestInactiveDevshardPublicStatusIsMetadataOnly(t *testing.T) {
+	g := newInactiveDevshardGateway(t)
+
+	req := httptest.NewRequest(http.MethodGet, "/devshard/77/v1/status", nil)
+	rec := httptest.NewRecorder()
+	g.handleDevshard(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+	require.Equal(t, "1", rec.Header().Get("X-Devshard-Metadata-Only"))
+
+	var body map[string]any
+	require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &body))
+	require.Equal(t, "77", body["id"])
+	require.Equal(t, "m", body["model"])
+	require.Equal(t, false, body["active"])
+	require.Equal(t, false, body["resident"])
+	require.Equal(t, true, body["metadata_only"])
+
+	// Fields that would require replaying diffs / loading a snapshot must be
+	// absent: the whole point is that no state was hydrated.
+	require.NotContains(t, body, "nonce")
+	require.NotContains(t, body, "balance")
+	require.NotContains(t, body, "phase")
+}
+
+// /v1/models is derivable from cheap registry config, so it is public for a
+// non-resident devshard.
+func TestInactiveDevshardPublicModelsIsMetadataOnly(t *testing.T) {
+	g := newInactiveDevshardGateway(t)
+
+	req := httptest.NewRequest(http.MethodGet, "/devshard/77/v1/models", nil)
+	rec := httptest.NewRecorder()
+	g.handleDevshard(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+	require.Equal(t, "1", rec.Header().Get("X-Devshard-Metadata-Only"))
+	require.Contains(t, rec.Body.String(), `"m"`)
+}
+
+// A read that needs hydrated state (here /v1/requests/*) is refused for a
+// non-admin caller on a non-resident devshard: it must look unknown and must
+// not hydrate (no metadata-only response either).
+func TestInactiveDevshardPublicStatefulReadRefused(t *testing.T) {
+	g := newInactiveDevshardGateway(t)
+
+	req := httptest.NewRequest(http.MethodGet, "/devshard/77/v1/requests/abc", nil)
+	rec := httptest.NewRecorder()
+	g.handleDevshard(rec, req)
+
+	require.Equal(t, http.StatusNotFound, rec.Code)
+	require.Empty(t, rec.Header().Get("X-Devshard-Metadata-Only"))
+	require.Contains(t, rec.Body.String(), "unknown devshard")
+}
+
+// With admin auth present, the non-resident read path hydrates a transient
+// runtime instead of returning the metadata-only response. We only assert it
+// did NOT take the metadata-only branch (hydration may succeed or fail
+// depending on on-disk storage, but either way it is not metadata-only).
+func TestInactiveDevshardAdminReadHydrates(t *testing.T) {
+	g := newInactiveDevshardGateway(t)
+
+	req := httptest.NewRequest(http.MethodGet, "/devshard/77/v1/status", nil)
+	req = req.WithContext(context.WithValue(req.Context(), adminAuthContextKey{}, true))
+	rec := httptest.NewRecorder()
+	g.handleDevshard(rec, req)
+
+	require.Empty(t, rec.Header().Get("X-Devshard-Metadata-Only"),
+		"admin read must hydrate, not serve the metadata-only response")
+}
+
+// An unknown (not-in-store) devshard must not reveal anything to a non-admin,
+// even on the otherwise-public metadata paths.
+func TestUnknownDevshardPublicReadIsNotFound(t *testing.T) {
+	g := newInactiveDevshardGateway(t)
+
+	for _, path := range []string{"/devshard/does-not-exist/v1/status", "/devshard/does-not-exist/v1/models"} {
+		req := httptest.NewRequest(http.MethodGet, path, nil)
+		rec := httptest.NewRecorder()
+		g.handleDevshard(rec, req)
+
+		require.Equal(t, http.StatusNotFound, rec.Code, "path=%s", path)
+		require.Empty(t, rec.Header().Get("X-Devshard-Metadata-Only"), "path=%s", path)
+	}
+}
diff --git a/devshard/cmd/devshardctl/gateway_race_cleanup_barrier_test.go b/devshard/cmd/devshardctl/gateway_race_cleanup_barrier_test.go
new file mode 100644
index 0000000000..cf69ff65d5
--- /dev/null
+++ b/devshard/cmd/devshardctl/gateway_race_cleanup_barrier_test.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+// A speculative race returns to the client on the winner and hands its still
+// pending losers to a background race cleanup (finishRaceWhenPendingDone) that
+// keeps refunding reserved cost and persisting loser signatures on
+// context.Background() for up to SecondaryWaitAfterWinner. That cleanup holds no
+// activeUserRequests slot, so the drain barrier must track it separately:
+// settling (which reads the balance the cleanup is still mutating) and retiring
+// (which closes the SQLite store the cleanup is still writing to) must both wait
+// until the cleanup drains too.
+
+// TestReleaseRuntimeDefersSettleWhilePendingRaceCleanup pins the money branch: a
+// runtime with a pending race cleanup must NOT settle when its last foreground
+// request drains — only once the cleanup completes as well.
+func TestReleaseRuntimeDefersSettleWhilePendingRaceCleanup(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold-1, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	g.reserveRuntime(rt, 1) // the one in-flight foreground request
+	g.startRaceCleanup(rt)  // its background race cleanup, spawned before it returns
+	rt.settlementReason = "low_balance"
+	rt.settlementPending.Store(true)
+
+	g.releaseRuntime(rt, 1) // foreground request returns; cleanup still in flight
+	require.Never(t, func() bool { return settled.Load() > 0 }, 200*time.Millisecond, 20*time.Millisecond,
+		"settlement must not fire while a background race cleanup is still refunding/persisting")
+
+	g.releaseRaceCleanup(rt) // cleanup drains
+	require.Eventually(t, func() bool { return settled.Load() == 1 }, time.Second, 10*time.Millisecond,
+		"settlement must fire exactly once, after the cleanup drains")
+}
+
+// TestReleaseRuntimeDefersRetireWhilePendingRaceCleanup pins the durability
+// branch: retirement (which closes the per-runtime SQLite store) must defer
+// while a race cleanup is still writing loser signatures, and fire once it drains.
+func TestReleaseRuntimeDefersRetireWhilePendingRaceCleanup(t *testing.T) {
+	g, rt := newRetireTestGateway("12")
+	g.reserveRuntime(rt, 0) // the one in-flight foreground request
+	g.startRaceCleanup(rt)  // its background race cleanup
+	rt.retireReason = "balance exhausted"
+	rt.retirePending.Store(true)
+
+	g.releaseRuntime(rt, 0) // foreground request returns; cleanup still in flight
+	_, stillRegistered := g.runtimes["12"]
+	require.True(t, stillRegistered, "retire must defer while a race cleanup is in flight")
+
+	g.releaseRaceCleanup(rt) // cleanup drains
+	_, stillRegistered = g.runtimes["12"]
+	require.False(t, stillRegistered, "retire fires once the cleanup drains")
+	require.Empty(t, g.runtimeOrder)
+}
+
+// TestGoTrackedRaceCleanupStartsBarrierSynchronously pins the ordering contract
+// the fix depends on: the start hook must fire synchronously, before the cleanup
+// goroutine is spawned, so a winning foreground handler that returns and drops
+// activeUserRequests immediately afterwards can never observe the runtime as
+// quiet while this cleanup is still in flight.
+func TestGoTrackedRaceCleanupStartsBarrierSynchronously(t *testing.T) {
+	var started, done atomic.Int64
+	release := make(chan struct{})
+	redundancy := &Redundancy{
+		onRaceCleanupStart: func() { started.Add(1) },
+		onRaceCleanupDone:  func() { done.Add(1) },
+	}
+
+	redundancy.goTrackedRaceCleanup(func() { <-release })
+
+	require.Equal(t, int64(1), started.Load(), "start hook must fire before goTrackedRaceCleanup returns")
+	require.Equal(t, int64(0), done.Load(), "done hook must not fire while the cleanup runs")
+
+	close(release)
+	require.Eventually(t, func() bool { return done.Load() == 1 }, time.Second, 10*time.Millisecond,
+		"done hook must fire once the cleanup completes")
+}
+
+// TestConcurrentDrainSettlesExactlyOnce guards the two-counter drain: when the
+// last foreground request and the last race cleanup reach zero concurrently,
+// exactly one of the racing drain paths must settle — never zero (a lost
+// wakeup) and, thanks to dedup, never twice.
+func TestConcurrentDrainSettlesExactlyOnce(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold-1, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	g.reserveRuntime(rt, 1)
+	g.startRaceCleanup(rt)
+	rt.settlementReason = "low_balance"
+	rt.settlementPending.Store(true)
+
+	var ready sync.WaitGroup
+	ready.Add(2)
+	start := make(chan struct{})
+	go func() { ready.Done(); <-start; g.releaseRuntime(rt, 1) }()
+	go func() { ready.Done(); <-start; g.releaseRaceCleanup(rt) }()
+	ready.Wait()
+	close(start) // release both drains as simultaneously as the scheduler allows
+
+	require.Eventually(t, func() bool { return settled.Load() == 1 }, time.Second, 10*time.Millisecond,
+		"a concurrent drain must settle exactly once")
+	require.Never(t, func() bool { return settled.Load() > 1 }, 200*time.Millisecond, 20*time.Millisecond,
+		"dedup must keep a double drain from settling twice")
+}
diff --git a/devshard/cmd/devshardctl/gateway_runtime_retire_test.go b/devshard/cmd/devshardctl/gateway_runtime_retire_test.go
new file mode 100644
index 0000000000..6f440fbab3
--- /dev/null
+++ b/devshard/cmd/devshardctl/gateway_runtime_retire_test.go
@@ -0,0 +1,149 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+// newRetireTestGateway builds a minimal Gateway holding a single active runtime
+// registered in both the lookup map and the ordered slice, mirroring how the
+// real registry is populated.
+func newRetireTestGateway(id string) (*Gateway, *devshardRuntime) {
+	rt := &devshardRuntime{id: id}
+	rt.active.Store(true)
+	g := &Gateway{
+		runtimes:         map[string]*devshardRuntime{id: rt},
+		runtimeOrder:     []*devshardRuntime{rt},
+		rotationBreakers: make(map[string]*rotationBreaker),
+	}
+	return g, rt
+}
+
+// TestRetireRuntimeRemovesRuntimeFromRegistry pins the core leak fix: retiring a
+// runtime must drop it from both g.runtimes and g.runtimeOrder so its
+// user.Session (and the per-runtime SQLite handles it owns) can be released.
+func TestRetireRuntimeRemovesRuntimeFromRegistry(t *testing.T) {
+	g, _ := newRetireTestGateway("12")
+
+	require.True(t, g.retireRuntime("12", "test"))
+
+	_, stillRegistered := g.runtimes["12"]
+	require.False(t, stillRegistered, "runtime must be removed from g.runtimes")
+	require.Empty(t, g.runtimeOrder, "runtime must be removed from g.runtimeOrder")
+
+	// Idempotent: retiring an already-gone runtime is a no-op, not a panic.
+	require.False(t, g.retireRuntime("12", "test"))
+}
+
+// TestRetireRuntimeDefersWhileRequestsInFlight guards against closing a SQLite
+// store out from under an in-flight request: retirement must defer (and leave
+// the runtime registered) until the request count drains to zero.
+func TestRetireRuntimeDefersWhileRequestsInFlight(t *testing.T) {
+	g, rt := newRetireTestGateway("12")
+	rt.activeUserRequests.Store(1)
+
+	require.False(t, g.retireRuntime("12", "busy"))
+	_, stillRegistered := g.runtimes["12"]
+	require.True(t, stillRegistered, "busy runtime must stay registered")
+	require.True(t, rt.retirePending.Load(), "deferred retire must record its intent")
+	require.Equal(t, "busy", rt.retireReason)
+
+	rt.activeUserRequests.Store(0)
+	require.True(t, g.retireRuntime("12", "drained"))
+	_, stillRegistered = g.runtimes["12"]
+	require.False(t, stillRegistered)
+}
+
+// TestReleaseRuntimeRetiresAfterDrain: a retire deferred while busy fires once
+// the last request drains through releaseRuntime.
+func TestReleaseRuntimeRetiresAfterDrain(t *testing.T) {
+	g, rt := newRetireTestGateway("12")
+	rt.activeUserRequests.Store(1)
+
+	require.False(t, g.retireRuntime("12", "balance exhausted"))
+	_, stillRegistered := g.runtimes["12"]
+	require.True(t, stillRegistered, "busy runtime must stay registered")
+
+	g.releaseRuntime(rt, 0)
+
+	_, stillRegistered = g.runtimes["12"]
+	require.False(t, stillRegistered, "drained runtime must be retired by releaseRuntime")
+	require.Empty(t, g.runtimeOrder)
+}
+
+// TestReleaseRuntimeRetiresWithOnlyRetirePending exercises the retire branch in
+// isolation: only retirePending set (no settlement), drain → retire.
+func TestReleaseRuntimeRetiresWithOnlyRetirePending(t *testing.T) {
+	g, rt := newRetireTestGateway("12")
+	rt.activeUserRequests.Store(1)
+	rt.retireReason = "balance exhausted"
+	rt.retirePending.Store(true)
+
+	g.releaseRuntime(rt, 0)
+
+	_, stillRegistered := g.runtimes["12"]
+	require.False(t, stillRegistered, "retire branch must fire on drain")
+	require.Empty(t, g.runtimeOrder)
+}
+
+// TestReleaseRuntimeDefersWhileRequestsRemain: while remaining != 0 nothing
+// fires; settled stays 0 until the last request drains. Uses settlementPending
+// because scheduleAutoSettlement fires regardless of the live count, so a
+// broken guard leaks as settled>0 (retire would self-defer and hide it).
+func TestReleaseRuntimeDefersWhileRequestsRemain(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold-1, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	g.reserveRuntime(rt, 1)
+	g.reserveRuntime(rt, 1)
+	rt.settlementReason = "low_balance"
+	rt.settlementPending.Store(true)
+
+	g.releaseRuntime(rt, 1) // remaining == 1 → quiet
+	require.Never(t, func() bool { return settled.Load() > 0 }, 200*time.Millisecond, 20*time.Millisecond)
+
+	g.releaseRuntime(rt, 1) // remaining == 0 → settles once
+	require.Eventually(t, func() bool { return settled.Load() == 1 }, time.Second, 10*time.Millisecond)
+}
+
+// TestRetireRotatedDevshardRetiresWithoutSettlement covers the no-settle
+// terminal path: when settlement is disabled, the rotated-out runtime is
+// deactivated AND retired in the same step.
+func TestRetireRotatedDevshardRetiresWithoutSettlement(t *testing.T) {
+	g, _ := newRetireTestGateway("12")
+	settings := GatewaySettings{EscrowRotation: EscrowRotationSettings{SettlementEnabled: false}}
+
+	settled, err := g.retireRotatedDevshard(context.Background(), "12", "rotated", settings)
+	require.NoError(t, err)
+	require.False(t, settled)
+
+	_, stillRegistered := g.runtimes["12"]
+	require.False(t, stillRegistered, "no-settle rotation must retire the runtime")
+}
+
+// TestRetireRotatedDevshardRetiresAfterSettlement covers the settle terminal
+// path: the runtime stays alive through settlement (which reads its session)
+// and is retired only once settlement succeeds.
+func TestRetireRotatedDevshardRetiresAfterSettlement(t *testing.T) {
+	g, _ := newRetireTestGateway("12")
+	settings := GatewaySettings{EscrowRotation: EscrowRotationSettings{SettlementEnabled: true}}
+
+	oldSettle := gatewaySettleDevshardOnChain
+	gatewaySettleDevshardOnChain = func(g *Gateway, _ context.Context, id string, _ adminSettleEscrowRequest) (*SettleDevshardEscrowResult, error) {
+		// The session must still be reachable at settlement time.
+		_, ok := g.runtimes[id]
+		require.True(t, ok, "runtime must still be registered during settlement")
+		return &SettleDevshardEscrowResult{TxHash: "OK"}, nil
+	}
+	t.Cleanup(func() { gatewaySettleDevshardOnChain = oldSettle })
+
+	settled, err := g.retireRotatedDevshard(context.Background(), "12", "rotated", settings)
+	require.NoError(t, err)
+	require.True(t, settled)
+
+	_, stillRegistered := g.runtimes["12"]
+	require.False(t, stillRegistered, "settled rotation must retire the runtime")
+}
diff --git a/devshard/cmd/devshardctl/gateway_store.go b/devshard/cmd/devshardctl/gateway_store.go
index f6e3c8d5b0..d966d06167 100644
--- a/devshard/cmd/devshardctl/gateway_store.go
+++ b/devshard/cmd/devshardctl/gateway_store.go
@@ -95,7 +95,7 @@ type EscrowRotationModelSettings struct {
 	TempCount     int    `json:"temp_count"`
 	TargetCount   int    `json:"target_count"`
 	Amount        uint64 `json:"amount"`
-	PrivateKeyEnv string `json:"private_key_env"`
+	PrivateKeyEnv string `json:"private_key_env"` // trimmed by WithTuningDefaults on settings load
 }
 
 const (
@@ -285,16 +285,24 @@ func normalizeGatewayModelAccess(access []GatewayModelAccessSettings) []GatewayM
 
 type GatewayDevshardState struct {
 	RuntimeConfig
-	Active        bool   `json:"active"`
-	RotationRole  string `json:"rotation_role,omitempty"`
-	RotationEpoch uint64 `json:"rotation_epoch,omitempty"`
-	CreatedAt     string `json:"created_at,omitempty"`
-	UpdatedAt     string `json:"updated_at,omitempty"`
+	Active            bool   `json:"active"`
+	SettlementPending bool   `json:"settlement_pending,omitempty"`
+	RotationRole      string `json:"rotation_role,omitempty"`
+	RotationEpoch     uint64 `json:"rotation_epoch,omitempty"`
+	CreatedAt         string `json:"created_at,omitempty"`
+	UpdatedAt         string `json:"updated_at,omitempty"`
+}
+
+type GatewaySuspiciousHost struct {
+	ParticipantKey string `json:"participant_key"`
+	Note           string `json:"note,omitempty"`
+	CreatedAt      string `json:"created_at,omitempty"`
 }
 
 type GatewayState struct {
-	Settings  GatewaySettings        `json:"settings"`
-	Devshards []GatewayDevshardState `json:"devshards"`
+	Settings        GatewaySettings         `json:"settings"`
+	Devshards       []GatewayDevshardState  `json:"devshards"`
+	SuspiciousHosts []GatewaySuspiciousHost `json:"suspicious_hosts,omitempty"`
 }
 
 type GatewayStore struct {
@@ -306,6 +314,19 @@ func NewGatewayStore(path string) (*GatewayStore, error) {
 	if err != nil {
 		return nil, fmt.Errorf("open gateway store: %w", err)
 	}
+	// Serialize access and wait on contention instead of failing with "database is
+	// locked". Mirrors storage/sqlite.go.
+	db.SetMaxOpenConns(1)
+	for _, pragma := range []string{
+		"PRAGMA journal_mode=WAL",
+		"PRAGMA synchronous=NORMAL",
+		"PRAGMA busy_timeout=5000",
+	} {
+		if _, err := db.Exec(pragma); err != nil {
+			db.Close()
+			return nil, fmt.Errorf("apply gateway store pragma %q: %w", pragma, err)
+		}
+	}
 	stmts := []string{
 		`CREATE TABLE IF NOT EXISTS gateway_settings (
 			id INTEGER PRIMARY KEY CHECK (id = 1),
@@ -368,6 +389,7 @@ func NewGatewayStore(path string) (*GatewayStore, error) {
 			active INTEGER NOT NULL DEFAULT 1,
 			rotation_role TEXT NOT NULL DEFAULT '',
 			rotation_epoch INTEGER NOT NULL DEFAULT 0,
+			settlement_pending INTEGER NOT NULL DEFAULT 0,
 			created_at TEXT NOT NULL,
 			updated_at TEXT NOT NULL
 		)`,
@@ -430,6 +452,10 @@ func NewGatewayStore(path string) (*GatewayStore, error) {
 		db.Close()
 		return nil, fmt.Errorf("migrate gateway devshard epoch: %w", err)
 	}
+	if err := ensureGatewayDevshardsColumn(db, "settlement_pending", "INTEGER NOT NULL DEFAULT 0"); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("migrate gateway devshard settlement_pending: %w", err)
+	}
 	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS participant_throttle_state (
 		participant_key TEXT PRIMARY KEY,
 		tokens REAL NOT NULL DEFAULT 0,
@@ -459,6 +485,31 @@ func NewGatewayStore(path string) (*GatewayStore, error) {
 		db.Close()
 		return nil, fmt.Errorf("init gateway rotation status table: %w", err)
 	}
+	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS gateway_suspicious_hosts (
+		participant_key TEXT PRIMARY KEY,
+		note TEXT NOT NULL DEFAULT '',
+		created_at TEXT NOT NULL
+	)`); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("init gateway suspicious hosts table: %w", err)
+	}
+	// Write-ahead intent for an escrow create (written before the on-chain tx).
+	if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS escrow_rotation_commitments (
+		tx_hash TEXT PRIMARY KEY,
+		model TEXT NOT NULL,
+		role TEXT NOT NULL DEFAULT '',
+		epoch INTEGER NOT NULL DEFAULT 0,
+		private_key_env TEXT NOT NULL DEFAULT '',
+		block_height INTEGER NOT NULL DEFAULT 0,
+		created_at TEXT NOT NULL
+	)`); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("init escrow rotation commitments table: %w", err)
+	}
+	if err := ensureColumn(db, "escrow_rotation_commitments", "protocol_version", "TEXT NOT NULL DEFAULT ''"); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("migrate escrow rotation commitments protocol version: %w", err)
+	}
 	if err := ensureColumn(db, "participant_throttle_state", "quarantine_until_utc", "TEXT NOT NULL DEFAULT ''"); err != nil {
 		db.Close()
 		return nil, fmt.Errorf("migrate participant throttle: %w", err)
@@ -471,6 +522,22 @@ func NewGatewayStore(path string) (*GatewayStore, error) {
 		db.Close()
 		return nil, fmt.Errorf("migrate participant throttle eof streak: %w", err)
 	}
+	if err := ensureColumn(db, "participant_throttle_state", "model_ids", "TEXT NOT NULL DEFAULT ''"); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("migrate participant throttle models: %w", err)
+	}
+	if err := ensureColumn(db, "participant_throttle_state", "failure_strikes", "INTEGER NOT NULL DEFAULT 0"); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("migrate participant throttle strikes: %w", err)
+	}
+	if _, err := db.Exec(`
+		UPDATE participant_throttle_state
+		SET failure_strikes = MAX(IFNULL(empty_stream_streak, 0), IFNULL(eof_transport_failure_streak, 0))
+		WHERE IFNULL(failure_strikes, 0) = 0
+		  AND (IFNULL(empty_stream_streak, 0) > 0 OR IFNULL(eof_transport_failure_streak, 0) > 0)`); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("migrate participant throttle strike values: %w", err)
+	}
 
 	return &GatewayStore{db: db}, nil
 }
@@ -595,7 +662,7 @@ func (s *GatewayStore) LoadState() (GatewayState, bool, error) {
 
 	rows, err := s.db.Query(`
 		SELECT id, private_key_hex, private_key_env, model, storage_path, active, created_at, updated_at, protocol_version,
-		       rotation_role, rotation_epoch
+		       rotation_role, rotation_epoch, settlement_pending
 		FROM gateway_devshards
 		ORDER BY id`)
 	if err != nil {
@@ -605,6 +672,7 @@ func (s *GatewayStore) LoadState() (GatewayState, bool, error) {
 	for rows.Next() {
 		var devshard GatewayDevshardState
 		var active int
+		var settlementPending int
 		if err := rows.Scan(
 			&devshard.ID,
 			&devshard.PrivateKeyHex,
@@ -617,15 +685,22 @@ func (s *GatewayStore) LoadState() (GatewayState, bool, error) {
 			&devshard.ProtocolVersion,
 			&devshard.RotationRole,
 			&devshard.RotationEpoch,
+			&settlementPending,
 		); err != nil {
 			return GatewayState{}, false, fmt.Errorf("scan gateway devshard: %w", err)
 		}
 		devshard.Active = active != 0
+		devshard.SettlementPending = settlementPending != 0
 		state.Devshards = append(state.Devshards, devshard)
 	}
 	if err := rows.Err(); err != nil {
 		return GatewayState{}, false, fmt.Errorf("iterate gateway devshards: %w", err)
 	}
+	suspiciousHosts, err := s.LoadSuspiciousHosts()
+	if err != nil {
+		return GatewayState{}, false, err
+	}
+	state.SuspiciousHosts = suspiciousHosts
 	return state, true, nil
 }
 
@@ -948,6 +1023,180 @@ func (s *GatewayStore) LoadRotationStatuses(limit int) ([]GatewayRotationStatus,
 	return statuses, nil
 }
 
+// GatewayEscrowCommitment is the write-ahead intent for one escrow create, keyed by tx hash.
+type GatewayEscrowCommitment struct {
+	TxHash          string
+	Model           string
+	Role            string
+	Epoch           uint64
+	PrivateKeyEnv   string
+	ProtocolVersion string
+	BlockHeight     uint64
+	CreatedAt       time.Time
+}
+
+// SaveCommitment records a create intent, keyed by tx hash.
+func (s *GatewayStore) SaveCommitment(c GatewayEscrowCommitment) error {
+	if s == nil || s.db == nil {
+		return fmt.Errorf("gateway store unavailable")
+	}
+	createdAt := c.CreatedAt
+	if createdAt.IsZero() {
+		createdAt = time.Now().UTC()
+	} else {
+		createdAt = createdAt.UTC()
+	}
+	_, err := s.db.Exec(`
+		INSERT OR REPLACE INTO escrow_rotation_commitments (
+			tx_hash, model, role, epoch, private_key_env, protocol_version, block_height, created_at
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+		strings.TrimSpace(c.TxHash),
+		strings.TrimSpace(c.Model),
+		strings.TrimSpace(c.Role),
+		c.Epoch,
+		c.PrivateKeyEnv,
+		strings.TrimSpace(c.ProtocolVersion),
+		c.BlockHeight,
+		createdAt,
+	)
+	if err != nil {
+		return fmt.Errorf("save escrow commitment tx=%s: %w", c.TxHash, err)
+	}
+	return nil
+}
+
+func scanGatewayDBTime(raw string) time.Time {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return time.Time{}
+	}
+	if t, err := time.Parse(time.RFC3339Nano, raw); err == nil {
+		return t.UTC()
+	}
+	if t, err := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", raw); err == nil {
+		return t.UTC()
+	}
+	return time.Time{}
+}
+
+// LoadCommitments returns all pending commitments (oldest first).
+func (s *GatewayStore) LoadCommitments() ([]GatewayEscrowCommitment, error) {
+	if s == nil || s.db == nil {
+		return nil, nil
+	}
+	rows, err := s.db.Query(`
+		SELECT tx_hash, model, role, epoch, private_key_env, protocol_version, block_height, created_at
+		FROM escrow_rotation_commitments
+		ORDER BY created_at ASC`)
+	if err != nil {
+		return nil, fmt.Errorf("load escrow commitments: %w", err)
+	}
+	defer rows.Close()
+	var commitments []GatewayEscrowCommitment
+	for rows.Next() {
+		var c GatewayEscrowCommitment
+		var createdAt string
+		if err := rows.Scan(&c.TxHash, &c.Model, &c.Role, &c.Epoch, &c.PrivateKeyEnv, &c.ProtocolVersion, &c.BlockHeight, &createdAt); err != nil {
+			return nil, fmt.Errorf("scan escrow commitment: %w", err)
+		}
+		c.CreatedAt = scanGatewayDBTime(createdAt)
+		commitments = append(commitments, c)
+	}
+	return commitments, rows.Err()
+}
+
+// DeleteCommitment clears a commitment once its escrow is persisted (or proven absent).
+func (s *GatewayStore) DeleteCommitment(txHash string) error {
+	if s == nil || s.db == nil {
+		return fmt.Errorf("gateway store unavailable")
+	}
+	if _, err := s.db.Exec(`DELETE FROM escrow_rotation_commitments WHERE tx_hash = ?`, strings.TrimSpace(txHash)); err != nil {
+		return fmt.Errorf("delete escrow commitment tx=%s: %w", txHash, err)
+	}
+	return nil
+}
+
+func (s *GatewayStore) LoadSuspiciousHosts() ([]GatewaySuspiciousHost, error) {
+	if s == nil || s.db == nil {
+		return nil, nil
+	}
+	rows, err := s.db.Query(`
+		SELECT participant_key, note, created_at
+		FROM gateway_suspicious_hosts
+		ORDER BY participant_key`)
+	if err != nil {
+		return nil, fmt.Errorf("load gateway suspicious hosts: %w", err)
+	}
+	defer rows.Close()
+
+	var hosts []GatewaySuspiciousHost
+	for rows.Next() {
+		var host GatewaySuspiciousHost
+		if err := rows.Scan(&host.ParticipantKey, &host.Note, &host.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan gateway suspicious host: %w", err)
+		}
+		hosts = append(hosts, host)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return hosts, nil
+}
+
+func (s *GatewayStore) UpsertSuspiciousHosts(participantKeys []string, note string) ([]GatewaySuspiciousHost, error) {
+	if s == nil || s.db == nil {
+		return nil, nil
+	}
+	participantKeys = normalizeParticipantKeys(participantKeys)
+	if len(participantKeys) == 0 {
+		return nil, fmt.Errorf("participant_keys must contain at least one key")
+	}
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil, fmt.Errorf("begin suspicious host upsert: %w", err)
+	}
+	defer tx.Rollback()
+	now := time.Now().UTC().Format(time.RFC3339Nano)
+	note = strings.TrimSpace(note)
+	for _, key := range participantKeys {
+		if _, err := tx.Exec(`
+			INSERT INTO gateway_suspicious_hosts (participant_key, note, created_at)
+			VALUES (?, ?, ?)
+			ON CONFLICT(participant_key) DO UPDATE SET note = excluded.note`,
+			key, note, now); err != nil {
+			return nil, fmt.Errorf("upsert suspicious host %s: %w", key, err)
+		}
+	}
+	if err := tx.Commit(); err != nil {
+		return nil, fmt.Errorf("commit suspicious host upsert: %w", err)
+	}
+	return s.LoadSuspiciousHosts()
+}
+
+func (s *GatewayStore) DeleteSuspiciousHosts(participantKeys []string) ([]GatewaySuspiciousHost, error) {
+	if s == nil || s.db == nil {
+		return nil, nil
+	}
+	participantKeys = normalizeParticipantKeys(participantKeys)
+	if len(participantKeys) == 0 {
+		return nil, fmt.Errorf("participant_keys must contain at least one key")
+	}
+	tx, err := s.db.Begin()
+	if err != nil {
+		return nil, fmt.Errorf("begin suspicious host delete: %w", err)
+	}
+	defer tx.Rollback()
+	for _, key := range participantKeys {
+		if _, err := tx.Exec(`DELETE FROM gateway_suspicious_hosts WHERE participant_key = ?`, key); err != nil {
+			return nil, fmt.Errorf("delete suspicious host %s: %w", key, err)
+		}
+	}
+	if err := tx.Commit(); err != nil {
+		return nil, fmt.Errorf("commit suspicious host delete: %w", err)
+	}
+	return s.LoadSuspiciousHosts()
+}
+
 func (s *GatewayStore) UpsertDevshard(devshard GatewayDevshardState) error {
 	now := time.Now().UTC().Format(time.RFC3339Nano)
 	tx, err := s.db.Begin()
@@ -964,11 +1213,16 @@ func (s *GatewayStore) UpsertDevshard(devshard GatewayDevshardState) error {
 func (s *GatewayStore) upsertDevshardTx(tx *sql.Tx, devshard GatewayDevshardState, now string) error {
 	createdAt := now
 	_ = tx.QueryRow(`SELECT created_at FROM gateway_devshards WHERE id = ?`, devshard.ID).Scan(&createdAt)
+	// Preserve the existing settlement_pending marker so an unrelated upsert
+	// never silently clears a queued settlement; a brand-new row falls back
+	// to the value carried on devshard.
+	settlementPending := gatewayBoolToInt(devshard.SettlementPending)
+	_ = tx.QueryRow(`SELECT settlement_pending FROM gateway_devshards WHERE id = ?`, devshard.ID).Scan(&settlementPending)
 	if _, err := tx.Exec(`
 		INSERT OR REPLACE INTO gateway_devshards (
 			id, private_key_hex, private_key_env, model, storage_path, active, created_at, updated_at, protocol_version,
-			rotation_role, rotation_epoch
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			rotation_role, rotation_epoch, settlement_pending
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 		strings.TrimSpace(devshard.ID),
 		strings.TrimSpace(devshard.PrivateKeyHex),
 		strings.TrimSpace(devshard.PrivateKeyEnv),
@@ -980,12 +1234,51 @@ func (s *GatewayStore) upsertDevshardTx(tx *sql.Tx, devshard GatewayDevshardStat
 		strings.TrimSpace(devshard.ProtocolVersion),
 		strings.TrimSpace(devshard.RotationRole),
 		devshard.RotationEpoch,
+		settlementPending,
 	); err != nil {
 		return fmt.Errorf("upsert gateway devshard %s: %w", devshard.ID, err)
 	}
 	return nil
 }
 
+// GetDevshard returns the registry record for a single devshard. The second
+// return value is false when no row exists for the id. It is used by lazy
+// hydration to look up the config of a non-resident devshard without loading
+// the entire registry.
+func (s *GatewayStore) GetDevshard(id string) (GatewayDevshardState, bool, error) {
+	id = strings.TrimSpace(id)
+	var devshard GatewayDevshardState
+	var active int
+	var settlementPending int
+	err := s.db.QueryRow(`
+		SELECT id, private_key_hex, private_key_env, model, storage_path, active, created_at, updated_at, protocol_version,
+		       rotation_role, rotation_epoch, settlement_pending
+		FROM gateway_devshards
+		WHERE id = ?`, id).Scan(
+		&devshard.ID,
+		&devshard.PrivateKeyHex,
+		&devshard.PrivateKeyEnv,
+		&devshard.Model,
+		&devshard.StoragePath,
+		&active,
+		&devshard.CreatedAt,
+		&devshard.UpdatedAt,
+		&devshard.ProtocolVersion,
+		&devshard.RotationRole,
+		&devshard.RotationEpoch,
+		&settlementPending,
+	)
+	if err == sql.ErrNoRows {
+		return GatewayDevshardState{}, false, nil
+	}
+	if err != nil {
+		return GatewayDevshardState{}, false, fmt.Errorf("get devshard %s: %w", id, err)
+	}
+	devshard.Active = active != 0
+	devshard.SettlementPending = settlementPending != 0
+	return devshard, true, nil
+}
+
 func (s *GatewayStore) SetDevshardActive(id string, active bool) error {
 	res, err := s.db.Exec(`
 		UPDATE gateway_devshards
@@ -1008,6 +1301,28 @@ func (s *GatewayStore) SetDevshardActive(id string, active bool) error {
 	return nil
 }
 
+func (s *GatewayStore) SetDevshardSettlementPending(id string, pending bool) error {
+	res, err := s.db.Exec(`
+		UPDATE gateway_devshards
+		SET settlement_pending = ?, updated_at = ?
+		WHERE id = ?`,
+		gatewayBoolToInt(pending),
+		time.Now().UTC().Format(time.RFC3339Nano),
+		strings.TrimSpace(id),
+	)
+	if err != nil {
+		return fmt.Errorf("update devshard %s settlement_pending=%t: %w", id, pending, err)
+	}
+	n, err := res.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("rows affected for devshard %s: %w", id, err)
+	}
+	if n == 0 {
+		return fmt.Errorf("devshard %s not found", id)
+	}
+	return nil
+}
+
 func (s *GatewayStore) DeleteDevshard(id string) error {
 	res, err := s.db.Exec(`DELETE FROM gateway_devshards WHERE id = ?`, strings.TrimSpace(id))
 	if err != nil {
@@ -1023,18 +1338,38 @@ func (s *GatewayStore) DeleteDevshard(id string) error {
 	return nil
 }
 
+func normalizeParticipantKeys(keys []string) []string {
+	if len(keys) == 0 {
+		return nil
+	}
+	normalized := make([]string, 0, len(keys))
+	seen := make(map[string]struct{}, len(keys))
+	for _, key := range keys {
+		key = strings.TrimSpace(key)
+		if key == "" {
+			continue
+		}
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		normalized = append(normalized, key)
+	}
+	return normalized
+}
+
 // ParticipantThrottleRow represents a persisted reactive throttle state for one host.
 type ParticipantThrottleRow struct {
-	Key                       string
-	Tokens                    float64
-	LastRefillAt              time.Time
-	Status                    int
-	QuarantineUntil           time.Time // wall-clock end of unified quarantine; zero if unset
-	EmptyStreamStreak         int
-	EOFTransportFailureStreak int
+	Key             string
+	ModelIDs        []string
+	Tokens          float64
+	LastRefillAt    time.Time
+	Status          int
+	QuarantineUntil time.Time // wall-clock end of unified quarantine; zero if unset
+	FailureStrikes  int
 }
 
-func (s *GatewayStore) SaveParticipantThrottle(key string, tokens float64, lastRefillAt time.Time, status int, quarantineUntil time.Time, emptyStreamStreak int, eofTransportFailureStreak int) error {
+func (s *GatewayStore) SaveParticipantThrottle(key string, modelIDs []string, tokens float64, lastRefillAt time.Time, status int, quarantineUntil time.Time, failureStrikes int) error {
 	if s == nil || s.db == nil {
 		return nil
 	}
@@ -1044,9 +1379,9 @@ func (s *GatewayStore) SaveParticipantThrottle(key string, tokens float64, lastR
 	}
 	_, err := s.db.Exec(`
 		INSERT OR REPLACE INTO participant_throttle_state
-			(participant_key, tokens, last_refill_at, last_throttle_status, quarantine_until_utc, empty_stream_streak, eof_transport_failure_streak)
+			(participant_key, tokens, last_refill_at, last_throttle_status, quarantine_until_utc, failure_strikes, model_ids)
 		VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		key, tokens, lastRefillAt.UTC().Format(time.RFC3339Nano), status, quarStr, emptyStreamStreak, eofTransportFailureStreak)
+		key, tokens, lastRefillAt.UTC().Format(time.RFC3339Nano), status, quarStr, failureStrikes, strings.Join(normalizeModelIDs(modelIDs), ","))
 	if err != nil {
 		return fmt.Errorf("save participant throttle %s: %w", key, err)
 	}
@@ -1070,9 +1405,9 @@ func (s *GatewayStore) LoadParticipantThrottles() ([]ParticipantThrottleRow, err
 	}
 	rows, err := s.db.Query(`
 		SELECT participant_key, tokens, last_refill_at, last_throttle_status,
-		       IFNULL(empty_stream_streak, 0) AS empty_stream_streak,
-		       IFNULL(eof_transport_failure_streak, 0) AS eof_transport_failure_streak,
-		       IFNULL(quarantine_until_utc, '') AS quarantine_until_utc
+		       IFNULL(quarantine_until_utc, '') AS quarantine_until_utc,
+		       IFNULL(failure_strikes, 0) AS failure_strikes,
+		       IFNULL(model_ids, '') AS model_ids
 		FROM participant_throttle_state`)
 	if err != nil {
 		return nil, fmt.Errorf("load participant throttles: %w", err)
@@ -1082,10 +1417,11 @@ func (s *GatewayStore) LoadParticipantThrottles() ([]ParticipantThrottleRow, err
 	var result []ParticipantThrottleRow
 	for rows.Next() {
 		var row ParticipantThrottleRow
-		var lastRefillStr, quarantineStr string
-		if err := rows.Scan(&row.Key, &row.Tokens, &lastRefillStr, &row.Status, &row.EmptyStreamStreak, &row.EOFTransportFailureStreak, &quarantineStr); err != nil {
+		var lastRefillStr, quarantineStr, modelIDsStr string
+		if err := rows.Scan(&row.Key, &row.Tokens, &lastRefillStr, &row.Status, &quarantineStr, &row.FailureStrikes, &modelIDsStr); err != nil {
 			return nil, fmt.Errorf("scan participant throttle: %w", err)
 		}
+		row.ModelIDs = splitModelIDs(modelIDsStr)
 		row.LastRefillAt, err = time.Parse(time.RFC3339Nano, lastRefillStr)
 		if err != nil {
 			return nil, fmt.Errorf("parse last_refill_at for %s: %w", row.Key, err)
diff --git a/devshard/cmd/devshardctl/gateway_store_test.go b/devshard/cmd/devshardctl/gateway_store_test.go
index 60e5e31c54..efca871214 100644
--- a/devshard/cmd/devshardctl/gateway_store_test.go
+++ b/devshard/cmd/devshardctl/gateway_store_test.go
@@ -225,6 +225,39 @@ func TestGatewayStoreLoadsLegacyModelAccessIntoModelLimits(t *testing.T) {
 	}}, state.Settings.ModelLimits)
 }
 
+func TestGatewayStorePersistsSuspiciousHosts(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, store.Close())
+	})
+	require.NoError(t, store.Initialize(GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		MaxInputTokensInFlight:  200,
+	}, nil))
+
+	hosts, err := store.UpsertSuspiciousHosts([]string{" host-a ", "host-b", "host-a"}, "bad output")
+	require.NoError(t, err)
+	require.Len(t, hosts, 2)
+	require.Equal(t, "host-a", hosts[0].ParticipantKey)
+	require.Equal(t, "bad output", hosts[0].Note)
+	require.Equal(t, "host-b", hosts[1].ParticipantKey)
+
+	state, ok, err := store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+	require.Len(t, state.SuspiciousHosts, 2)
+
+	hosts, err = store.DeleteSuspiciousHosts([]string{"host-a"})
+	require.NoError(t, err)
+	require.Len(t, hosts, 1)
+	require.Equal(t, "host-b", hosts[0].ParticipantKey)
+}
+
 func TestValidateGatewaySettingsRequiresRotationModels(t *testing.T) {
 	settings := GatewaySettings{
 		ChainREST:               "http://node:1317",
@@ -270,6 +303,25 @@ func TestValidateGatewaySettingsRequiresRotationModels(t *testing.T) {
 	require.Contains(t, err.Error(), "duplicate model_id")
 }
 
+func TestGatewaySettingsWithTuningDefaultsTrimsPrivateKeyEnv(t *testing.T) {
+	settings := GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		EscrowRotation: EscrowRotationSettings{
+			Models: []EscrowRotationModelSettings{{
+				ModelID:       " Qwen/Test ",
+				PrivateKeyEnv: "  KIMI_KEY  ",
+			}},
+		},
+	}.WithTuningDefaults()
+
+	require.Equal(t, "Qwen/Test", settings.EscrowRotation.Models[0].ModelID)
+	require.Equal(t, "KIMI_KEY", settings.EscrowRotation.Models[0].PrivateKeyEnv)
+}
+
 func TestEscrowRotationPreparePromotesRegularEscrowsOnTempCreateFailure(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
@@ -324,9 +376,9 @@ func TestEscrowRotationPreparePromotesRegularEscrowsOnTempCreateFailure(t *testi
 		gatewaySettleDevshardOnChain = oldSettle
 	})
 
-	g := &Gateway{store: store, rotationFailures: make(map[string]struct{})}
-	g.prepareBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 10}, settings)
-	g.prepareBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 10}, settings)
+	g := &Gateway{store: store}
+	g.prepareBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 10}, settings)
+	g.prepareBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 10}, settings)
 
 	require.Equal(t, 1, createAttempts)
 	require.Equal(t, 0, settleAttempts)
@@ -340,6 +392,32 @@ func TestEscrowRotationPreparePromotesRegularEscrowsOnTempCreateFailure(t *testi
 	require.Equal(t, rotationRoleRegular, byID["13"].RotationRole)
 }
 
+// Rotation state must never stamp a hardcoded protocol constant (a guard
+// originally added when the gateway-v2 branches hardcoded ProtocolV2): the
+// protocol is derived from the gateway route prefix, and without a resolvable
+// route version the field stays empty (the pre-existing v1-default behavior).
+func TestNewRotationDevshardStateDerivesProtocolFromRoutePrefix(t *testing.T) {
+	record := newRotationDevshardState(&CreateDevshardEscrowResult{EscrowID: 99}, EscrowRotationModelSettings{
+		ModelID:       "Qwen/Test",
+		PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY",
+	}, rotationRoleTemp, 10)
+
+	require.Equal(t, "99", record.ID)
+	require.Equal(t, "Qwen/Test", record.Model)
+	require.Equal(t, "DEVSHARD_PRIVATE_KEY", record.PrivateKeyEnv)
+	require.Empty(t, record.ProtocolVersion, "no route prefix version -> no protocol stamp")
+	require.True(t, record.Active)
+	require.Equal(t, rotationRoleTemp, record.RotationRole)
+	require.EqualValues(t, 10, record.RotationEpoch)
+
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/devshard/v3")
+	record = newRotationDevshardState(&CreateDevshardEscrowResult{EscrowID: 100}, EscrowRotationModelSettings{
+		ModelID:       "Qwen/Test",
+		PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY",
+	}, rotationRoleTemp, 10)
+	require.Equal(t, "3", record.ProtocolVersion, "protocol derived from route prefix, not hardcoded")
+}
+
 func TestEscrowRotationFinishDoesNotSettleTempWhenRegularCreateFails(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
@@ -389,14 +467,144 @@ func TestEscrowRotationFinishDoesNotSettleTempWhenRegularCreateFails(t *testing.
 		gatewaySettleDevshardOnChain = oldSettle
 	})
 
-	g := &Gateway{store: store, rotationFailures: make(map[string]struct{})}
-	g.finishBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 11}, settings)
-	g.finishBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 11}, settings)
+	g := &Gateway{store: store}
+	g.finishBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 11}, settings)
+	g.finishBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 11}, settings)
 
 	require.Equal(t, 1, createAttempts)
 	require.Equal(t, 0, settleAttempts)
 }
 
+func TestEscrowRotationSkipsCreateWhenModelAbsentFromNetwork(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, store.Close())
+	})
+
+	settings := GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		EscrowRotation: EscrowRotationSettings{
+			Enabled:           true,
+			SettlementEnabled: true,
+			Models: []EscrowRotationModelSettings{{
+				ModelID:       "Qwen/Removed",
+				TempCount:     1,
+				TargetCount:   16,
+				Amount:        1000,
+				PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY",
+			}},
+		},
+	}.WithTuningDefaults()
+	// A stale temp bridge escrow remains for a model the network no longer
+	// serves; finishing rotation must NOT broadcast a regular create (which
+	// the chain rejects with ErrEpochGroupDataNotFound and still burns the
+	// gas fee) but MUST still settle the stranded temp escrow to recover funds.
+	require.NoError(t, store.Initialize(settings, []GatewayDevshardState{{
+		RuntimeConfig: RuntimeConfig{ID: "12", PrivateKeyHex: "secret", Model: "Qwen/Removed"},
+		Active:        true,
+		RotationRole:  rotationRoleTemp,
+		RotationEpoch: 10,
+	}}))
+
+	oldCreate := gatewayCreateRotationEscrow
+	oldSettle := gatewaySettleDevshardOnChain
+	createAttempts := 0
+	var settled []string
+	gatewayCreateRotationEscrow = func(*Gateway, context.Context, GatewaySettings, EscrowRotationModelSettings, string, uint64) (*CreateDevshardEscrowResult, error) {
+		createAttempts++
+		return &CreateDevshardEscrowResult{EscrowID: uint64(90 + createAttempts), TxHash: "OK"}, nil
+	}
+	gatewaySettleDevshardOnChain = func(_ *Gateway, _ context.Context, id string, _ adminSettleEscrowRequest) (*SettleDevshardEscrowResult, error) {
+		settled = append(settled, id)
+		return nil, nil
+	}
+	t.Cleanup(func() {
+		gatewayCreateRotationEscrow = oldCreate
+		gatewaySettleDevshardOnChain = oldSettle
+	})
+
+	// The network serves a different model; "Qwen/Removed" is positively absent.
+	capacity := NewCapacityState()
+	capacity.SetHostWeightViews(
+		map[string]float64{"host": 1},
+		map[string]float64{"host": 1},
+		map[string]map[string]float64{"Qwen/Present": {"host": 1}},
+		map[string]map[string]float64{"Qwen/Present": {"host": 1}},
+	)
+
+	g := &Gateway{store: store, capacity: capacity, rotationBreakers: make(map[string]*rotationBreaker)}
+	g.finishBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 11}, settings)
+
+	require.Equal(t, 0, createAttempts, "must not create escrow for a model absent from the network")
+	require.Equal(t, []string{"12"}, settled, "stranded temp escrow must still be settled")
+}
+
+func TestEscrowRotationCreatesWhenModelPresentInNetwork(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, store.Close())
+	})
+
+	settings := GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		EscrowRotation: EscrowRotationSettings{
+			Enabled:           true,
+			SettlementEnabled: true,
+			Models: []EscrowRotationModelSettings{{
+				ModelID:       "Qwen/Test",
+				TempCount:     1,
+				TargetCount:   2,
+				Amount:        1000,
+				PrivateKeyEnv: "DEVSHARD_PRIVATE_KEY",
+			}},
+		},
+	}.WithTuningDefaults()
+	require.NoError(t, store.Initialize(settings, []GatewayDevshardState{{
+		RuntimeConfig: RuntimeConfig{ID: "12", PrivateKeyHex: "secret", Model: "Qwen/Test"},
+		Active:        true,
+		RotationRole:  rotationRoleTemp,
+		RotationEpoch: 10,
+	}}))
+
+	oldCreate := gatewayCreateRotationEscrow
+	oldSettle := gatewaySettleDevshardOnChain
+	createAttempts := 0
+	gatewayCreateRotationEscrow = func(*Gateway, context.Context, GatewaySettings, EscrowRotationModelSettings, string, uint64) (*CreateDevshardEscrowResult, error) {
+		createAttempts++
+		return &CreateDevshardEscrowResult{EscrowID: uint64(90 + createAttempts), TxHash: "OK"}, nil
+	}
+	gatewaySettleDevshardOnChain = func(*Gateway, context.Context, string, adminSettleEscrowRequest) (*SettleDevshardEscrowResult, error) {
+		return nil, nil
+	}
+	t.Cleanup(func() {
+		gatewayCreateRotationEscrow = oldCreate
+		gatewaySettleDevshardOnChain = oldSettle
+	})
+
+	capacity := NewCapacityState()
+	capacity.SetHostWeightViews(
+		map[string]float64{"host": 1},
+		map[string]float64{"host": 1},
+		map[string]map[string]float64{"Qwen/Test": {"host": 1}},
+		map[string]map[string]float64{"Qwen/Test": {"host": 1}},
+	)
+
+	g := &Gateway{store: store, capacity: capacity, rotationBreakers: make(map[string]*rotationBreaker)}
+	g.finishBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 11}, settings)
+
+	require.Equal(t, 2, createAttempts, "must create escrows for a model the network serves")
+}
+
 func TestEscrowRotationFinishSettlesTempFromCurrentLatestEpoch(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
@@ -446,8 +654,8 @@ func TestEscrowRotationFinishSettlesTempFromCurrentLatestEpoch(t *testing.T) {
 		gatewaySettleDevshardOnChain = oldSettle
 	})
 
-	g := &Gateway{store: store, rotationFailures: make(map[string]struct{})}
-	g.finishBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 10}, settings)
+	g := &Gateway{store: store}
+	g.finishBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 10}, settings)
 
 	require.Equal(t, 2, createAttempts)
 	require.Equal(t, []string{"12"}, settled)
@@ -511,8 +719,8 @@ func TestEscrowRotationPrepareDeactivatesRegularWithoutSettlementWhenSettlementD
 
 	rt := &devshardRuntime{id: "12"}
 	rt.active.Store(true)
-	g := &Gateway{store: store, runtimes: map[string]*devshardRuntime{"12": rt}, rotationFailures: make(map[string]struct{})}
-	g.prepareBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 10}, settings)
+	g := &Gateway{store: store, runtimes: map[string]*devshardRuntime{"12": rt}}
+	g.prepareBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 10}, settings)
 
 	require.Equal(t, 1, createAttempts)
 	require.Equal(t, 0, settleAttempts)
@@ -579,8 +787,8 @@ func TestEscrowRotationFinishDeactivatesTempWithoutSettlementWhenSettlementDisab
 
 	rt := &devshardRuntime{id: "12"}
 	rt.active.Store(true)
-	g := &Gateway{store: store, runtimes: map[string]*devshardRuntime{"12": rt}, rotationFailures: make(map[string]struct{})}
-	g.finishBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 10}, settings)
+	g := &Gateway{store: store, runtimes: map[string]*devshardRuntime{"12": rt}}
+	g.finishBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 10}, settings)
 
 	require.Equal(t, 1, createAttempts)
 	require.Equal(t, 0, settleAttempts)
@@ -657,8 +865,8 @@ func TestEscrowRotationPrepareRotatesModelsIndependently(t *testing.T) {
 		gatewaySettleDevshardOnChain = oldSettle
 	})
 
-	g := &Gateway{store: store, rotationFailures: make(map[string]struct{})}
-	g.prepareBridgeEscrows(ChainPhaseSnapshot{EpochIndex: 10}, settings)
+	g := &Gateway{store: store}
+	g.prepareBridgeEscrows(context.Background(),ChainPhaseSnapshot{EpochIndex: 10}, settings)
 
 	require.Equal(t, []string{"13"}, settled)
 	state, ok, err := store.LoadState()
@@ -720,10 +928,9 @@ func TestEscrowRotationUsesEpochSwitchHeightDuringPoC(t *testing.T) {
 	})
 
 	g := &Gateway{
-		store:            store,
-		settings:         settings,
-		phaseGate:        &ChainPhaseGate{},
-		rotationFailures: make(map[string]struct{}),
+		store:     store,
+		settings:  settings,
+		phaseGate: &ChainPhaseGate{},
 	}
 	g.phaseGate.storeSnapshot(ChainPhaseSnapshot{
 		BlockHeight:            350,
@@ -733,12 +940,55 @@ func TestEscrowRotationUsesEpochSwitchHeightDuringPoC(t *testing.T) {
 		epochSwitchBlockHeight: 600,
 	})
 
-	g.rotateEscrowsOnce()
+	g.rotateEscrowsOnce(context.Background())
 
 	require.Equal(t, 1, createAttempts)
 	require.Equal(t, 1, settleAttempts)
 }
 
+func TestGatewayStoreSetDevshardSettlementPending(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, store.Close()) })
+
+	require.NoError(t, store.Initialize(GatewaySettings{
+		ChainREST: "http://node:1317", DefaultModel: "m", DefaultRequestMaxTokens: 1000,
+	}.WithTuningDefaults(), []GatewayDevshardState{{
+		RuntimeConfig: RuntimeConfig{ID: "12", PrivateKeyHex: "secret", Model: "m"},
+		Active:        true,
+	}}))
+
+	// Default is not pending.
+	state, ok, err := store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+	require.False(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+
+	// Set pending → persisted and survives reload.
+	require.NoError(t, store.SetDevshardSettlementPending("12", true))
+	state, _, err = store.LoadState()
+	require.NoError(t, err)
+	require.True(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+
+	// An unrelated upsert must NOT wipe the pending marker.
+	require.NoError(t, store.UpsertDevshard(GatewayDevshardState{
+		RuntimeConfig: RuntimeConfig{ID: "12", PrivateKeyHex: "secret", Model: "m"},
+		Active:        false,
+	}))
+	state, _, err = store.LoadState()
+	require.NoError(t, err)
+	require.True(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+
+	// Clear pending.
+	require.NoError(t, store.SetDevshardSettlementPending("12", false))
+	state, _, err = store.LoadState()
+	require.NoError(t, err)
+	require.False(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+
+	// Unknown id errors.
+	require.Error(t, store.SetDevshardSettlementPending("nope", true))
+}
+
 func gatewayDevshardsByID(devshards []GatewayDevshardState) map[string]GatewayDevshardState {
 	byID := make(map[string]GatewayDevshardState, len(devshards))
 	for _, devshard := range devshards {
diff --git a/devshard/cmd/devshardctl/gateway_test.go b/devshard/cmd/devshardctl/gateway_test.go
index dca9d6585d..22804cca23 100644
--- a/devshard/cmd/devshardctl/gateway_test.go
+++ b/devshard/cmd/devshardctl/gateway_test.go
@@ -82,6 +82,17 @@ func gatewayTestRuntimeForLimits(t *testing.T, id string, balance, nonce uint64)
 	}
 }
 
+func seedGatewayTestCapacity(g *Gateway, weights map[string]float64) {
+	if g == nil || g.capacity == nil {
+		return
+	}
+	seeded := make(map[string]float64, len(weights))
+	for host := range weights {
+		seeded[host] = 10_000
+	}
+	g.capacity.SetHostWeightViews(seeded, seeded, nil, nil)
+}
+
 func gatewayTestDepletionGateway(t *testing.T, rt *devshardRuntime, modifySettings ...func(*GatewaySettings)) (*Gateway, *atomic.Int32, *atomic.Int32) {
 	t.Helper()
 
@@ -227,6 +238,93 @@ func TestGatewayCheckBalancesKeepsRuntimeBelowLimits(t *testing.T) {
 	require.True(t, rt.active.Load())
 }
 
+func TestEnqueueSettlementWaitsForActiveRequests(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold-1, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	// One request in flight → settlement must NOT fire yet, but escrow is
+	// deactivated and marked pending (in-memory + persisted).
+	g.reserveRuntime(rt, 1)
+	g.deactivateAndSettleDevshardByID("12", "low_balance")
+
+	require.False(t, rt.active.Load())
+	require.True(t, rt.settlementPending.Load())
+	state, ok, err := g.store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+	require.True(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+	require.EqualValues(t, 0, settled.Load())
+
+	// Draining the last request triggers exactly one settlement, which
+	// clears the marker.
+	g.releaseRuntime(rt, 1)
+	require.Eventually(t, func() bool {
+		return settled.Load() == 1 && !rt.settlementPending.Load()
+	}, time.Second, 10*time.Millisecond)
+
+	state, _, err = g.store.LoadState()
+	require.NoError(t, err)
+	require.False(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+}
+
+func TestEnqueueSettlementSettlesImmediatelyWhenDrained(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold-1, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	// No active requests → settle right away.
+	g.deactivateAndSettleDevshardByID("12", "low_balance")
+
+	require.Eventually(t, func() bool {
+		return settled.Load() == 1 && !rt.active.Load()
+	}, time.Second, 10*time.Millisecond)
+}
+
+func TestReconcilePendingSettlementsSettlesDrainedEscrow(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	// Simulate a marker left behind by a pre-restart drain.
+	rt.active.Store(false)
+	require.NoError(t, g.store.SetDevshardActive("12", false))
+	require.NoError(t, g.store.SetDevshardSettlementPending("12", true))
+
+	g.reconcilePendingSettlements()
+
+	require.Eventually(t, func() bool {
+		return settled.Load() == 1 && !rt.settlementPending.Load()
+	}, time.Second, 10*time.Millisecond)
+}
+
+func TestReconcilePendingSettlementsSkipsActiveOrUnflagged(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt)
+
+	// Active escrow, no pending marker → nothing to do.
+	g.reconcilePendingSettlements()
+	require.Never(t, func() bool { return settled.Load() > 0 }, 200*time.Millisecond, 20*time.Millisecond)
+}
+
+func TestReconcilePendingSettlementsSkipsWhenSettlementDisabled(t *testing.T) {
+	rt := gatewayTestRuntimeForLimits(t, "12", balanceMinimumThreshold, nonceDeactivationLimit-1)
+	g, _, settled := gatewayTestDepletionGateway(t, rt, func(settings *GatewaySettings) {
+		settings.EscrowRotation.SettlementEnabled = false
+	})
+
+	// Inactive escrow flagged pending, but settlement is disabled → reconcile
+	// must not settle, and the marker is preserved for a later re-enable.
+	rt.active.Store(false)
+	require.NoError(t, g.store.SetDevshardActive("12", false))
+	require.NoError(t, g.store.SetDevshardSettlementPending("12", true))
+
+	g.reconcilePendingSettlements()
+
+	require.Never(t, func() bool { return settled.Load() > 0 }, 200*time.Millisecond, 20*time.Millisecond)
+	state, ok, err := g.store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+	require.True(t, gatewayDevshardsByID(state.Devshards)["12"].SettlementPending)
+}
+
 func TestParseDevshardPath(t *testing.T) {
 	id, inner, ok := parseDevshardPath("/devshard/12/v1/debug/perf")
 	require.True(t, ok)
@@ -238,19 +336,19 @@ func TestParseDevshardPath(t *testing.T) {
 }
 
 func TestGatewayChooseRuntimeUsesLowestLoad(t *testing.T) {
-	// Load score is activeRequests / W(e). Both runtimes share W(e)=1
+	// Load score is activeUserRequests / W(e). Both runtimes share W(e)=1
 	// (no capacity model wired). The picker should prefer the runtime
 	// with fewer in-flight requests.
 	a := &devshardRuntime{id: "6", model: "m"}
 	b := &devshardRuntime{id: "12", model: "m"}
-	a.activeRequests.Store(5)
-	b.activeRequests.Store(1)
+	a.activeUserRequests.Store(5)
+	b.activeUserRequests.Store(1)
 
 	g := NewGateway([]*devshardRuntime{a, b}, NewGatewayLimiter(0, 0), "m")
 	chosen, err := g.reserveRuntimeForModel("m", 5)
 	require.NoError(t, err)
 	require.Equal(t, "12", chosen.id)
-	require.EqualValues(t, 2, chosen.activeRequests.Load())
+	require.EqualValues(t, 2, chosen.activeUserRequests.Load())
 	require.EqualValues(t, 5, chosen.reservedTokens.Load())
 }
 
@@ -333,7 +431,7 @@ func TestGatewayModelAccessAdminOnlyDeniesPooledAndDirectChat(t *testing.T) {
 	}.WithTuningDefaults()
 	g.capacity.SetEscrowMembership("12", map[string]int{"host-k": 1})
 	g.capacity.SetHostWeightsByModel(map[string]map[string]float64{
-		"Kimi/Test": {"host-k": 50},
+		"Kimi/Test": {"host-k": 10_000},
 	}, false)
 
 	req := httptest.NewRequest(http.MethodPost, "/v1/chat/completions",
@@ -364,8 +462,8 @@ func TestGatewayModelAccessAdminOnlyDeniesPooledAndDirectChat(t *testing.T) {
 		Capacity gatewayCapacityStatus `json:"capacity"`
 	}
 	require.NoError(t, json.Unmarshal(statusRec.Body.Bytes(), &body))
-	require.InDelta(t, 50.0, body.Capacity.Models["Kimi/Test"].CurrentWeight, 1e-9)
-	require.InDelta(t, 50.0, body.Capacity.Models["Kimi/Test"].FullWeight, 1e-9)
+	require.InDelta(t, 10_000.0, body.Capacity.Models["Kimi/Test"].CurrentWeight, 1e-9)
+	require.InDelta(t, 10_000.0, body.Capacity.Models["Kimi/Test"].FullWeight, 1e-9)
 	require.InDelta(t, 1.0, body.Capacity.Models["Kimi/Test"].ScaleFactor, 1e-9)
 	require.True(t, body.Capacity.Models["Kimi/Test"].AccessEnabled)
 	require.Equal(t, "admin_only", body.Capacity.Models["Kimi/Test"].AccessMode)
@@ -387,6 +485,7 @@ func TestGatewayModelAccessAdminOnlyAllowsAdminAuthenticatedInference(t *testing
 		}),
 	}
 	g := NewGateway([]*devshardRuntime{rt}, NewGatewayLimiter(10, 1000), "Kimi/Test")
+	seedGatewayTestCapacity(g, map[string]float64{"host-k": 1})
 	g.settings = GatewaySettings{
 		DefaultModel: "Kimi/Test",
 		ModelLimits: []GatewayModelLimitSettings{{
@@ -397,7 +496,7 @@ func TestGatewayModelAccessAdminOnlyAllowsAdminAuthenticatedInference(t *testing
 	}.WithTuningDefaults()
 	g.capacity.SetEscrowMembership("12", map[string]int{"host-k": 1})
 	g.capacity.SetHostWeightsByModel(map[string]map[string]float64{
-		"Kimi/Test": {"host-k": 50},
+		"Kimi/Test": {"host-k": 10_000},
 	}, false)
 
 	handler := buildGatewayHandler(g, runtimeOptions{
@@ -443,6 +542,7 @@ func TestGatewayModelAccessAPIKeyAllowsClientAuthenticatedInference(t *testing.T
 		}),
 	}
 	g := NewGateway([]*devshardRuntime{rt}, NewGatewayLimiter(10, 1000), "Kimi/Test")
+	seedGatewayTestCapacity(g, map[string]float64{"host-k": 1})
 	g.settings = GatewaySettings{
 		DefaultModel: "Kimi/Test",
 		ModelLimits: []GatewayModelLimitSettings{{
@@ -510,6 +610,7 @@ func TestGatewayModelAccessDefaultsToAdminOnly(t *testing.T) {
 		participantSlotCounts: map[string]int{"host-q": 1},
 	}
 	g := NewGateway([]*devshardRuntime{rt, other}, NewGatewayLimiter(10, 1000), "Kimi/Test")
+	seedGatewayTestCapacity(g, map[string]float64{"host-k": 1, "host-q": 1})
 	handler := buildGatewayHandler(g, runtimeOptions{adminAPIKey: "admin-key"})
 
 	req := httptest.NewRequest(http.MethodPost, "/v1/chat/completions",
@@ -551,6 +652,7 @@ func TestGatewayModelAccessOpenAllowsUnauthenticatedInference(t *testing.T) {
 		}),
 	}
 	g := NewGateway([]*devshardRuntime{rt}, NewGatewayLimiter(10, 1000), "Kimi/Test")
+	seedGatewayTestCapacity(g, map[string]float64{"host-k": 1})
 	g.settings = GatewaySettings{
 		DefaultModel: "Kimi/Test",
 		ModelLimits: []GatewayModelLimitSettings{{
@@ -705,7 +807,7 @@ func TestAdminDeactivateDevshardAllowsActiveRequestsAndStopsNewChat(t *testing.T
 			w.WriteHeader(http.StatusNoContent)
 		}),
 	}
-	rt.activeRequests.Store(1)
+	rt.activeUserRequests.Store(1)
 	g := NewGateway([]*devshardRuntime{rt}, NewGatewayLimiter(0, 0), "Qwen/Test")
 	g.store = store
 
@@ -715,7 +817,7 @@ func TestAdminDeactivateDevshardAllowsActiveRequestsAndStopsNewChat(t *testing.T
 
 	require.Equal(t, http.StatusOK, rec.Code)
 	require.False(t, rt.active.Load())
-	require.EqualValues(t, 1, rt.activeRequests.Load())
+	require.EqualValues(t, 1, rt.activeUserRequests.Load())
 
 	state, ok, err := store.LoadState()
 	require.NoError(t, err)
@@ -878,6 +980,39 @@ func TestAdminAddDevshardWiresSharedPhaseGate(t *testing.T) {
 	require.Equal(t, "confirmation_poc", addedStatus.BlockReason)
 }
 
+func TestGatewayHostRoutePrefixDefaultsToBuildVersion(t *testing.T) {
+	previousVersion := Version
+	Version = "dev"
+	t.Cleanup(func() { Version = previousVersion })
+
+	require.Equal(t, "/devshard/dev", gatewayHostRoutePrefix(""))
+	require.Equal(t, "/devshard/v2", gatewayHostRoutePrefix("/devshard/v2"))
+	require.Equal(t, "/v1/devshard", gatewayHostRoutePrefix("/v1/devshard"))
+	require.NoError(t, validateGatewayHostRoutePrefix("/devshard/dev"))
+	require.NoError(t, validateGatewayHostRoutePrefix("/devshard/v2"))
+	require.Error(t, validateGatewayHostRoutePrefix("/v1/devshard"))
+}
+
+func TestResolveGatewayRoutePrefixDefaultsToBuildVersion(t *testing.T) {
+	oldVersion := Version
+	t.Cleanup(func() { Version = oldVersion })
+	Version = "v2"
+
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "")
+	got, err := resolveGatewayRoutePrefix()
+	require.NoError(t, err)
+	require.Equal(t, "/devshard/v2", got)
+
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", "/v1/devshard")
+	_, err = resolveGatewayRoutePrefix()
+	require.ErrorContains(t, err, "unsupported devshard route prefix")
+
+	t.Setenv("DEVSHARD_ROUTE_PREFIX", " /devshard/test ")
+	got, err = resolveGatewayRoutePrefix()
+	require.NoError(t, err)
+	require.Equal(t, "/devshard/test", got)
+}
+
 func TestAdminImportDevshardLoadsInactiveRuntimeAndAccounting(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
@@ -1016,7 +1151,7 @@ func TestGatewayHandleDevshardFinalizeRequiresNoActiveRequests(t *testing.T) {
 			w.WriteHeader(http.StatusNoContent)
 		}),
 	}
-	rt.activeRequests.Store(1)
+	rt.activeUserRequests.Store(1)
 	g := NewGateway([]*devshardRuntime{rt}, NewGatewayLimiter(0, 0), "Qwen/Test")
 	g.store = store
 
@@ -1028,7 +1163,7 @@ func TestGatewayHandleDevshardFinalizeRequiresNoActiveRequests(t *testing.T) {
 	require.False(t, forwarded)
 	require.True(t, rt.active.Load())
 
-	rt.activeRequests.Store(0)
+	rt.activeUserRequests.Store(0)
 	rec = httptest.NewRecorder()
 	g.handleDevshard(rec, req)
 
@@ -1043,6 +1178,45 @@ func TestGatewayHandleDevshardFinalizeRequiresNoActiveRequests(t *testing.T) {
 	require.False(t, state.Devshards[0].Active)
 }
 
+func TestAdminSuspiciousHostsEndpointPersistsAndUpdatesRuntime(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, store.Close())
+	})
+	require.NoError(t, store.Initialize(GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		MaxInputTokensInFlight:  200,
+	}, nil))
+	g := NewGateway(nil, NewGatewayLimiter(0, 0), "Qwen/Test")
+	g.store = store
+
+	req := httptest.NewRequest(http.MethodPost, "/v1/admin/suspicious-hosts",
+		strings.NewReader(`{"participant_keys":["host-a","host-b"],"note":"bad output"}`))
+	rec := httptest.NewRecorder()
+	g.handleAdminSuspiciousHosts(rec, req)
+	require.Equal(t, http.StatusOK, rec.Code)
+	require.True(t, g.isSuspiciousParticipant("host-a"))
+	require.True(t, g.isSuspiciousParticipant("host-b"))
+
+	state, ok, err := store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+	require.Len(t, state.SuspiciousHosts, 2)
+
+	req = httptest.NewRequest(http.MethodDelete, "/v1/admin/suspicious-hosts",
+		strings.NewReader(`{"participant_key":"host-a"}`))
+	rec = httptest.NewRecorder()
+	g.handleAdminSuspiciousHosts(rec, req)
+	require.Equal(t, http.StatusOK, rec.Code)
+	require.False(t, g.isSuspiciousParticipant("host-a"))
+	require.True(t, g.isSuspiciousParticipant("host-b"))
+}
+
 func TestGatewayHandlePooledChatSetsChosenDevshardHeader(t *testing.T) {
 	slow := &devshardRuntime{
 		id:    "6",
@@ -1061,8 +1235,8 @@ func TestGatewayHandlePooledChatSetsChosenDevshardHeader(t *testing.T) {
 			w.WriteHeader(http.StatusCreated)
 		}),
 	}
-	slow.activeRequests.Store(10)
-	fast.activeRequests.Store(0)
+	slow.activeUserRequests.Store(10)
+	fast.activeUserRequests.Store(0)
 
 	g := NewGateway([]*devshardRuntime{slow, fast}, NewGatewayLimiter(0, 0), "Qwen/Test")
 	g.settings.ModelLimits = []GatewayModelLimitSettings{{ModelID: "Qwen/Test", AccessMode: string(gatewayAccessModeOpen)}}
@@ -1191,7 +1365,7 @@ func TestGatewayPooledChatCachesStreamingResponseWithFreshRequestID(t *testing.T
 	require.EqualValues(t, 1, calls.Load())
 }
 
-func TestGatewayPooledChatCachesErrorResponseWithFreshRequestID(t *testing.T) {
+func TestGatewayPooledChatCachesOpenAIStyleBadRequestWithFreshRequestID(t *testing.T) {
 	var calls atomic.Int32
 	rt := &devshardRuntime{
 		id:    "12",
@@ -1202,8 +1376,8 @@ func TestGatewayPooledChatCachesErrorResponseWithFreshRequestID(t *testing.T) {
 				w.Header().Set("X-Request-Id", rid)
 			}
 			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusBadGateway)
-			_, _ = w.Write([]byte(`{"error":{"message":"upstream failed"}}`))
+			w.WriteHeader(http.StatusBadRequest)
+			_, _ = w.Write([]byte(`{"error":{"message":"bad response_format schema","type":"BadRequestError","code":400}}`))
 		}),
 	}
 	g := NewGateway([]*devshardRuntime{rt}, NewGatewayLimiter(0, 0), "Qwen/Test")
@@ -1214,7 +1388,7 @@ func TestGatewayPooledChatCachesErrorResponseWithFreshRequestID(t *testing.T) {
 	rec := httptest.NewRecorder()
 	g.handlePooledChat(rec, req)
 
-	require.Equal(t, http.StatusBadGateway, rec.Code)
+	require.Equal(t, http.StatusBadRequest, rec.Code)
 	firstBody := rec.Body.String()
 	firstRequestID := rec.Header().Get("X-Request-Id")
 	require.NotEmpty(t, firstRequestID)
@@ -1224,7 +1398,7 @@ func TestGatewayPooledChatCachesErrorResponseWithFreshRequestID(t *testing.T) {
 	rec = httptest.NewRecorder()
 	g.handlePooledChat(rec, req)
 
-	require.Equal(t, http.StatusBadGateway, rec.Code)
+	require.Equal(t, http.StatusBadRequest, rec.Code)
 	require.Equal(t, firstBody, rec.Body.String())
 	require.Equal(t, "12", rec.Header().Get("X-Devshard-ID"))
 	require.NotEmpty(t, rec.Header().Get("X-Request-Id"))
@@ -1311,7 +1485,7 @@ func TestGatewayHandlePooledChatRejectsUnsupportedModel(t *testing.T) {
 	require.Contains(t, rec.Body.String(), `unsupported model \"Nope/Unsupported\"`)
 	require.Contains(t, rec.Body.String(), "Qwen/Test")
 	require.False(t, forwarded)
-	require.EqualValues(t, 0, rt.activeRequests.Load())
+	require.EqualValues(t, 0, rt.activeUserRequests.Load())
 }
 
 func TestGatewayHandlePooledChatRejectsUnsupportedModelBeforeDefaultAdminOnly(t *testing.T) {
@@ -1336,7 +1510,7 @@ func TestGatewayHandlePooledChatRejectsUnsupportedModelBeforeDefaultAdminOnly(t
 	require.Contains(t, rec.Body.String(), `unsupported model \"Nope/Unsupported\"`)
 	require.NotContains(t, rec.Body.String(), "admin API key")
 	require.False(t, forwarded)
-	require.EqualValues(t, 0, rt.activeRequests.Load())
+	require.EqualValues(t, 0, rt.activeUserRequests.Load())
 }
 
 func TestGatewayHandleDevshardChatRejectsUnsupportedModel(t *testing.T) {
@@ -1361,7 +1535,7 @@ func TestGatewayHandleDevshardChatRejectsUnsupportedModel(t *testing.T) {
 	require.Contains(t, rec.Body.String(), `unsupported model \"Nope/Unsupported\"`)
 	require.Contains(t, rec.Body.String(), "Qwen/Test")
 	require.False(t, forwarded)
-	require.EqualValues(t, 0, rt.activeRequests.Load())
+	require.EqualValues(t, 0, rt.activeUserRequests.Load())
 }
 
 func TestGatewayPooledChatRefreshesCapacityScaleBeforeAcquire(t *testing.T) {
@@ -1473,7 +1647,7 @@ func TestGatewayStatusZerosModelCapacityWithoutRoutableDevshards(t *testing.T) {
 	kimi.active.Store(false)
 	g.capacity.SetHostWeightsByModel(map[string]map[string]float64{
 		"Qwen/Test": {"host-q": 100},
-		"Kimi/Test": {"host-k": 50},
+		"Kimi/Test": {"host-k": 10_000},
 	}, false)
 
 	req := httptest.NewRequest(http.MethodGet, "/v1/status", nil)
@@ -1496,7 +1670,7 @@ func TestGatewayStatusZerosModelCapacityWithoutRoutableDevshards(t *testing.T) {
 	require.Equal(t, 1, body.Capacity.Models["Qwen/Test"].RoutableDevshards)
 
 	require.InDelta(t, 0.0, body.Capacity.Models["Kimi/Test"].CurrentWeight, 1e-9)
-	require.InDelta(t, 50.0, body.Capacity.Models["Kimi/Test"].FullWeight, 1e-9)
+	require.InDelta(t, 10_000.0, body.Capacity.Models["Kimi/Test"].FullWeight, 1e-9)
 	require.InDelta(t, 0.0, body.Capacity.Models["Kimi/Test"].ScaleFactor, 1e-9)
 	require.InDelta(t, 100.0, body.Capacity.Models["Kimi/Test"].LostPercent, 1e-9)
 	require.EqualValues(t, 0, body.Limiter.Models["Kimi/Test"].CurrentCapacityCapRequests)
@@ -1518,6 +1692,12 @@ func TestGatewayWiresQuarantineIntoCapacityWithoutPhaseGate(t *testing.T) {
 		participantSlotCounts: map[string]int{"host-c": 1},
 	}
 	g := NewGateway([]*devshardRuntime{rt, other}, NewGatewayLimiter(4, 0), "Qwen/Test")
+	g.capacity.SetHostWeightViews(
+		map[string]float64{"host-a": 1, "host-b": 1, "host-c": 1},
+		map[string]float64{"host-a": 1, "host-b": 1, "host-c": 1},
+		nil,
+		nil,
+	)
 	g.participantLimiter = limiter
 	g.attachCapacityLiveAvailability()
 
@@ -1536,8 +1716,8 @@ func TestGatewayWiresQuarantineIntoCapacityWithoutPhaseGate(t *testing.T) {
 	require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &body))
 	require.Equal(t, 2, body.Capacity.AvailableHostCount)
 	require.Equal(t, 1, body.Capacity.UnavailableHostCount)
-	require.Equal(t, 0, body.Capacity.CurrentWeightMatched)
-	require.Equal(t, 3, body.Capacity.CurrentWeightFallback)
+	require.Equal(t, 3, body.Capacity.CurrentWeightMatched)
+	require.Equal(t, 0, body.Capacity.CurrentWeightFallback)
 	require.InDelta(t, 2.0, body.Capacity.TotalWeight, 1e-9)
 	require.InDelta(t, 3.0, body.Capacity.BaselineWeight, 1e-9)
 	require.InDelta(t, 33.333333, body.Capacity.LostPercent, 1e-6)
@@ -1651,6 +1831,7 @@ func TestGatewayChooseRuntimeSkipsParticipantLimitedDevshard(t *testing.T) {
 		participantSlotCounts: map[string]int{"fresh-host": 1},
 	}
 	g := NewGateway([]*devshardRuntime{limited, available}, NewGatewayLimiter(0, 0), "m")
+	seedGatewayTestCapacity(g, map[string]float64{"shared-host": 1, "fresh-host": 1})
 	g.participantLimiter = limiter
 	g.capacity.SetLiveAvailable(limiter.IsAvailable)
 
@@ -1677,6 +1858,7 @@ func TestGatewayChooseRuntimePrefersHealthyEscrowWithoutBenchingPartial(t *testi
 		participantSlotCounts: map[string]int{"fresh-a": 1, "fresh-b": 1},
 	}
 	g := NewGateway([]*devshardRuntime{mixed, healthy}, NewGatewayLimiter(0, 0), "m")
+	seedGatewayTestCapacity(g, map[string]float64{"dead-host": 1, "live-host": 1, "fresh-a": 1, "fresh-b": 1})
 	g.participantLimiter = limiter
 	g.capacity.SetLiveAvailable(limiter.IsAvailable)
 
@@ -1705,6 +1887,7 @@ func TestGatewayChooseRuntimeFailsWhenAllDevshardsParticipantLimited(t *testing.
 		participantSlotCounts: map[string]int{"shared-host": 1},
 	}
 	g := NewGateway([]*devshardRuntime{a, b}, NewGatewayLimiter(0, 0), "m")
+	seedGatewayTestCapacity(g, map[string]float64{"shared-host": 1})
 	g.participantLimiter = limiter
 	g.capacity.SetLiveAvailable(limiter.IsAvailable)
 
@@ -1732,6 +1915,7 @@ func TestGatewayChooseRuntimeReactsToRecoveryWithoutPhasePoll(t *testing.T) {
 		participantSlotCounts: map[string]int{"b-host": 1},
 	}
 	g := NewGateway([]*devshardRuntime{a, b}, NewGatewayLimiter(0, 0), "m")
+	seedGatewayTestCapacity(g, map[string]float64{"a-host": 1, "b-host": 1})
 	g.participantLimiter = limiter
 	g.capacity.SetLiveAvailable(limiter.IsAvailable)
 
@@ -1854,14 +2038,13 @@ func TestParticipantRequestLimiterEOFTransportFailureQuarantinesAfterThreeConsec
 	require.True(t, limiter.allow("eof-host", now.Add(transportFailureQuarantine+time.Second)))
 }
 
-func TestParticipantRequestLimiterSuccessfulInferenceResetsEOFTransportFailureStreak(t *testing.T) {
+func TestParticipantRequestLimiterSuccessfulInferenceDecrementsEOFTransportFailureStrike(t *testing.T) {
 	limiter := NewParticipantRequestLimiter(10, 10)
 
 	limiter.ObserveTransportFailure("eof-host", "/sessions/1/chat/completions", fmt.Errorf("read stream: EOF"))
 	limiter.ObserveTransportFailure("eof-host", "/sessions/1/chat/completions", fmt.Errorf("read stream: EOF"))
 	limiter.ObserveSuccessfulInference("eof-host")
 
-	limiter.ObserveTransportFailure("eof-host", "/sessions/1/chat/completions", fmt.Errorf("read stream: EOF"))
 	limiter.ObserveTransportFailure("eof-host", "/sessions/1/chat/completions", fmt.Errorf("read stream: EOF"))
 	require.False(t, limiter.IsBlocked("eof-host"))
 	limiter.ObserveTransportFailure("eof-host", "/sessions/1/chat/completions", fmt.Errorf("read stream: EOF"))
@@ -1896,15 +2079,20 @@ func TestParticipantRequestLimiterEmptyStreamQuarantineAfterThreeConsecutive(t *
 
 	limiter.ObserveEmptyStream("empty-host")
 	require.False(t, limiter.IsBlocked("empty-host"))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"))
 	require.NoError(t, limiter.AllowRequest("empty-host", "/sessions/12/chat/completions"))
 
 	limiter.ObserveEmptyStream("empty-host")
 	require.False(t, limiter.IsBlocked("empty-host"))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"))
 	require.NoError(t, limiter.AllowRequest("empty-host", "/sessions/12/chat/completions"))
 
 	limiter.ObserveEmptyStream("empty-host")
-	require.True(t, limiter.IsBlocked("empty-host"))
+	require.False(t, limiter.IsBlocked("empty-host"))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"))
+	require.NoError(t, limiter.AllowRequest("empty-host", "/sessions/12/chat/completions"))
 	require.True(t, limiter.allow("empty-host", now.Add(emptyStreamQuarantine+time.Second)))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"), "expired quarantine enters shadow probation")
 }
 
 func TestParticipantRequestLimiterUsesUpdatedThrottleSettings(t *testing.T) {
@@ -1925,13 +2113,15 @@ func TestParticipantRequestLimiterUsesUpdatedThrottleSettings(t *testing.T) {
 
 	limiter.ObserveEmptyStream("empty-host")
 	require.False(t, limiter.IsBlocked("empty-host"))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"))
 	limiter.ObserveEmptyStream("empty-host")
 	emptyStreamQuarantineAt := time.Now()
-	require.True(t, limiter.IsBlocked("empty-host"))
+	require.False(t, limiter.IsBlocked("empty-host"))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"))
 	require.True(t, limiter.allow("empty-host", emptyStreamQuarantineAt.Add(151*time.Millisecond)))
 }
 
-func TestParticipantRequestLimiterSuccessfulInferenceResetsEmptyStreamStreak(t *testing.T) {
+func TestParticipantRequestLimiterSuccessfulInferenceDecrementsFailureStrikes(t *testing.T) {
 	limiter := NewParticipantRequestLimiter(10, 10)
 
 	limiter.ObserveEmptyStream("empty-host")
@@ -1944,8 +2134,30 @@ func TestParticipantRequestLimiterSuccessfulInferenceResetsEmptyStreamStreak(t *
 	require.False(t, limiter.IsBlocked("empty-host"))
 	limiter.ObserveEmptyStream("empty-host")
 	require.False(t, limiter.IsBlocked("empty-host"))
-	limiter.ObserveEmptyStream("empty-host")
-	require.True(t, limiter.IsBlocked("empty-host"))
+	require.True(t, limiter.IsShadowQuarantined("empty-host"))
+}
+
+// Model-burn empties must neither increment nor reset the real empty streak.
+func TestParticipantRequestLimiterObserveModelBurnEmptyIsTelemetryOnly(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+
+	limiter.ObserveEmptyStream("host-A")                    // real empty: streak -> 1
+	limiter.ObserveModelBurnEmpty("host-A", kimiK26ModelID) // telemetry-only: must not touch the streak
+
+	// The burn must neither increment nor reset the empty-stream strike count:
+	// it stays at the single real empty observed above.
+	require.Equal(t, 1, limiter.participants["host-A"].failureStrikes,
+		"model-burn empty must be inert for the empty-stream streak")
+}
+
+// Catches a regression where anyone adds streak logic to ObserveModelBurnEmpty.
+func TestParticipantRequestLimiterObserveModelBurnEmptyNeverQuarantines(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+
+	for i := 0; i < 100; i++ {
+		limiter.ObserveModelBurnEmpty("host-A", kimiK26ModelID)
+	}
+	require.False(t, limiter.IsBlocked("host-A"))
 }
 
 func TestParticipantRequestLimiterStalledWinnerQuarantinesImmediately(t *testing.T) {
@@ -1956,10 +2168,35 @@ func TestParticipantRequestLimiterStalledWinnerQuarantinesImmediately(t *testing
 	limiter.ObserveEmptyStream("stall-host")
 	limiter.ObserveStalledWinner("stall-host")
 
-	require.True(t, limiter.IsBlocked("stall-host"))
+	require.False(t, limiter.IsBlocked("stall-host"))
+	require.True(t, limiter.IsShadowQuarantined("stall-host"))
 	require.True(t, limiter.allow("stall-host", now.Add(stalledWinnerQuarantine+time.Second)))
 }
 
+func TestRedundancyNoWinnerParticipantIncludesShadowQuarantineAndProbation(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+	for i := 0; i < emptyStreamQuarantineThreshold; i++ {
+		limiter.ObserveEmptyStream("shadow-host")
+	}
+	limiter.ObserveResult("probe-host", "/sessions/12/chat/completions", http.StatusServiceUnavailable)
+	limiter.ObserveResult("probation-host", "/sessions/12/chat/completions", http.StatusServiceUnavailable)
+	require.True(t, limiter.ClearQuarantine("probation-host"))
+
+	redundancy := &Redundancy{
+		participantLimiter: limiter,
+		suspiciousParticipant: func(participantKey string) bool {
+			return participantKey == "manual-host"
+		},
+	}
+
+	require.True(t, redundancy.isNoWinnerParticipant("manual-host"))
+	require.True(t, redundancy.isNoWinnerParticipant("shadow-host"))
+	require.True(t, redundancy.isNoWinnerParticipant("probation-host"))
+	require.False(t, redundancy.isNoWinnerParticipant("probe-host"))
+	require.True(t, limiter.IsBlocked("probe-host"))
+	require.False(t, limiter.IsBlocked("shadow-host"))
+}
+
 func TestParticipantRequestLimiterRecoversAfterThrottle(t *testing.T) {
 	limiter := NewParticipantRequestLimiter(1, 10)
 	limiter.ObserveResult("shared-host", "/sessions/12/chat/completions", http.StatusServiceUnavailable)
@@ -1970,6 +2207,38 @@ func TestParticipantRequestLimiterRecoversAfterThrottle(t *testing.T) {
 	require.True(t, limiter.allow("shared-host", after))
 }
 
+func TestParticipantRequestLimiterProbeQuarantineIsModelScoped(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+
+	limiter.ObserveResultForModel("shared-host", "Kimi/Test", "/sessions/12/chat/completions", http.StatusServiceUnavailable)
+
+	require.True(t, limiter.IsBlockedForModel("shared-host", "Kimi/Test"))
+	require.False(t, limiter.IsBlockedForModel("shared-host", "Qwen/Test"))
+	require.Error(t, limiter.AllowRequestForModel("shared-host", "Kimi/Test", "/sessions/12/chat/completions"))
+	require.NoError(t, limiter.AllowRequestForModel("shared-host", "Qwen/Test", "/sessions/12/chat/completions"))
+
+	snapshot := limiter.Snapshot([]string{"shared-host"})["shared-host"]
+	require.Equal(t, []string{"Kimi/Test"}, snapshot.ModelIDs)
+}
+
+func TestParticipantRequestLimiterShadowQuarantineIsModelScoped(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+	for i := 0; i < emptyStreamQuarantineThreshold; i++ {
+		limiter.ObserveEmptyStreamForModel("shared-host", "Kimi/Test")
+	}
+
+	require.True(t, limiter.IsShadowQuarantinedForModel("shared-host", "Kimi/Test"))
+	require.False(t, limiter.IsShadowQuarantinedForModel("shared-host", "Qwen/Test"))
+
+	redundancy := &Redundancy{
+		model:              "Kimi/Test",
+		participantLimiter: limiter,
+	}
+	require.True(t, redundancy.isNoWinnerParticipant("shared-host"))
+	redundancy.model = "Qwen/Test"
+	require.False(t, redundancy.isNoWinnerParticipant("shared-host"))
+}
+
 func TestParticipantRequestLimiterMarksParticipantExhaustedOn503(t *testing.T) {
 	limiter := NewParticipantRequestLimiter(2, 10)
 	limiter.ObserveResult("shared-host", "/sessions/12/chat/completions", http.StatusServiceUnavailable)
@@ -1991,7 +2260,7 @@ func TestParticipantRequestLimiterExpiresOnFullRecovery(t *testing.T) {
 	require.Equal(t, 1, limiter.TrackedCount())
 	require.True(t, limiter.IsRecentlyQuarantined("shared-host"))
 
-	for i := 0; i < participantProbationSuccessesAfterQuarantine-1; i++ {
+	for i := 0; i < participantStrikesAfterQuarantine-1; i++ {
 		limiter.ObserveSuccessfulInference("shared-host")
 		require.True(t, limiter.IsRecentlyQuarantined("shared-host"))
 	}
@@ -2016,7 +2285,7 @@ func TestParticipantRequestLimiterClearQuarantineStartsProbation(t *testing.T) {
 	require.True(t, snapshot.RequestAllowed)
 	require.True(t, snapshot.AvailableForCapacity)
 
-	for i := 0; i < participantProbationSuccessesAfterQuarantine-1; i++ {
+	for i := 0; i < participantStrikesAfterQuarantine-1; i++ {
 		limiter.ObserveSuccessfulInference("shared-host")
 		require.True(t, limiter.IsRecentlyQuarantined("shared-host"))
 	}
@@ -2040,10 +2309,31 @@ func TestParticipantRequestLimiterPersistsThrottleState(t *testing.T) {
 	require.Equal(t, "shared-host", rows[0].Key)
 	require.Equal(t, float64(0), rows[0].Tokens)
 	require.Equal(t, http.StatusServiceUnavailable, rows[0].Status)
-	require.Equal(t, 0, rows[0].EmptyStreamStreak)
+	require.Equal(t, participantFailureStrikeThreshold, rows[0].FailureStrikes)
+	require.Empty(t, rows[0].ModelIDs)
 }
 
-func TestParticipantRequestLimiterPersistsEmptyStreamStreak(t *testing.T) {
+func TestParticipantRequestLimiterPersistsModelScopedThrottleState(t *testing.T) {
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { store.Close() })
+
+	limiter := NewParticipantRequestLimiter(10, 10)
+	limiter.SetStore(store)
+	limiter.ObserveResultForModel("shared-host", "Kimi/Test", "/sessions/12/chat/completions", http.StatusServiceUnavailable)
+
+	rows, err := store.LoadParticipantThrottles()
+	require.NoError(t, err)
+	require.Len(t, rows, 1)
+	require.Equal(t, []string{"Kimi/Test"}, rows[0].ModelIDs)
+
+	reloaded := NewParticipantRequestLimiter(10, 10)
+	reloaded.LoadStateWithQuarantine(rows[0].Key, rows[0].ModelIDs, rows[0].Tokens, rows[0].LastRefillAt, rows[0].Status, rows[0].QuarantineUntil, rows[0].FailureStrikes)
+	require.True(t, reloaded.IsBlockedForModel("shared-host", "Kimi/Test"))
+	require.False(t, reloaded.IsBlockedForModel("shared-host", "Qwen/Test"))
+}
+
+func TestParticipantRequestLimiterPersistsFailureStrikes(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
 	t.Cleanup(func() { store.Close() })
@@ -2057,7 +2347,7 @@ func TestParticipantRequestLimiterPersistsEmptyStreamStreak(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, rows, 1)
 	require.Equal(t, "shared-host", rows[0].Key)
-	require.Equal(t, 2, rows[0].EmptyStreamStreak)
+	require.Equal(t, 2, rows[0].FailureStrikes)
 }
 
 func TestParticipantRequestLimiterLoadStateRecoversTokens(t *testing.T) {
@@ -2074,7 +2364,7 @@ func TestParticipantRequestLimiterLoadStateDeletesFullyRecovered(t *testing.T) {
 	require.NoError(t, err)
 	t.Cleanup(func() { store.Close() })
 
-	require.NoError(t, store.SaveParticipantThrottle("shared-host", 0, time.Now().Add(-time.Hour), 503, time.Time{}, 0, 0))
+	require.NoError(t, store.SaveParticipantThrottle("shared-host", nil, 0, time.Now().Add(-time.Hour), 503, time.Time{}, 0))
 
 	limiter := NewParticipantRequestLimiter(10, 10)
 	limiter.SetStore(store)
@@ -2087,7 +2377,7 @@ func TestParticipantRequestLimiterLoadStateDeletesFullyRecovered(t *testing.T) {
 	require.Len(t, rows, 0)
 }
 
-func TestParticipantRequestLimiterDeletesOnExpiry(t *testing.T) {
+func TestParticipantRequestLimiterPersistsProbationOnExpiry(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
 	t.Cleanup(func() { store.Close() })
@@ -2103,6 +2393,14 @@ func TestParticipantRequestLimiterDeletesOnExpiry(t *testing.T) {
 	now := time.Now().Add(httpThrottleQuarantine + 2*time.Second)
 	require.True(t, limiter.allow("shared-host", now))
 
+	rows, err = store.LoadParticipantThrottles()
+	require.NoError(t, err)
+	require.Len(t, rows, 1)
+	require.Equal(t, participantStrikesAfterQuarantine, rows[0].FailureStrikes)
+	require.True(t, rows[0].QuarantineUntil.IsZero())
+
+	limiter.ObserveSuccessfulInference("shared-host")
+	limiter.ObserveSuccessfulInference("shared-host")
 	rows, err = store.LoadParticipantThrottles()
 	require.NoError(t, err)
 	require.Len(t, rows, 0)
@@ -2228,7 +2526,7 @@ func TestMigrateGatewayLegacyStorageRejectsConflictingEpochDB(t *testing.T) {
 	require.NoError(t, sqlStore.CreateSession(storage.CreateSessionParams{
 		EscrowID:       "12",
 		EpochID:        270,
-		Version:        types.LegacyRouteSessionVersion,
+		Version:        types.SessionVersionV1,
 		CreatorAddr:    "creator",
 		Config:         types.SessionConfig{},
 		Group:          []types.SlotAssignment{{SlotID: 0, ValidatorAddress: "a"}},
@@ -2314,7 +2612,7 @@ func writeGatewayLegacyStateDB(t *testing.T, path, escrowID string, latestNonce
 	_, err = db.Exec(
 		`INSERT INTO sessions (escrow_id, version, creator_addr, config_json, group_json, initial_balance, latest_nonce)
 		 VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		escrowID, types.LegacyRouteSessionVersion, "creator", string(configJSON), string(groupJSON), 1000, latestNonce,
+		escrowID, types.SessionVersionV1, "creator", string(configJSON), string(groupJSON), 1000, latestNonce,
 	)
 	require.NoError(t, err)
 	for nonce := uint64(1); nonce <= latestNonce; nonce++ {
@@ -2594,6 +2892,8 @@ func TestGatewayMetricsEndpointExposedAndUpdated(t *testing.T) {
 	require.Contains(t, body, `status="429"`)
 	require.Contains(t, body, `devshard_gateway_limit_rejections_total`)
 	require.Contains(t, body, `reason="max_input_tokens_in_flight"`)
+	require.Contains(t, body, `devshard_gateway_requests_total{model="Qwen/Test",outcome="gateway_limited",reason="max_input_tokens_in_flight"} 1`)
+	require.Contains(t, body, `devshard_gateway_critical_user_failures_total{model="Qwen/Test",reason="max_input_tokens_in_flight"} 1`)
 	require.Contains(t, body, `devshard_gateway_inflight_requests`)
 	require.Contains(t, body, `devshard_runtime_active`)
 	require.Contains(t, body, `devshard_id="12"`)
diff --git a/devshard/cmd/devshardctl/hostperf.go b/devshard/cmd/devshardctl/hostperf.go
index 5818d65905..4415e22b9d 100644
--- a/devshard/cmd/devshardctl/hostperf.go
+++ b/devshard/cmd/devshardctl/hostperf.go
@@ -39,6 +39,7 @@ func ApplyPerfSettings(settings PerfSettings) {
 type RequestSample struct {
 	HostIdx        int
 	ParticipantKey string
+	Model          string
 	Responsive     bool
 	SendTime       time.Time
 	ReceiptTime    time.Time // zero if no receipt
diff --git a/devshard/cmd/devshardctl/main.go b/devshard/cmd/devshardctl/main.go
index de73c8890f..d9d567cd36 100644
--- a/devshard/cmd/devshardctl/main.go
+++ b/devshard/cmd/devshardctl/main.go
@@ -48,8 +48,24 @@ type HostStatsJSON struct {
 	Missed               uint32 `json:"missed"`
 	Invalid              uint32 `json:"invalid"`
 	Cost                 uint64 `json:"cost"`
-	RequiredValidations  uint32 `json:"required_validations"`
-	CompletedValidations uint32 `json:"completed_validations"`
+	RequiredValidations  uint32 `json:"required_validations,omitempty"`
+	CompletedValidations uint32 `json:"completed_validations,omitempty"`
+}
+
+func hostStatsJSONFromDomain(slot uint32, hs *types.HostStats) HostStatsJSON {
+	entry := HostStatsJSON{
+		SlotID:  slot,
+		Missed:  hs.Missed,
+		Invalid: hs.Invalid,
+		Cost:    hs.Cost,
+	}
+	if hs.RequiredValidations != 0 {
+		entry.RequiredValidations = hs.RequiredValidations
+	}
+	if hs.CompletedValidations != 0 {
+		entry.CompletedValidations = hs.CompletedValidations
+	}
+	return entry
 }
 
 type SlotSignatureJSON struct {
@@ -104,6 +120,7 @@ var gatewayRuntimeBuilder = buildRuntime
 func main() {
 	ConfigurePoCRequestMode(os.Getenv("DEVSHARD_POC_REQUEST_MODE"))
 	ConfigureCapacityAwareLimits(os.Getenv("DEVSHARD_CAPACITY_AWARE_LIMITS"))
+	configureClassifyCapsFromEnv()
 	flags := parseCLIFlags()
 	runtimeOpts := mustLoadRuntimeOptions(flags)
 	gatewayStore := mustOpenGatewayStore(runtimeOpts.baseStorageDir)
@@ -252,7 +269,7 @@ func mustLoadParticipantThrottleState(store *GatewayStore) {
 		return
 	}
 	for _, t := range throttles {
-		sharedParticipantRequestLimiter.LoadStateWithQuarantine(t.Key, t.Tokens, t.LastRefillAt, t.Status, t.QuarantineUntil, t.EmptyStreamStreak, t.EOFTransportFailureStreak)
+		sharedParticipantRequestLimiter.LoadStateWithQuarantine(t.Key, t.ModelIDs, t.Tokens, t.LastRefillAt, t.Status, t.QuarantineUntil, t.FailureStrikes)
 	}
 	if len(throttles) > 0 {
 		log.Printf("loaded %d persisted participant throttle state(s)", len(throttles))
@@ -363,16 +380,25 @@ func mustBuildGateway(gatewayStore *GatewayStore, gatewayState GatewayState, bas
 }
 
 func buildGatewayRuntimes(gatewayStore *GatewayStore, gatewayState *GatewayState, baseStorageDir string, perf *PerfTracker) ([]*devshardRuntime, error) {
-	// Load ALL devshards (active and inactive) so that inactive ones
-	// remain accessible for finalization, debug, and settlement retrieval.
-	// Inactive runtimes are loaded with active=false and excluded from
-	// the inference routing pool.
+	// Load only ACTIVE devshards at boot. Inactive devshards (deactivated,
+	// finalized, or settled) stay in the registry but are not built into
+	// memory-resident runtimes: keeping hundreds of dormant escrows resident
+	// wastes RAM, and probing each one against the chain at startup causes a
+	// boot-time request storm. Inactive devshards are rehydrated on demand:
+	// read-only from local storage for debug/state endpoints, or fully (with
+	// chain access) for manual settlement. See hydrateReadOnlyRuntime and the
+	// lazy settle path.
 	type cfgEntry struct {
 		cfg    RuntimeConfig
 		active bool
 	}
 	allEntries := make([]cfgEntry, 0, len(gatewayState.Devshards))
+	skippedInactive := 0
 	for _, devshard := range gatewayState.Devshards {
+		if !devshard.Active {
+			skippedInactive++
+			continue
+		}
 		allEntries = append(allEntries, cfgEntry{cfg: devshard.RuntimeConfig, active: devshard.Active})
 	}
 	allCfgs := make([]RuntimeConfig, len(allEntries))
@@ -391,8 +417,13 @@ func buildGatewayRuntimes(gatewayStore *GatewayStore, gatewayState *GatewayState
 	}
 	t0 := time.Now()
 	ch := make(chan buildResult, len(allCfgs))
+	// Cap concurrent builders (see maxConcurrentRuntimeBuilds); results are still
+	// collected per-index below, so ordering and error handling are unchanged.
+	buildSem := make(chan struct{}, resolveMaxConcurrentRuntimeBuilds())
 	for i, cfg := range allCfgs {
 		go func(idx int, cfg RuntimeConfig) {
+			buildSem <- struct{}{}
+			defer func() { <-buildSem }()
 			rt, err := gatewayRuntimeBuilder(cfg, gatewayState.Settings.ChainREST, gatewayState.Settings.DefaultModel, perf)
 			ch <- buildResult{idx, rt, err}
 		}(i, cfg)
@@ -470,8 +501,8 @@ func buildGatewayRuntimes(gatewayStore *GatewayStore, gatewayState *GatewayState
 			out = append(out, rt)
 		}
 	}
-	log.Printf("build_runtimes_parallel count=%d active=%d inactive=%d skipped=%d total_elapsed_ms=%d",
-		len(out), activeCount, inactiveCount, len(skipped), time.Since(t0).Milliseconds())
+	log.Printf("build_runtimes_parallel count=%d active=%d inactive=%d skipped=%d skipped_inactive=%d total_elapsed_ms=%d",
+		len(out), activeCount, inactiveCount, len(skipped), skippedInactive, time.Since(t0).Milliseconds())
 	return out, nil
 }
 
@@ -562,6 +593,7 @@ func isAuthExemptPath(path string) bool {
 func isAdminPath(path string) bool {
 	if strings.HasPrefix(path, "/v1/admin/") ||
 		strings.HasPrefix(path, "/v1/debug/") ||
+		strings.HasPrefix(path, "/debug/pprof/") ||
 		path == "/v1/finalize" ||
 		path == "/v1/state" {
 		return true
@@ -667,11 +699,7 @@ func buildSettlementJSON(p *state.SettlementPayload) (SettlementJSON, error) {
 
 	stats := make([]HostStatsJSON, 0, len(p.HostStats))
 	for slot, hs := range p.HostStats {
-		stats = append(stats, HostStatsJSON{
-			SlotID: slot, Missed: hs.Missed, Invalid: hs.Invalid,
-			Cost: hs.Cost, RequiredValidations: hs.RequiredValidations,
-			CompletedValidations: hs.CompletedValidations,
-		})
+		stats = append(stats, hostStatsJSONFromDomain(slot, hs))
 	}
 
 	sigs := make([]SlotSignatureJSON, 0, len(p.Signatures))
diff --git a/devshard/cmd/devshardctl/main_test.go b/devshard/cmd/devshardctl/main_test.go
index 6cd7c1567b..c315bbd55b 100644
--- a/devshard/cmd/devshardctl/main_test.go
+++ b/devshard/cmd/devshardctl/main_test.go
@@ -2,9 +2,12 @@ package main
 
 import (
 	"fmt"
+	"net/http"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
@@ -168,6 +171,166 @@ func TestBuildGatewayRuntimesPreservesActiveOnOtherErrors(t *testing.T) {
 	require.True(t, reloaded.Devshards[0].Active)
 }
 
+// measurePeakRuntimeBuildConcurrency runs buildGatewayRuntimes over n active
+// devshards with a fake builder that records the peak number of simultaneous
+// builder invocations.
+func measurePeakRuntimeBuildConcurrency(t *testing.T, n int) int64 {
+	t.Helper()
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, store.Close()) })
+	require.NoError(t, store.Initialize(GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		MaxInputTokensInFlight:  200,
+	}, activeDevshardStates(n)))
+
+	state, ok, err := store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+
+	var inFlight, peakInFlight atomic.Int64
+	savedBuilder := gatewayRuntimeBuilder
+	gatewayRuntimeBuilder = func(cfg RuntimeConfig, chainREST, defaultModel string, perf *PerfTracker) (*devshardRuntime, error) {
+		running := inFlight.Add(1)
+		for {
+			peak := peakInFlight.Load()
+			if running <= peak || peakInFlight.CompareAndSwap(peak, running) {
+				break
+			}
+		}
+		// Hold the slot briefly so overlapping builders show up in the
+		// high-water mark; this occupies the resource, it does not wait on
+		// async work.
+		time.Sleep(25 * time.Millisecond)
+		inFlight.Add(-1)
+		return &devshardRuntime{id: cfg.ID, model: defaultModel}, nil
+	}
+	t.Cleanup(func() { gatewayRuntimeBuilder = savedBuilder })
+
+	runtimes, err := buildGatewayRuntimes(store, &state, t.TempDir(), NewPerfTracker(nil))
+	require.NoError(t, err)
+	require.Len(t, runtimes, n)
+	return peakInFlight.Load()
+}
+
+func TestBuildGatewayRuntimesBoundsBuilderConcurrency(t *testing.T) {
+	// An unbounded fan-out floods the chain LCD (429) and crash-loops startup;
+	// builder concurrency must stay within the resolved bound.
+	const devshardCount = 32
+	limit := int64(resolveMaxConcurrentRuntimeBuilds())
+
+	peak := measurePeakRuntimeBuildConcurrency(t, devshardCount)
+
+	require.Greater(t, int64(devshardCount), limit, "test needs more devshards than the bound to be meaningful")
+	require.LessOrEqual(t, peak, limit, "runtime builder fan-out is unbounded: %d builders ran concurrently", peak)
+}
+
+func TestBuildGatewayRuntimesHonorsConcurrencyEnvOverride(t *testing.T) {
+	t.Setenv("DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS", "4")
+
+	peak := measurePeakRuntimeBuildConcurrency(t, 32)
+
+	require.LessOrEqual(t, peak, int64(4), "DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS=4 must bound builder concurrency")
+}
+
+func activeDevshardStates(n int) []GatewayDevshardState {
+	states := make([]GatewayDevshardState, 0, n)
+	for i := 0; i < n; i++ {
+		states = append(states, GatewayDevshardState{
+			RuntimeConfig: RuntimeConfig{ID: fmt.Sprintf("%d", i+1), PrivateKeyHex: "secret", Model: "Qwen/Test"},
+			Active:        true,
+		})
+	}
+	return states
+}
+
+func TestBuildGatewayRuntimesBoundedFanoutSurvivesRateLimitingLCD(t *testing.T) {
+	// Regression: an unbounded builder fan-out floods the chain LCD, which
+	// answers 429. A 429 is not a soft error (unlike ErrEscrowNotFound /
+	// private-key-missing), so it becomes firstFatal and the gateway fails to
+	// start — restart repeats the same fan-out — crash loop. With the fan-out
+	// bounded, at most the resolved limit of builders hit the LCD at once, so an
+	// LCD that tolerates that many never rate-limits and startup succeeds.
+	const devshardCount = 32
+	limit := int64(resolveMaxConcurrentRuntimeBuilds())
+
+	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
+	require.NoError(t, err)
+	t.Cleanup(func() { require.NoError(t, store.Close()) })
+	require.NoError(t, store.Initialize(GatewaySettings{
+		ChainREST:               "http://node:1317",
+		PublicAPI:               "http://api:9000",
+		DefaultModel:            "Qwen/Test",
+		DefaultRequestMaxTokens: 1000,
+		MaxConcurrentRequests:   2,
+		MaxInputTokensInFlight:  200,
+	}, activeDevshardStates(devshardCount)))
+
+	state, ok, err := store.LoadState()
+	require.NoError(t, err)
+	require.True(t, ok)
+
+	// The fake LCD tolerates up to the resolved limit of concurrent builds and
+	// rejects the one that exceeds it with a 429.
+	var inFlight atomic.Int64
+	var rateLimited atomic.Bool
+	savedBuilder := gatewayRuntimeBuilder
+	gatewayRuntimeBuilder = func(cfg RuntimeConfig, chainREST, defaultModel string, perf *PerfTracker) (*devshardRuntime, error) {
+		defer inFlight.Add(-1)
+		if inFlight.Add(1) > limit {
+			rateLimited.Store(true)
+			return nil, fmt.Errorf("runtime %s: get escrow: chain LCD: 429 Too Many Requests", cfg.ID)
+		}
+		// Hold the slot so genuinely concurrent builders overlap.
+		time.Sleep(25 * time.Millisecond)
+		return &devshardRuntime{id: cfg.ID, model: defaultModel}, nil
+	}
+	t.Cleanup(func() { gatewayRuntimeBuilder = savedBuilder })
+
+	runtimes, err := buildGatewayRuntimes(store, &state, t.TempDir(), NewPerfTracker(nil))
+
+	require.False(t, rateLimited.Load(), "fan-out exceeded the LCD's concurrency tolerance and tripped a 429")
+	require.NoError(t, err, "bounded startup must survive a rate-limiting LCD")
+	require.Len(t, runtimes, devshardCount)
+}
+
+func TestResolveMaxConcurrentRuntimeBuildsDefaultsWhenUnset(t *testing.T) {
+	require.NoError(t, os.Unsetenv("DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS"))
+	require.Equal(t, defaultMaxConcurrentRuntimeBuilds, resolveMaxConcurrentRuntimeBuilds())
+}
+
+func TestResolveMaxConcurrentRuntimeBuildsParsesOverride(t *testing.T) {
+	cases := []struct {
+		name string
+		env  string
+		want int
+	}{
+		{name: "valid positive", env: "4", want: 4},
+		{name: "zero falls back", env: "0", want: defaultMaxConcurrentRuntimeBuilds},
+		{name: "negative falls back", env: "-3", want: defaultMaxConcurrentRuntimeBuilds},
+		{name: "non-numeric falls back", env: "abc", want: defaultMaxConcurrentRuntimeBuilds},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Setenv("DEVSHARD_MAX_CONCURRENT_RUNTIME_BUILDS", tc.env)
+			require.Equal(t, tc.want, resolveMaxConcurrentRuntimeBuilds())
+		})
+	}
+}
+
+func TestBuildRuntimeBridgeClientPinsIdleConnPool(t *testing.T) {
+	client := buildRuntimeBridgeClient(4)
+	transport, ok := client.Transport.(*http.Transport)
+	require.True(t, ok)
+	require.Equal(t, 4, transport.MaxIdleConnsPerHost)
+	require.Equal(t, 4, transport.MaxIdleConns)
+	require.Equal(t, 10*time.Second, client.Timeout)
+}
+
 func TestRepairPersistedGatewayEndpointSettingsBackfillsBlankPublicAPI(t *testing.T) {
 	store, err := NewGatewayStore(filepath.Join(t.TempDir(), "gateway.db"))
 	require.NoError(t, err)
diff --git a/devshard/cmd/devshardctl/marshal_test.go b/devshard/cmd/devshardctl/marshal_test.go
index 72611b4aae..1278d07ecc 100644
--- a/devshard/cmd/devshardctl/marshal_test.go
+++ b/devshard/cmd/devshardctl/marshal_test.go
@@ -37,11 +37,11 @@ func TestMarshalSettlement_RoundTrip(t *testing.T) {
 	payload := &state.SettlementPayload{
 		EscrowID:                    "42",
 		StateRootAndProtocolVersion: "dev",
-		Nonce:      5,
-		Fees:       321,
-		RestHash:   restHash,
-		HostStats:  hostStats,
-		Signatures: map[uint32][]byte{0: []byte("sig0"), 1: []byte("sig1")},
+		Nonce:                       5,
+		Fees:                        321,
+		RestHash:                    restHash,
+		HostStats:                   hostStats,
+		Signatures:                  map[uint32][]byte{0: []byte("sig0"), 1: []byte("sig1")},
 	}
 
 	// Step 1: marshal (devshardctl side)
@@ -135,3 +135,34 @@ func TestMarshalSettlement_KotlinReserialize(t *testing.T) {
 	require.Equal(t, expectedRoot, stateRoot,
 		"state_root mismatch after Kotlin-style re-serialization")
 }
+
+func TestMarshalSettlement_OmitsZeroValidationFields(t *testing.T) {
+	hostStats := map[uint32]*types.HostStats{
+		0: {Cost: 150},
+		1: {Cost: 100, Missed: 1},
+	}
+	restHash, err := state.ComputeRestHash(9850, map[uint64]*types.InferenceRecord{
+		1: {Status: types.StatusFinished, ExecutorSlot: 0, PromptHash: []byte("abcdefghijklmnopqrstuvwxyz012345")},
+	}, nil)
+	require.NoError(t, err)
+
+	payload := &state.SettlementPayload{
+		EscrowID:                    "42",
+		StateRootAndProtocolVersion: "dev",
+		Nonce:                       3,
+		Fees:                        10,
+		RestHash:                    restHash,
+		HostStats:                   hostStats,
+		Signatures:                  map[uint32][]byte{0: []byte("sig0")},
+	}
+
+	data, err := marshalSettlement(payload)
+	require.NoError(t, err)
+	require.NotContains(t, string(data), "required_validations")
+	require.NotContains(t, string(data), "completed_validations")
+
+	var parsed SettlementJSON
+	require.NoError(t, json.Unmarshal(data, &parsed))
+	require.Equal(t, uint32(0), parsed.HostStats[0].RequiredValidations)
+	require.Equal(t, uint32(0), parsed.HostStats[0].CompletedValidations)
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/content.go b/devshard/cmd/devshardctl/messagevalidators/content.go
new file mode 100644
index 0000000000..d458eee72d
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/content.go
@@ -0,0 +1,124 @@
+package messagevalidators
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ValidateNonEmptyContent rejects empty strings and empty/malformed content-part
+// arrays. Each non-string content must be a []any of typed text parts.
+func ValidateNonEmptyContent(content any) error {
+	switch value := content.(type) {
+	case string:
+		if strings.TrimSpace(value) == "" {
+			return fmt.Errorf("must not be empty")
+		}
+		return nil
+	case []any:
+		if len(value) == 0 {
+			return fmt.Errorf("must not be empty")
+		}
+		for i, rawPart := range value {
+			part, ok := rawPart.(map[string]any)
+			if !ok {
+				return fmt.Errorf("[%d] must be an object", i)
+			}
+			text, err := RequiredTextContentPart(part, i)
+			if err != nil {
+				return err
+			}
+			if strings.TrimSpace(text) == "" {
+				return fmt.Errorf("[%d].text must not be empty", i)
+			}
+		}
+		return nil
+	default:
+		return fmt.Errorf("must be a string or an array of typed content parts")
+	}
+}
+
+func ValidateRequiredContentField(message map[string]any) error {
+	content, exists := message["content"]
+	if !exists || content == nil {
+		return fmt.Errorf("is required")
+	}
+	return ValidateNonEmptyContent(content)
+}
+
+func ValidateAssistantContentField(message map[string]any, canBeEmpty bool) error {
+	content, exists := message["content"]
+	if !exists || content == nil {
+		if canBeEmpty {
+			return nil
+		}
+		return fmt.Errorf("is required unless tool_calls or function_call is provided")
+	}
+	return ValidateNonEmptyContent(content)
+}
+
+// RequiredTextContentPart validates that part has type:"text" and a non-empty text field.
+// Returned errors carry no `messages[%d].content` prefix — the caller adds it.
+func RequiredTextContentPart(part map[string]any, partIndex int) (string, error) {
+	partType, err := RequiredNonEmptyString(part, "type")
+	if err != nil {
+		return "", fmt.Errorf("[%d].type: %w", partIndex, err)
+	}
+	if partType != "text" {
+		return "", fmt.Errorf("[%d].type has unsupported value %q", partIndex, partType)
+	}
+	text, err := RequiredNonEmptyString(part, "text")
+	if err != nil {
+		return "", fmt.Errorf("[%d].text: %w", partIndex, err)
+	}
+	return text, nil
+}
+
+// CombineTextContentParts joins typed text parts into a single newline-separated string.
+// Returned errors carry no `messages[%d].content` prefix — the caller adds it.
+func CombineTextContentParts(parts []any) (string, error) {
+	texts := make([]string, 0, len(parts))
+	for partIndex, rawPart := range parts {
+		part, ok := rawPart.(map[string]any)
+		if !ok {
+			return "", fmt.Errorf("[%d] must be an object", partIndex)
+		}
+		text, err := RequiredTextContentPart(part, partIndex)
+		if err != nil {
+			return "", err
+		}
+		texts = append(texts, text)
+	}
+	if len(texts) == 0 {
+		return "", nil
+	}
+	return strings.Join(texts, "\n"), nil
+}
+
+func IsEmptyContent(content any) bool {
+	switch v := content.(type) {
+	case string:
+		return strings.TrimSpace(v) == ""
+	case []any:
+		return len(v) == 0
+	default:
+		return false
+	}
+}
+
+func IsAssistantTurnEmpty(msg map[string]any) bool {
+	if raw, exists := msg["tool_calls"]; exists && raw != nil {
+		if calls, ok := raw.([]any); ok && len(calls) > 0 {
+			return false
+		}
+	}
+	if raw, exists := msg["function_call"]; exists && raw != nil {
+		if fc, ok := raw.(map[string]any); ok && len(fc) > 0 {
+			return false
+		}
+	}
+	content, exists := msg["content"]
+	if !exists || content == nil {
+		return true
+	}
+	return IsEmptyContent(content)
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/content_test.go b/devshard/cmd/devshardctl/messagevalidators/content_test.go
new file mode 100644
index 0000000000..5592013f9a
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/content_test.go
@@ -0,0 +1,261 @@
+package messagevalidators
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateNonEmptyContent(t *testing.T) {
+	cases := []struct {
+		name      string
+		content   any
+		errSubstr string
+	}{
+		{"string-ok", "hello", ""},
+		{"string-with-think-block", "<think>step</think> answer", ""},
+		{"string-empty", "", "must not be empty"},
+		{"string-whitespace", "  \t\n  ", "must not be empty"},
+		{"array-of-text-parts-ok", []any{map[string]any{"type": "text", "text": "hello"}}, ""},
+		{"array-empty", []any{}, "must not be empty"},
+		{"array-element-not-object", []any{"not-an-object"}, "[0] must be an object"},
+		{"array-part-missing-type", []any{map[string]any{"text": "no type"}}, "[0].type"},
+		{"array-part-wrong-type", []any{map[string]any{"type": "image_url", "text": "x"}}, "unsupported value"},
+		{"array-part-empty-text", []any{map[string]any{"type": "text", "text": " "}}, "[0].text"},
+		{"number-not-supported", 42, "must be a string or an array"},
+		{"object-not-supported", map[string]any{}, "must be a string or an array"},
+		{"nil-not-supported", nil, "must be a string or an array"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := ValidateNonEmptyContent(tc.content)
+			if tc.errSubstr == "" {
+				if err != nil {
+					t.Fatalf("want no error, got %v", err)
+				}
+				return
+			}
+			if err == nil {
+				t.Fatalf("want error containing %q, got nil", tc.errSubstr)
+			}
+			if !strings.Contains(err.Error(), tc.errSubstr) {
+				t.Fatalf("want error containing %q, got %q", tc.errSubstr, err.Error())
+			}
+		})
+	}
+}
+
+func TestValidateRequiredContentField(t *testing.T) {
+	t.Run("missing-rejected", func(t *testing.T) {
+		err := ValidateRequiredContentField(map[string]any{})
+		if err == nil || !strings.Contains(err.Error(), "is required") {
+			t.Fatalf("want 'is required', got %v", err)
+		}
+	})
+	t.Run("nil-rejected", func(t *testing.T) {
+		err := ValidateRequiredContentField(map[string]any{"content": nil})
+		if err == nil || !strings.Contains(err.Error(), "is required") {
+			t.Fatalf("want 'is required', got %v", err)
+		}
+	})
+	t.Run("string-ok", func(t *testing.T) {
+		err := ValidateRequiredContentField(map[string]any{"content": "hi"})
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+	})
+}
+
+func TestValidateAssistantContentField(t *testing.T) {
+	t.Run("missing-with-canBeEmpty-ok", func(t *testing.T) {
+		// Assistant turn with tool_calls/function_call can omit content.
+		err := ValidateAssistantContentField(map[string]any{}, true)
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+	})
+	t.Run("missing-without-canBeEmpty-rejected", func(t *testing.T) {
+		err := ValidateAssistantContentField(map[string]any{}, false)
+		if err == nil || !strings.Contains(err.Error(), "tool_calls or function_call") {
+			t.Fatalf("want hint about tool_calls/function_call, got %v", err)
+		}
+	})
+	t.Run("nil-with-canBeEmpty-ok", func(t *testing.T) {
+		err := ValidateAssistantContentField(map[string]any{"content": nil}, true)
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+	})
+	t.Run("non-empty-content-still-validated", func(t *testing.T) {
+		// Even when canBeEmpty=true, present content must not be empty/wrong shape.
+		err := ValidateAssistantContentField(map[string]any{"content": ""}, true)
+		if err == nil {
+			t.Fatal("empty string content must still be rejected")
+		}
+	})
+}
+
+func TestRequiredTextContentPart(t *testing.T) {
+	t.Run("happy", func(t *testing.T) {
+		text, err := RequiredTextContentPart(map[string]any{"type": "text", "text": "hello"}, 0)
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+		if text != "hello" {
+			t.Fatalf("want 'hello', got %q", text)
+		}
+	})
+	t.Run("missing-type", func(t *testing.T) {
+		_, err := RequiredTextContentPart(map[string]any{"text": "hi"}, 2)
+		if err == nil || !strings.Contains(err.Error(), "[2].type") {
+			t.Fatalf("want '[2].type', got %v", err)
+		}
+	})
+	t.Run("wrong-type", func(t *testing.T) {
+		_, err := RequiredTextContentPart(map[string]any{"type": "image_url", "text": "x"}, 3)
+		if err == nil || !strings.Contains(err.Error(), "unsupported value") {
+			t.Fatalf("want 'unsupported value', got %v", err)
+		}
+	})
+	t.Run("missing-text", func(t *testing.T) {
+		_, err := RequiredTextContentPart(map[string]any{"type": "text"}, 0)
+		if err == nil || !strings.Contains(err.Error(), "[0].text") {
+			t.Fatalf("want '[0].text', got %v", err)
+		}
+	})
+}
+
+func TestCombineTextContentParts(t *testing.T) {
+	t.Run("single-part", func(t *testing.T) {
+		got, err := CombineTextContentParts([]any{map[string]any{"type": "text", "text": "hello"}})
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+		if got != "hello" {
+			t.Fatalf("want 'hello', got %q", got)
+		}
+	})
+	t.Run("multiple-parts-newline-join", func(t *testing.T) {
+		got, err := CombineTextContentParts([]any{
+			map[string]any{"type": "text", "text": "first"},
+			map[string]any{"type": "text", "text": "second"},
+		})
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+		if got != "first\nsecond" {
+			t.Fatalf("want 'first\\nsecond', got %q", got)
+		}
+	})
+	t.Run("empty-array-returns-empty-string", func(t *testing.T) {
+		got, err := CombineTextContentParts([]any{})
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+		if got != "" {
+			t.Fatalf("want empty, got %q", got)
+		}
+	})
+	t.Run("non-object-element", func(t *testing.T) {
+		_, err := CombineTextContentParts([]any{"plain-string"})
+		if err == nil || !strings.Contains(err.Error(), "[0] must be an object") {
+			t.Fatalf("want '[0] must be an object', got %v", err)
+		}
+	})
+	t.Run("propagates-part-error", func(t *testing.T) {
+		_, err := CombineTextContentParts([]any{map[string]any{"type": "image_url", "text": "x"}})
+		if err == nil || !strings.Contains(err.Error(), "unsupported value") {
+			t.Fatalf("want 'unsupported value', got %v", err)
+		}
+	})
+	t.Run("preserves-think-block-in-text", func(t *testing.T) {
+		// MiniMax-M2.7 round-trips <think>...</think> verbatim in content.
+		got, err := CombineTextContentParts([]any{
+			map[string]any{"type": "text", "text": "<think>reasoning</think>"},
+			map[string]any{"type": "text", "text": "answer"},
+		})
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+		if got != "<think>reasoning</think>\nanswer" {
+			t.Fatalf("think block must round-trip, got %q", got)
+		}
+	})
+}
+
+func TestIsEmptyContent(t *testing.T) {
+	cases := []struct {
+		name    string
+		content any
+		want    bool
+	}{
+		{"empty-string", "", true},
+		{"whitespace-string", "   ", true},
+		{"non-empty-string", "x", false},
+		{"empty-array", []any{}, true},
+		{"non-empty-array", []any{1}, false},
+		{"nil-not-empty", nil, false}, // nil is "missing", not "empty"
+		{"int-not-empty", 42, false},
+		{"object-not-empty", map[string]any{}, false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := IsEmptyContent(tc.content); got != tc.want {
+				t.Fatalf("want %v, got %v", tc.want, got)
+			}
+		})
+	}
+}
+
+func TestIsAssistantTurnEmpty(t *testing.T) {
+	t.Run("no-fields-empty", func(t *testing.T) {
+		if !IsAssistantTurnEmpty(map[string]any{}) {
+			t.Fatal("empty turn must be empty")
+		}
+	})
+	t.Run("content-only-non-empty", func(t *testing.T) {
+		if IsAssistantTurnEmpty(map[string]any{"content": "hi"}) {
+			t.Fatal("turn with content must not be empty")
+		}
+	})
+	t.Run("tool-calls-non-empty", func(t *testing.T) {
+		msg := map[string]any{"tool_calls": []any{map[string]any{"id": "x"}}}
+		if IsAssistantTurnEmpty(msg) {
+			t.Fatal("turn with tool_calls must not be empty")
+		}
+	})
+	t.Run("empty-tool-calls-array-still-empty", func(t *testing.T) {
+		// Empty tool_calls = informationless placeholder.
+		msg := map[string]any{"tool_calls": []any{}}
+		if !IsAssistantTurnEmpty(msg) {
+			t.Fatal("empty tool_calls slot is informationless")
+		}
+	})
+	t.Run("nil-tool-calls-treated-as-absent", func(t *testing.T) {
+		msg := map[string]any{"tool_calls": nil}
+		if !IsAssistantTurnEmpty(msg) {
+			t.Fatal("nil tool_calls is absent")
+		}
+	})
+	t.Run("function-call-non-empty", func(t *testing.T) {
+		msg := map[string]any{"function_call": map[string]any{"name": "fn"}}
+		if IsAssistantTurnEmpty(msg) {
+			t.Fatal("turn with function_call must not be empty")
+		}
+	})
+	t.Run("empty-function-call-object-empty", func(t *testing.T) {
+		msg := map[string]any{"function_call": map[string]any{}}
+		if !IsAssistantTurnEmpty(msg) {
+			t.Fatal("empty function_call object is informationless")
+		}
+	})
+	t.Run("nil-content-empty", func(t *testing.T) {
+		if !IsAssistantTurnEmpty(map[string]any{"content": nil}) {
+			t.Fatal("nil content is empty")
+		}
+	})
+	t.Run("empty-content-array-empty", func(t *testing.T) {
+		if !IsAssistantTurnEmpty(map[string]any{"content": []any{}}) {
+			t.Fatal("empty content array is empty")
+		}
+	})
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/fields.go b/devshard/cmd/devshardctl/messagevalidators/fields.go
new file mode 100644
index 0000000000..702be36988
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/fields.go
@@ -0,0 +1,44 @@
+package messagevalidators
+
+import (
+	"fmt"
+	"strings"
+)
+
+// RequiredNonEmptyString returns the trimmed string value at values[field]
+// or describes why it's missing/wrong. Returned errors carry no positional
+// prefix — the caller (which knows the message/part index) wraps them.
+func RequiredNonEmptyString(values map[string]any, field string) (string, error) {
+	rawValue, exists := values[field]
+	if !exists || rawValue == nil {
+		return "", fmt.Errorf("is required")
+	}
+	value, ok := rawValue.(string)
+	if !ok {
+		return "", fmt.Errorf("must be a string")
+	}
+	if strings.TrimSpace(value) == "" {
+		return "", fmt.Errorf("must not be empty")
+	}
+	return value, nil
+}
+
+func OptionalStringField(values map[string]any, field string) error {
+	rawValue, exists := values[field]
+	if !exists || rawValue == nil {
+		return nil
+	}
+	if _, ok := rawValue.(string); !ok {
+		return fmt.Errorf("must be a string")
+	}
+	return nil
+}
+
+func EnsureFieldsAbsent(values map[string]any, fields ...string) error {
+	for _, field := range fields {
+		if _, exists := values[field]; exists {
+			return fmt.Errorf("%s is not allowed for this role", field)
+		}
+	}
+	return nil
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/fields_test.go b/devshard/cmd/devshardctl/messagevalidators/fields_test.go
new file mode 100644
index 0000000000..e855ce028b
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/fields_test.go
@@ -0,0 +1,120 @@
+package messagevalidators
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestRequiredNonEmptyString(t *testing.T) {
+	cases := []struct {
+		name      string
+		values    map[string]any
+		field     string
+		want      string
+		errSubstr string
+	}{
+		{"happy", map[string]any{"x": "hello"}, "x", "hello", ""},
+		{"trimmed-keeps-original", map[string]any{"x": "  hello  "}, "x", "  hello  ", ""},
+		{"missing", map[string]any{}, "x", "", "is required"},
+		{"explicit-nil", map[string]any{"x": nil}, "x", "", "is required"},
+		{"non-string", map[string]any{"x": 42}, "x", "", "must be a string"},
+		{"bool-not-string", map[string]any{"x": true}, "x", "", "must be a string"},
+		{"empty-string", map[string]any{"x": ""}, "x", "", "must not be empty"},
+		{"whitespace-only", map[string]any{"x": "   \t\n"}, "x", "", "must not be empty"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got, err := RequiredNonEmptyString(tc.values, tc.field)
+			if tc.errSubstr == "" {
+				if err != nil {
+					t.Fatalf("want no error, got %v", err)
+				}
+				if got != tc.want {
+					t.Fatalf("want %q, got %q", tc.want, got)
+				}
+				return
+			}
+			if err == nil {
+				t.Fatalf("want error containing %q, got nil", tc.errSubstr)
+			}
+			if !strings.Contains(err.Error(), tc.errSubstr) {
+				t.Fatalf("want error containing %q, got %q", tc.errSubstr, err.Error())
+			}
+		})
+	}
+}
+
+func TestOptionalStringField(t *testing.T) {
+	cases := []struct {
+		name      string
+		values    map[string]any
+		field     string
+		errSubstr string
+	}{
+		{"missing-ok", map[string]any{}, "x", ""},
+		{"explicit-nil-ok", map[string]any{"x": nil}, "x", ""},
+		{"empty-string-ok", map[string]any{"x": ""}, "x", ""},
+		{"valid-string-ok", map[string]any{"x": "hello"}, "x", ""},
+		{"non-string-rejected", map[string]any{"x": 42}, "x", "must be a string"},
+		{"object-rejected", map[string]any{"x": map[string]any{}}, "x", "must be a string"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := OptionalStringField(tc.values, tc.field)
+			if tc.errSubstr == "" {
+				if err != nil {
+					t.Fatalf("want no error, got %v", err)
+				}
+				return
+			}
+			if err == nil {
+				t.Fatalf("want error containing %q, got nil", tc.errSubstr)
+			}
+			if !strings.Contains(err.Error(), tc.errSubstr) {
+				t.Fatalf("want error containing %q, got %q", tc.errSubstr, err.Error())
+			}
+		})
+	}
+}
+
+func TestEnsureFieldsAbsent(t *testing.T) {
+	t.Run("all-absent-ok", func(t *testing.T) {
+		err := EnsureFieldsAbsent(map[string]any{"role": "user"}, "tool_calls", "tool_call_id")
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+	})
+	t.Run("present-rejected", func(t *testing.T) {
+		err := EnsureFieldsAbsent(map[string]any{"role": "user", "tool_calls": []any{}}, "tool_calls")
+		if err == nil {
+			t.Fatal("want error, got nil")
+		}
+		if !strings.Contains(err.Error(), "tool_calls is not allowed") {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	})
+	t.Run("first-violation-wins", func(t *testing.T) {
+		// Multiple violations: caller sees the first listed disallowed field.
+		err := EnsureFieldsAbsent(map[string]any{"a": 1, "b": 2}, "a", "b")
+		if err == nil {
+			t.Fatal("want error, got nil")
+		}
+		if !strings.Contains(err.Error(), "a is not allowed") {
+			t.Fatalf("want first-violation 'a', got %v", err)
+		}
+	})
+	t.Run("nil-value-still-present", func(t *testing.T) {
+		// An explicit null in the request still counts as "present" — clients that
+		// emit nil placeholders must not bypass the role policy.
+		err := EnsureFieldsAbsent(map[string]any{"tool_calls": nil}, "tool_calls")
+		if err == nil {
+			t.Fatal("want error, got nil")
+		}
+	})
+	t.Run("variadic-empty-ok", func(t *testing.T) {
+		err := EnsureFieldsAbsent(map[string]any{"a": 1}, []string{}...)
+		if err != nil {
+			t.Fatalf("want no error, got %v", err)
+		}
+	})
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/minimax_tool_message.go b/devshard/cmd/devshardctl/messagevalidators/minimax_tool_message.go
new file mode 100644
index 0000000000..a630e7cf03
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/minimax_tool_message.go
@@ -0,0 +1,76 @@
+package messagevalidators
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// MiniMax-M2.7 tool result messages carry per-call results as an array of
+// {name, type:"text", text} objects instead of OpenAI's single content string
+// keyed by tool_call_id.
+var (
+	ErrMinimaxToolContentShape = errors.New("content: must be a non-empty array of {name,type,text} objects")
+	ErrMinimaxToolEntryShape   = errors.New("content entry: invalid shape")
+)
+
+type MinimaxToolMessage struct {
+	MaxEntries  int
+	NameMaxLen  int
+	TextMaxSize int
+}
+
+// Validate enforces the MiniMax tool message content shape and per-entry caps.
+func (v MinimaxToolMessage) Validate(content any) error {
+	entries, ok := content.([]any)
+	if !ok {
+		return fmt.Errorf("%w: not an array", ErrMinimaxToolContentShape)
+	}
+	if len(entries) == 0 {
+		return fmt.Errorf("%w: array is empty", ErrMinimaxToolContentShape)
+	}
+	if v.MaxEntries > 0 && len(entries) > v.MaxEntries {
+		return fmt.Errorf("%w: %d entries exceeds limit %d", ErrMinimaxToolContentShape, len(entries), v.MaxEntries)
+	}
+	for i, rawEntry := range entries {
+		if err := v.validateEntry(i, rawEntry); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (v MinimaxToolMessage) validateEntry(index int, raw any) error {
+	entry, ok := raw.(map[string]any)
+	if !ok {
+		return fmt.Errorf("%w: [%d] must be an object", ErrMinimaxToolEntryShape, index)
+	}
+	// Closed allow-list. Stray keys would otherwise reach the upstream parser
+	// whose union-with-null typing has been a crash vector (SGLang #16057).
+	for key := range entry {
+		switch key {
+		case "name", "type", "text":
+		default:
+			return fmt.Errorf("%w: [%d] has unsupported key %q", ErrMinimaxToolEntryShape, index, key)
+		}
+	}
+	name, ok := entry["name"].(string)
+	if !ok || strings.TrimSpace(name) == "" {
+		return fmt.Errorf("%w: [%d].name must be a non-empty string", ErrMinimaxToolEntryShape, index)
+	}
+	if v.NameMaxLen > 0 && len(name) > v.NameMaxLen {
+		return fmt.Errorf("%w: [%d].name length %d exceeds limit %d", ErrMinimaxToolEntryShape, index, len(name), v.NameMaxLen)
+	}
+	partType, ok := entry["type"].(string)
+	if !ok || partType != "text" {
+		return fmt.Errorf("%w: [%d].type must be \"text\"", ErrMinimaxToolEntryShape, index)
+	}
+	text, ok := entry["text"].(string)
+	if !ok {
+		return fmt.Errorf("%w: [%d].text must be a string", ErrMinimaxToolEntryShape, index)
+	}
+	if v.TextMaxSize > 0 && len(text) > v.TextMaxSize {
+		return fmt.Errorf("%w: [%d].text size %d exceeds limit %d", ErrMinimaxToolEntryShape, index, len(text), v.TextMaxSize)
+	}
+	return nil
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/minimax_tool_message_test.go b/devshard/cmd/devshardctl/messagevalidators/minimax_tool_message_test.go
new file mode 100644
index 0000000000..b165e82b76
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/minimax_tool_message_test.go
@@ -0,0 +1,112 @@
+package messagevalidators
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func validatorForTest() MinimaxToolMessage {
+	return MinimaxToolMessage{MaxEntries: 16, NameMaxLen: 64, TextMaxSize: 1024}
+}
+
+func TestMinimaxToolMessage_AcceptsCanonicalShape(t *testing.T) {
+	v := validatorForTest()
+	content := []any{
+		map[string]any{"name": "get_weather", "type": "text", "text": `{"temperature":"25"}`},
+		map[string]any{"name": "search_web", "type": "text", "text": "results"},
+	}
+	if err := v.Validate(content); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsNonArray(t *testing.T) {
+	if err := validatorForTest().Validate("plain string"); !errors.Is(err, ErrMinimaxToolContentShape) {
+		t.Fatalf("expected ErrMinimaxToolContentShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsEmptyArray(t *testing.T) {
+	if err := validatorForTest().Validate([]any{}); !errors.Is(err, ErrMinimaxToolContentShape) {
+		t.Fatalf("expected ErrMinimaxToolContentShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsTooManyEntries(t *testing.T) {
+	v := MinimaxToolMessage{MaxEntries: 2, NameMaxLen: 64, TextMaxSize: 1024}
+	content := []any{
+		map[string]any{"name": "a", "type": "text", "text": "1"},
+		map[string]any{"name": "b", "type": "text", "text": "2"},
+		map[string]any{"name": "c", "type": "text", "text": "3"},
+	}
+	if err := v.Validate(content); !errors.Is(err, ErrMinimaxToolContentShape) {
+		t.Fatalf("expected ErrMinimaxToolContentShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsNonObjectEntry(t *testing.T) {
+	if err := validatorForTest().Validate([]any{"not an object"}); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsMissingName(t *testing.T) {
+	content := []any{map[string]any{"type": "text", "text": "result"}}
+	if err := validatorForTest().Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsBlankName(t *testing.T) {
+	content := []any{map[string]any{"name": "", "type": "text", "text": "result"}}
+	if err := validatorForTest().Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+// A whitespace-only name must be rejected too: it otherwise passes the gateway,
+// reaches the MiniMax tool parser, and hangs the request until the deadline.
+func TestMinimaxToolMessage_RejectsWhitespaceName(t *testing.T) {
+	content := []any{map[string]any{"name": "   ", "type": "text", "text": "result"}}
+	if err := validatorForTest().Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsOverlongName(t *testing.T) {
+	v := MinimaxToolMessage{MaxEntries: 16, NameMaxLen: 8, TextMaxSize: 1024}
+	content := []any{map[string]any{"name": "way_too_long_function_name", "type": "text", "text": "ok"}}
+	if err := v.Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsWrongType(t *testing.T) {
+	content := []any{map[string]any{"name": "fn", "type": "image_url", "text": "x"}}
+	if err := validatorForTest().Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsNonStringText(t *testing.T) {
+	content := []any{map[string]any{"name": "fn", "type": "text", "text": 42}}
+	if err := validatorForTest().Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsOverlongText(t *testing.T) {
+	v := MinimaxToolMessage{MaxEntries: 16, NameMaxLen: 64, TextMaxSize: 4}
+	content := []any{map[string]any{"name": "fn", "type": "text", "text": strings.Repeat("a", 5)}}
+	if err := v.Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
+
+func TestMinimaxToolMessage_RejectsExtraKeys(t *testing.T) {
+	content := []any{map[string]any{"name": "fn", "type": "text", "text": "ok", "extra": true}}
+	if err := validatorForTest().Validate(content); !errors.Is(err, ErrMinimaxToolEntryShape) {
+		t.Fatalf("expected ErrMinimaxToolEntryShape, got %v", err)
+	}
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/normalizers.go b/devshard/cmd/devshardctl/messagevalidators/normalizers.go
new file mode 100644
index 0000000000..95f51c5f4f
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/normalizers.go
@@ -0,0 +1,249 @@
+package messagevalidators
+
+import (
+	"fmt"
+	"slices"
+)
+
+// Wire-format role values; kept as local literals so the package stays free of
+// main-package imports. These match what is on the JSON wire and never change.
+const (
+	roleAssistant = "assistant"
+	roleTool      = "tool"
+)
+
+// OrphanToolMessageDropper drops role:"tool" entries whose tool_call_id has no
+// matching prior assistant.tool_call. Mirrors ValidateDocument's pending-set
+// accounting so survivors pass the strict check downstream.
+type OrphanToolMessageDropper struct{}
+
+func (OrphanToolMessageDropper) Apply(messages []any) ([]any, bool, error) {
+	pending := map[string]struct{}{}
+	filtered := make([]any, 0, len(messages))
+	dropped := false
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			filtered = append(filtered, raw)
+			continue
+		}
+		role, _ := msg["role"].(string)
+		switch role {
+		case roleAssistant:
+			if calls, ok := msg["tool_calls"].([]any); ok {
+				for _, rawCall := range calls {
+					call, ok := rawCall.(map[string]any)
+					if !ok {
+						continue
+					}
+					if id, ok := call["id"].(string); ok && id != "" {
+						pending[id] = struct{}{}
+					}
+				}
+			}
+		case roleTool:
+			if id, ok := msg["tool_call_id"].(string); ok && id != "" {
+				if _, matched := pending[id]; !matched {
+					dropped = true
+					continue
+				}
+				delete(pending, id)
+			}
+		}
+		filtered = append(filtered, raw)
+	}
+	return filtered, dropped, nil
+}
+
+// MinimaxOrphanToolMessageDropper drops role:"tool" messages on routes whose
+// tool messages carry no tool_call_id (e.g. MiniMax-M2.7). Orphan = tool
+// message appearing before any assistant.tool_calls[] block. The block stays
+// open across consecutive tool turns and resets on the next non-tool message.
+type MinimaxOrphanToolMessageDropper struct{}
+
+func (MinimaxOrphanToolMessageDropper) Apply(messages []any) ([]any, bool, error) {
+	inToolBlock := false
+	filtered := make([]any, 0, len(messages))
+	dropped := false
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			filtered = append(filtered, raw)
+			inToolBlock = false
+			continue
+		}
+		role, _ := msg["role"].(string)
+		switch role {
+		case roleAssistant:
+			inToolBlock = false
+			if calls, ok := msg["tool_calls"].([]any); ok && len(calls) > 0 {
+				inToolBlock = true
+			}
+		case roleTool:
+			if !inToolBlock {
+				dropped = true
+				continue
+			}
+		default:
+			inToolBlock = false
+		}
+		filtered = append(filtered, raw)
+	}
+	return filtered, dropped, nil
+}
+
+// EmptyAssistantTurnDropper drops role:"assistant" messages with no content
+// and no tool_calls / function_call — informationless placeholders left by
+// session-resume serializers.
+type EmptyAssistantTurnDropper struct{}
+
+func (EmptyAssistantTurnDropper) Apply(messages []any) ([]any, bool, error) {
+	filtered := make([]any, 0, len(messages))
+	dropped := false
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			filtered = append(filtered, raw)
+			continue
+		}
+		if role, _ := msg["role"].(string); role == roleAssistant && IsAssistantTurnEmpty(msg) {
+			dropped = true
+			continue
+		}
+		filtered = append(filtered, raw)
+	}
+	return filtered, dropped, nil
+}
+
+// EmptyContentNormalizer fills/normalizes content for special-case roles:
+//   - role:"tool" with missing, null, or empty content → ToolSentinel
+//   - role:"assistant" with empty content AND a tool_calls/function_call payload → null
+//
+// SkipRoles bypasses messages whose role is listed (e.g. MiniMax tool messages
+// carry array content with a non-OpenAI shape and must not be touched here).
+type EmptyContentNormalizer struct {
+	ToolSentinel string
+	SkipRoles    []string
+}
+
+func (n EmptyContentNormalizer) Apply(messages []any) ([]any, bool, error) {
+	changed := false
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		role, _ := msg["role"].(string)
+		if slices.Contains(n.SkipRoles, role) {
+			continue
+		}
+		content, exists := msg["content"]
+		switch {
+		case !exists, content == nil:
+			if role == roleTool {
+				msg["content"] = n.ToolSentinel
+				changed = true
+			}
+		case IsEmptyContent(content):
+			switch role {
+			case roleAssistant:
+				_, hasToolCalls := msg["tool_calls"]
+				_, hasFunctionCall := msg["function_call"]
+				if hasToolCalls || hasFunctionCall {
+					msg["content"] = nil
+					changed = true
+				}
+			case roleTool:
+				msg["content"] = n.ToolSentinel
+				changed = true
+			}
+		}
+	}
+	return messages, changed, nil
+}
+
+// LegacyToolNameStripper strips the legacy `name` field from role:"tool"
+// messages — an artifact of the old role:"function" API. Universal.
+type LegacyToolNameStripper struct{}
+
+func (LegacyToolNameStripper) Apply(messages []any) ([]any, bool, error) {
+	changed := false
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		role, _ := msg["role"].(string)
+		if role != roleTool {
+			continue
+		}
+		if _, exists := msg["name"]; !exists {
+			continue
+		}
+		delete(msg, "name")
+		changed = true
+	}
+	return messages, changed, nil
+}
+
+// MinimaxToolCallIDStripper silently strips tool_call_id from role:"tool"
+// messages. Clients dual-emitting tool_call_id for cross-route portability
+// keep working — MiniMax itself correlates tool results positionally.
+type MinimaxToolCallIDStripper struct{}
+
+func (MinimaxToolCallIDStripper) Apply(messages []any) ([]any, bool, error) {
+	changed := false
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		role, _ := msg["role"].(string)
+		if role != roleTool {
+			continue
+		}
+		if _, exists := msg["tool_call_id"]; exists {
+			delete(msg, "tool_call_id")
+			changed = true
+		}
+	}
+	return messages, changed, nil
+}
+
+// TextPartsFlattener combines a content array of {type:"text",text} parts into
+// a single newline-joined string. SkipRoles bypasses messages whose role is
+// listed (e.g. MiniMax tool messages keep their {name,type,text}[] shape).
+type TextPartsFlattener struct {
+	SkipRoles []string
+}
+
+func (n TextPartsFlattener) Apply(messages []any) ([]any, bool, error) {
+	changed := false
+	for index, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		role, _ := msg["role"].(string)
+		if slices.Contains(n.SkipRoles, role) {
+			continue
+		}
+		content, exists := msg["content"]
+		if !exists || content == nil {
+			continue
+		}
+		parts, ok := content.([]any)
+		if !ok {
+			continue
+		}
+		combined, err := CombineTextContentParts(parts)
+		if err != nil {
+			return nil, false, fmt.Errorf("messages[%d].content%w", index, err)
+		}
+		if combined != "" {
+			msg["content"] = combined
+			changed = true
+		}
+	}
+	return messages, changed, nil
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/normalizers_test.go b/devshard/cmd/devshardctl/messagevalidators/normalizers_test.go
new file mode 100644
index 0000000000..489a8635ea
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/normalizers_test.go
@@ -0,0 +1,379 @@
+package messagevalidators
+
+import (
+	"strings"
+	"testing"
+
+	"devshard/cmd/devshardctl/testutil"
+)
+
+// ============================================================
+// OrphanToolMessageDropper
+// ============================================================
+
+func TestOrphanToolMessageDropper_DropsToolWithUnmatchedID(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "content": "hi"},
+		map[string]any{"role": "tool", "tool_call_id": "nobody", "content": "stray"},
+		map[string]any{"role": "assistant", "content": "hello"},
+	}
+	out, changed, err := OrphanToolMessageDropper{}.Apply(msgs)
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if !changed {
+		t.Fatal("changed must be true when something is dropped")
+	}
+	if len(out) != 2 {
+		t.Fatalf("want 2 surviving messages, got %d", len(out))
+	}
+	if testutil.MapAt(t, out, 1)["role"] != "assistant" {
+		t.Fatal("orphan tool message must be dropped, assistant survives")
+	}
+}
+
+func TestOrphanToolMessageDropper_KeepsMatchedToolMessage(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "content": "q"},
+		map[string]any{"role": "assistant", "content": "", "tool_calls": []any{
+			map[string]any{"id": "c1", "type": "function", "function": map[string]any{"name": "fn"}},
+		}},
+		map[string]any{"role": "tool", "tool_call_id": "c1", "content": "result"},
+	}
+	out, changed, err := OrphanToolMessageDropper{}.Apply(msgs)
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if changed {
+		t.Fatal("nothing should change for a well-formed sequence")
+	}
+	if len(out) != 3 {
+		t.Fatalf("want 3 messages, got %d", len(out))
+	}
+}
+
+func TestOrphanToolMessageDropper_ConsumesPendingOnMatch(t *testing.T) {
+	// Same id appearing twice — second tool message is orphan because
+	// the first consumed the pending entry.
+	msgs := []any{
+		map[string]any{"role": "assistant", "content": "", "tool_calls": []any{
+			map[string]any{"id": "c1", "type": "function", "function": map[string]any{"name": "fn"}},
+		}},
+		map[string]any{"role": "tool", "tool_call_id": "c1", "content": "first"},
+		map[string]any{"role": "tool", "tool_call_id": "c1", "content": "second"},
+	}
+	out, changed, _ := OrphanToolMessageDropper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("must drop the second tool message")
+	}
+	if len(out) != 2 {
+		t.Fatalf("want 2 survivors, got %d", len(out))
+	}
+}
+
+// ============================================================
+// MinimaxOrphanToolMessageDropper
+// ============================================================
+
+func TestMinimaxOrphanToolMessageDropper_DropsToolBeforeAnyAssistant(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "content": "hi"},
+		map[string]any{"role": "tool", "content": []any{map[string]any{"name": "fn", "type": "text", "text": "x"}}},
+		map[string]any{"role": "assistant", "content": "hello"},
+	}
+	out, changed, _ := MinimaxOrphanToolMessageDropper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("orphan tool before assistant must be dropped")
+	}
+	if len(out) != 2 {
+		t.Fatalf("want 2 survivors, got %d", len(out))
+	}
+}
+
+func TestMinimaxOrphanToolMessageDropper_KeepsConsecutiveToolsInBlock(t *testing.T) {
+	// After assistant.tool_calls=[...], tool block stays open across all
+	// consecutive tool messages (parallel results).
+	msgs := []any{
+		map[string]any{"role": "user", "content": "q"},
+		map[string]any{"role": "assistant", "tool_calls": []any{
+			map[string]any{"id": "c1"}, map[string]any{"id": "c2"},
+		}},
+		map[string]any{"role": "tool", "content": []any{map[string]any{"name": "fn", "type": "text", "text": "r1"}}},
+		map[string]any{"role": "tool", "content": []any{map[string]any{"name": "fn", "type": "text", "text": "r2"}}},
+	}
+	out, changed, _ := MinimaxOrphanToolMessageDropper{}.Apply(msgs)
+	if changed {
+		t.Fatal("both tool messages are part of the block, no drops")
+	}
+	if len(out) != 4 {
+		t.Fatalf("want 4 messages preserved, got %d", len(out))
+	}
+}
+
+func TestMinimaxOrphanToolMessageDropper_NonToolMessageClosesBlock(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "assistant", "tool_calls": []any{map[string]any{"id": "c1"}}},
+		map[string]any{"role": "tool", "content": []any{map[string]any{"name": "fn", "type": "text", "text": "r"}}},
+		map[string]any{"role": "user", "content": "follow up"},
+		map[string]any{"role": "tool", "content": []any{map[string]any{"name": "fn", "type": "text", "text": "stray"}}},
+	}
+	out, changed, _ := MinimaxOrphanToolMessageDropper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("tool after user must be dropped")
+	}
+	if len(out) != 3 {
+		t.Fatalf("want 3 survivors (drop final orphan), got %d", len(out))
+	}
+}
+
+func TestMinimaxOrphanToolMessageDropper_EmptyToolCallsDoesNotOpenBlock(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "assistant", "content": "no tools", "tool_calls": []any{}},
+		map[string]any{"role": "tool", "content": []any{map[string]any{"name": "fn", "type": "text", "text": "x"}}},
+	}
+	out, changed, _ := MinimaxOrphanToolMessageDropper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("empty tool_calls does not open a block; tool is orphan")
+	}
+	if len(out) != 1 {
+		t.Fatalf("want 1 survivor, got %d", len(out))
+	}
+}
+
+// ============================================================
+// EmptyAssistantTurnDropper
+// ============================================================
+
+func TestEmptyAssistantTurnDropper(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "content": "hi"},
+		map[string]any{"role": "assistant"},                      // truly empty
+		map[string]any{"role": "assistant", "content": ""},       // empty string content
+		map[string]any{"role": "assistant", "content": "answer"}, // keep
+		map[string]any{"role": "user", "content": ""},            // user role NOT dropped here (validator job)
+		map[string]any{"role": "assistant", "tool_calls": []any{ // tool_calls makes it non-empty
+			map[string]any{"id": "c1"},
+		}},
+	}
+	out, changed, _ := EmptyAssistantTurnDropper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("must drop 2 empty assistant turns")
+	}
+	if len(out) != 4 {
+		t.Fatalf("want 4 survivors, got %d", len(out))
+	}
+	// Survivors: user[0], assistant[answer], user[empty], assistant[tool_calls]
+	roles := []string{}
+	for _, m := range out {
+		roles = append(roles, m.(map[string]any)["role"].(string))
+	}
+	got := strings.Join(roles, ",")
+	if got != "user,assistant,user,assistant" {
+		t.Fatalf("survivor roles: %q", got)
+	}
+}
+
+// ============================================================
+// EmptyContentNormalizer
+// ============================================================
+
+func TestEmptyContentNormalizer_FillsToolWithSentinel(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "tool", "tool_call_id": "c1"}, // missing content
+		map[string]any{"role": "tool", "tool_call_id": "c2", "content": nil},
+		map[string]any{"role": "tool", "tool_call_id": "c3", "content": ""},
+	}
+	_, changed, _ := EmptyContentNormalizer{ToolSentinel: "(no result)"}.Apply(msgs)
+	if !changed {
+		t.Fatal("must have rewritten all three tool messages")
+	}
+	for i, raw := range msgs {
+		m := raw.(map[string]any)
+		if m["content"] != "(no result)" {
+			t.Fatalf("[%d] want sentinel, got %v", i, m["content"])
+		}
+	}
+}
+
+func TestEmptyContentNormalizer_NullifiesAssistantWithCalls(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "assistant", "content": "", "tool_calls": []any{map[string]any{"id": "c1"}}},
+		map[string]any{"role": "assistant", "content": "", "function_call": map[string]any{"name": "fn"}},
+	}
+	_, changed, _ := EmptyContentNormalizer{ToolSentinel: "x"}.Apply(msgs)
+	if !changed {
+		t.Fatal("must nullify content on assistant turns with call payload")
+	}
+	for i, raw := range msgs {
+		m := raw.(map[string]any)
+		if m["content"] != nil {
+			t.Fatalf("[%d] want nil content, got %v", i, m["content"])
+		}
+	}
+}
+
+func TestEmptyContentNormalizer_LeavesAssistantWithoutCalls(t *testing.T) {
+	// Empty content on assistant turn WITHOUT call payload is left untouched —
+	// the validator will reject it as malformed. The normalizer must not paper
+	// over the bug by inventing content.
+	msg := map[string]any{"role": "assistant", "content": ""}
+	msgs := []any{msg}
+	_, changed, _ := EmptyContentNormalizer{ToolSentinel: "x"}.Apply(msgs)
+	if changed {
+		t.Fatal("must not touch assistant turn without call payload")
+	}
+	if msg["content"] != "" {
+		t.Fatalf("content must remain empty string, got %v", msg["content"])
+	}
+}
+
+func TestEmptyContentNormalizer_SkipRolesBypassesTool(t *testing.T) {
+	// MiniMax chain: tool messages carry array content with non-OpenAI shape.
+	// The normalizer must NOT replace it with the sentinel.
+	msg := map[string]any{"role": "tool", "content": []any{}}
+	msgs := []any{msg}
+	_, changed, _ := EmptyContentNormalizer{
+		ToolSentinel: "(no result)",
+		SkipRoles:    []string{"tool"},
+	}.Apply(msgs)
+	if changed {
+		t.Fatal("SkipRoles must bypass tool messages")
+	}
+	if _, ok := msg["content"].([]any); !ok {
+		t.Fatalf("tool content must remain array, got %T", msg["content"])
+	}
+}
+
+func TestEmptyContentNormalizer_LeavesUserRoleAlone(t *testing.T) {
+	// User role isn't a special case: empty content is the validator's
+	// concern, not the normalizer's.
+	msg := map[string]any{"role": "user", "content": ""}
+	msgs := []any{msg}
+	_, changed, _ := EmptyContentNormalizer{ToolSentinel: "x"}.Apply(msgs)
+	if changed {
+		t.Fatal("user role is not normalized")
+	}
+}
+
+// ============================================================
+// LegacyToolNameStripper
+// ============================================================
+
+func TestLegacyToolNameStripper(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "content": "hi", "name": "kept"},                          // not tool — name kept
+		map[string]any{"role": "tool", "tool_call_id": "c1", "content": "r", "name": "stripped"}, // tool — name stripped
+		map[string]any{"role": "tool", "tool_call_id": "c2", "content": "r"},                     // no name — no-op
+		map[string]any{"role": "assistant", "content": "x", "name": "assistant-name"},            // not tool — kept
+	}
+	_, changed, _ := LegacyToolNameStripper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("must strip name from one tool message")
+	}
+	if _, has := testutil.MapAt(t, msgs, 0)["name"]; !has {
+		t.Fatal("user.name must be preserved")
+	}
+	if _, has := testutil.MapAt(t, msgs, 1)["name"]; has {
+		t.Fatal("tool.name must be stripped")
+	}
+	if _, has := testutil.MapAt(t, msgs, 3)["name"]; !has {
+		t.Fatal("assistant.name must be preserved")
+	}
+}
+
+// ============================================================
+// MinimaxToolCallIDStripper
+// ============================================================
+
+func TestMinimaxToolCallIDStripper(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "tool_call_id": "weird-but-kept", "content": "hi"}, // not tool
+		map[string]any{"role": "tool", "tool_call_id": "c1", "content": []any{}},          // tool — stripped
+		map[string]any{"role": "tool", "content": []any{}},                                // tool no id — no-op
+	}
+	_, changed, _ := MinimaxToolCallIDStripper{}.Apply(msgs)
+	if !changed {
+		t.Fatal("must strip from one tool message")
+	}
+	if _, has := testutil.MapAt(t, msgs, 0)["tool_call_id"]; !has {
+		t.Fatal("non-tool role: tool_call_id preserved (validator's problem)")
+	}
+	if _, has := testutil.MapAt(t, msgs, 1)["tool_call_id"]; has {
+		t.Fatal("tool message: tool_call_id must be stripped")
+	}
+}
+
+// ============================================================
+// TextPartsFlattener
+// ============================================================
+
+func TestTextPartsFlattener_JoinsTextParts(t *testing.T) {
+	msg := map[string]any{
+		"role": "user",
+		"content": []any{
+			map[string]any{"type": "text", "text": "first"},
+			map[string]any{"type": "text", "text": "second"},
+		},
+	}
+	_, changed, err := TextPartsFlattener{}.Apply([]any{msg})
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if !changed {
+		t.Fatal("must have flattened content")
+	}
+	if msg["content"] != "first\nsecond" {
+		t.Fatalf("want 'first\\nsecond', got %v", msg["content"])
+	}
+}
+
+func TestTextPartsFlattener_LeavesStringAlone(t *testing.T) {
+	msg := map[string]any{"role": "user", "content": "already string"}
+	_, changed, _ := TextPartsFlattener{}.Apply([]any{msg})
+	if changed {
+		t.Fatal("string content must not trigger change")
+	}
+}
+
+func TestTextPartsFlattener_SkipRolesBypassesTool(t *testing.T) {
+	// MiniMax tool messages carry {name,type,text}[] arrays — must NOT be flattened.
+	msg := map[string]any{
+		"role": "tool",
+		"content": []any{
+			map[string]any{"name": "fn", "type": "text", "text": "result"},
+		},
+	}
+	_, changed, _ := TextPartsFlattener{SkipRoles: []string{"tool"}}.Apply([]any{msg})
+	if changed {
+		t.Fatal("SkipRoles must skip tool")
+	}
+	if _, ok := msg["content"].([]any); !ok {
+		t.Fatalf("tool content must remain array, got %T", msg["content"])
+	}
+}
+
+func TestTextPartsFlattener_ErrorIncludesMessageIndex(t *testing.T) {
+	msgs := []any{
+		map[string]any{"role": "user", "content": "ok"},
+		map[string]any{"role": "user", "content": []any{
+			map[string]any{"type": "image_url", "text": "x"},
+		}},
+	}
+	_, _, err := TextPartsFlattener{}.Apply(msgs)
+	if err == nil {
+		t.Fatal("want error from bad part")
+	}
+	if !strings.Contains(err.Error(), "messages[1].content") {
+		t.Fatalf("error must include messages[1].content, got %v", err)
+	}
+}
+
+func TestTextPartsFlattener_EmptyContentArrayLeftAlone(t *testing.T) {
+	// CombineTextContentParts returns "" for empty arrays; flattener treats
+	// "" as "no change" so the empty array is preserved (validator's call).
+	msg := map[string]any{"role": "user", "content": []any{}}
+	_, changed, _ := TextPartsFlattener{}.Apply([]any{msg})
+	if changed {
+		t.Fatal("empty content array must not be flattened to empty string")
+	}
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/toolcalls.go b/devshard/cmd/devshardctl/messagevalidators/toolcalls.go
new file mode 100644
index 0000000000..a2bc66bf14
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/toolcalls.go
@@ -0,0 +1,82 @@
+package messagevalidators
+
+import "fmt"
+
+// ValidateToolCallsField validates the message.tool_calls field and returns
+// (collected ids, hasField, error). A null tool_calls is treated as absent
+// and silently removed (some SDKs serialize empty slots that way). Errors
+// carry no `messages[%d]` prefix — the caller wraps them.
+func ValidateToolCallsField(message map[string]any) ([]string, bool, error) {
+	rawToolCalls, exists := message["tool_calls"]
+	if !exists {
+		return nil, false, nil
+	}
+	if rawToolCalls == nil {
+		delete(message, "tool_calls")
+		return nil, false, nil
+	}
+	toolCalls, ok := rawToolCalls.([]any)
+	if !ok {
+		return nil, true, fmt.Errorf("tool_calls must be an array")
+	}
+	if len(toolCalls) == 0 {
+		return nil, true, fmt.Errorf("tool_calls must not be empty")
+	}
+	seen := map[string]struct{}{}
+	ids := make([]string, 0, len(toolCalls))
+	for callIndex, rawCall := range toolCalls {
+		call, ok := rawCall.(map[string]any)
+		if !ok {
+			return nil, true, fmt.Errorf("tool_calls[%d] must be an object", callIndex)
+		}
+		id, err := RequiredNonEmptyString(call, "id")
+		if err != nil {
+			return nil, true, fmt.Errorf("tool_calls[%d].id: %w", callIndex, err)
+		}
+		if _, exists := seen[id]; exists {
+			return nil, true, fmt.Errorf("tool_calls[%d].id is duplicated", callIndex)
+		}
+		seen[id] = struct{}{}
+		callType, err := RequiredNonEmptyString(call, "type")
+		if err != nil {
+			return nil, true, fmt.Errorf("tool_calls[%d].type: %w", callIndex, err)
+		}
+		if callType != "function" {
+			return nil, true, fmt.Errorf("tool_calls[%d].type must be \"function\"", callIndex)
+		}
+		function, ok := call["function"].(map[string]any)
+		if !ok {
+			return nil, true, fmt.Errorf("tool_calls[%d].function must be an object", callIndex)
+		}
+		if _, err := RequiredNonEmptyString(function, "name"); err != nil {
+			return nil, true, fmt.Errorf("tool_calls[%d].function.name: %w", callIndex, err)
+		}
+		if err := OptionalStringField(function, "arguments"); err != nil {
+			return nil, true, fmt.Errorf("tool_calls[%d].function.arguments: %w", callIndex, err)
+		}
+		ids = append(ids, id)
+	}
+	return ids, true, nil
+}
+
+func ValidateFunctionCallField(message map[string]any) (bool, error) {
+	rawFunctionCall, exists := message["function_call"]
+	if !exists {
+		return false, nil
+	}
+	if rawFunctionCall == nil {
+		delete(message, "function_call")
+		return false, nil
+	}
+	functionCall, ok := rawFunctionCall.(map[string]any)
+	if !ok {
+		return true, fmt.Errorf("function_call must be an object")
+	}
+	if _, err := RequiredNonEmptyString(functionCall, "name"); err != nil {
+		return true, fmt.Errorf("function_call.name: %w", err)
+	}
+	if err := OptionalStringField(functionCall, "arguments"); err != nil {
+		return true, fmt.Errorf("function_call.arguments: %w", err)
+	}
+	return true, nil
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/toolcalls_test.go b/devshard/cmd/devshardctl/messagevalidators/toolcalls_test.go
new file mode 100644
index 0000000000..b63f7d5860
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/toolcalls_test.go
@@ -0,0 +1,202 @@
+package messagevalidators
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateToolCallsField_Absent(t *testing.T) {
+	msg := map[string]any{}
+	ids, has, err := ValidateToolCallsField(msg)
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if has {
+		t.Fatal("hasField must be false when field absent")
+	}
+	if ids != nil {
+		t.Fatalf("want nil ids, got %v", ids)
+	}
+}
+
+func TestValidateToolCallsField_NullTreatedAsAbsent(t *testing.T) {
+	// LangChain serializes empty slots as `null`; gateway silently drops it.
+	msg := map[string]any{"tool_calls": nil}
+	ids, has, err := ValidateToolCallsField(msg)
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if has {
+		t.Fatal("hasField must be false when value is null")
+	}
+	if _, stillThere := msg["tool_calls"]; stillThere {
+		t.Fatal("null tool_calls must be deleted from message")
+	}
+	if ids != nil {
+		t.Fatalf("want nil ids, got %v", ids)
+	}
+}
+
+func TestValidateToolCallsField_Happy(t *testing.T) {
+	msg := map[string]any{
+		"tool_calls": []any{
+			map[string]any{
+				"id":       "call_1",
+				"type":     "function",
+				"function": map[string]any{"name": "fn", "arguments": "{}"},
+			},
+			map[string]any{
+				"id":       "call_2",
+				"type":     "function",
+				"function": map[string]any{"name": "fn", "arguments": ""},
+			},
+		},
+	}
+	ids, has, err := ValidateToolCallsField(msg)
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if !has {
+		t.Fatal("hasField must be true")
+	}
+	if len(ids) != 2 || ids[0] != "call_1" || ids[1] != "call_2" {
+		t.Fatalf("want [call_1, call_2], got %v", ids)
+	}
+}
+
+func TestValidateToolCallsField_Errors(t *testing.T) {
+	cases := []struct {
+		name      string
+		msg       map[string]any
+		errSubstr string
+	}{
+		{
+			"not-array",
+			map[string]any{"tool_calls": "not-array"},
+			"tool_calls must be an array",
+		},
+		{
+			"empty-array",
+			map[string]any{"tool_calls": []any{}},
+			"tool_calls must not be empty",
+		},
+		{
+			"element-not-object",
+			map[string]any{"tool_calls": []any{"x"}},
+			"tool_calls[0] must be an object",
+		},
+		{
+			"missing-id",
+			map[string]any{"tool_calls": []any{
+				map[string]any{"type": "function", "function": map[string]any{"name": "fn"}},
+			}},
+			"tool_calls[0].id",
+		},
+		{
+			"duplicate-id",
+			map[string]any{"tool_calls": []any{
+				map[string]any{"id": "x", "type": "function", "function": map[string]any{"name": "fn"}},
+				map[string]any{"id": "x", "type": "function", "function": map[string]any{"name": "fn"}},
+			}},
+			"tool_calls[1].id is duplicated",
+		},
+		{
+			"wrong-type",
+			map[string]any{"tool_calls": []any{
+				map[string]any{"id": "x", "type": "code_interpreter", "function": map[string]any{"name": "fn"}},
+			}},
+			"tool_calls[0].type",
+		},
+		{
+			"function-not-object",
+			map[string]any{"tool_calls": []any{
+				map[string]any{"id": "x", "type": "function", "function": "not-object"},
+			}},
+			"tool_calls[0].function must be an object",
+		},
+		{
+			"function-missing-name",
+			map[string]any{"tool_calls": []any{
+				map[string]any{"id": "x", "type": "function", "function": map[string]any{}},
+			}},
+			"tool_calls[0].function.name",
+		},
+		{
+			"function-arguments-not-string",
+			map[string]any{"tool_calls": []any{
+				map[string]any{"id": "x", "type": "function", "function": map[string]any{"name": "fn", "arguments": 42}},
+			}},
+			"tool_calls[0].function.arguments",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, _, err := ValidateToolCallsField(tc.msg)
+			if err == nil {
+				t.Fatalf("want error containing %q, got nil", tc.errSubstr)
+			}
+			if !strings.Contains(err.Error(), tc.errSubstr) {
+				t.Fatalf("want error containing %q, got %q", tc.errSubstr, err.Error())
+			}
+		})
+	}
+}
+
+func TestValidateFunctionCallField_Absent(t *testing.T) {
+	has, err := ValidateFunctionCallField(map[string]any{})
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if has {
+		t.Fatal("hasField must be false")
+	}
+}
+
+func TestValidateFunctionCallField_NullTreatedAsAbsent(t *testing.T) {
+	msg := map[string]any{"function_call": nil}
+	has, err := ValidateFunctionCallField(msg)
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if has {
+		t.Fatal("hasField must be false")
+	}
+	if _, stillThere := msg["function_call"]; stillThere {
+		t.Fatal("null function_call must be deleted")
+	}
+}
+
+func TestValidateFunctionCallField_Happy(t *testing.T) {
+	has, err := ValidateFunctionCallField(map[string]any{
+		"function_call": map[string]any{"name": "fn", "arguments": "{}"},
+	})
+	if err != nil {
+		t.Fatalf("want no error, got %v", err)
+	}
+	if !has {
+		t.Fatal("hasField must be true")
+	}
+}
+
+func TestValidateFunctionCallField_Errors(t *testing.T) {
+	cases := []struct {
+		name      string
+		msg       map[string]any
+		errSubstr string
+	}{
+		{"not-object", map[string]any{"function_call": "x"}, "function_call must be an object"},
+		{"missing-name", map[string]any{"function_call": map[string]any{}}, "function_call.name"},
+		{"args-not-string", map[string]any{"function_call": map[string]any{"name": "fn", "arguments": 42}}, "function_call.arguments"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := ValidateFunctionCallField(tc.msg)
+			if err == nil {
+				t.Fatalf("want error containing %q, got nil", tc.errSubstr)
+			}
+			if !strings.Contains(err.Error(), tc.errSubstr) {
+				t.Fatalf("want error containing %q, got %q", tc.errSubstr, err.Error())
+			}
+		})
+	}
+}
diff --git a/devshard/cmd/devshardctl/messagevalidators/types.go b/devshard/cmd/devshardctl/messagevalidators/types.go
new file mode 100644
index 0000000000..cbcfc0ad7a
--- /dev/null
+++ b/devshard/cmd/devshardctl/messagevalidators/types.go
@@ -0,0 +1,14 @@
+// Package messagevalidators holds leaf-level shape/bounds validators for
+// per-message content. It mirrors paramvalidators (which validates top-level
+// request fields). Validators are model-agnostic — per-model dispatch happens
+// upstream in ChatMessageProcessor's role-policy catalog, which picks which
+// validator (if any) to call for a given (route, role) pair.
+package messagevalidators
+
+// ContentValidator validates the value of a single message's `content` field.
+// Implementations are pure: they do not mutate the message and do not have
+// access to cross-message state. Cross-message correlation (e.g. tool_call_id
+// matching) is handled by ChatMessageProcessor's per-role policy, not here.
+type ContentValidator interface {
+	Validate(content any) error
+}
diff --git a/devshard/cmd/devshardctl/metrics.go b/devshard/cmd/devshardctl/metrics.go
index 091a90e031..e972540502 100644
--- a/devshard/cmd/devshardctl/metrics.go
+++ b/devshard/cmd/devshardctl/metrics.go
@@ -1,7 +1,11 @@
 package main
 
 import (
+	"context"
+	"errors"
+	"io"
 	"net/http"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -30,6 +34,63 @@ type DevshardMetrics struct {
 	hostFirstTokenSeconds      *prometheus.HistogramVec
 	hostCTTFLSecondsPerToken   *prometheus.HistogramVec
 	hostTotalSeconds           *prometheus.HistogramVec
+	participantReceiptSeconds  *prometheus.HistogramVec
+	participantFirstContent    *prometheus.HistogramVec
+	participantPrefillPerToken *prometheus.HistogramVec
+	participantTotalSeconds    *prometheus.HistogramVec
+
+	gatewayRequests       *prometheus.CounterVec
+	criticalUserFailures  *prometheus.CounterVec
+	hiddenFailures        *prometheus.CounterVec
+	userVisibleWins       *prometheus.CounterVec
+	slotDecisions         *prometheus.CounterVec
+	attemptsStarted       *prometheus.CounterVec
+	attemptsTerminal      *prometheus.CounterVec
+	attemptFailures       *prometheus.CounterVec
+	quarantineTransitions *prometheus.CounterVec
+	noWinnerAttempts      *prometheus.CounterVec
+	timeoutActions        *prometheus.CounterVec
+}
+
+type GatewaySlotDecisionMetric struct {
+	ParticipantKey string
+	Model          string
+	EscrowID       string
+	Decision       string
+	Reason         string
+	QuarantineMode string
+}
+
+type GatewayAttemptStartMetric struct {
+	ParticipantKey string
+	Model          string
+	Role           string
+	Reason         string
+	QuarantineMode string
+}
+
+type GatewayAttemptTerminalMetric struct {
+	ParticipantKey string
+	Model          string
+	Role           string
+	Outcome        string
+	Visibility     string
+}
+
+type GatewayAttemptFailureMetric struct {
+	ParticipantKey string
+	Model          string
+	Role           string
+	Reason         string
+	Visibility     string
+}
+
+type GatewayTimeoutActionMetric struct {
+	ParticipantKey string
+	Model          string
+	Kind           string
+	Action         string
+	Reason         string
 }
 
 func NewDevshardMetrics() *DevshardMetrics {
@@ -66,16 +127,16 @@ func NewDevshardMetrics() *DevshardMetrics {
 		participantLimitRejections: prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Name: "devshard_gateway_participant_limit_rejections_total",
-				Help: "Total participant-budget rejections by routing scope.",
+				Help: "Total participant-budget rejections by participant, model, and routing scope.",
 			},
-			[]string{"scope"},
+			[]string{"participant_key", "model", "scope"},
 		),
 		participantTransportErrors: prometheus.NewCounterVec(
 			prometheus.CounterOpts{
 				Name: "devshard_gateway_participant_transport_errors_total",
-				Help: "Total participant-bound transport request errors by request kind and upstream status.",
+				Help: "Total participant-bound transport request errors by participant, model, request kind, and upstream status.",
 			},
-			[]string{"path_kind", "status"},
+			[]string{"participant_key", "model", "path_kind", "status"},
 		),
 		speculativeDecisions: prometheus.NewCounterVec(
 			prometheus.CounterOpts{
@@ -137,6 +198,115 @@ func NewDevshardMetrics() *DevshardMetrics {
 			},
 			[]string{"devshard_id", "host_idx"},
 		),
+		participantReceiptSeconds: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Name:    "devshard_gateway_participant_receipt_seconds",
+				Help:    "Time from gateway inference send until receipt confirmation by participant and model.",
+				Buckets: prometheus.ExponentialBuckets(0.01, 2, 12),
+			},
+			[]string{"participant_key", "model"},
+		),
+		participantFirstContent: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Name:    "devshard_gateway_participant_first_content_seconds",
+				Help:    "Time from gateway inference send until first content by participant and model.",
+				Buckets: prometheus.ExponentialBuckets(0.01, 2, 12),
+			},
+			[]string{"participant_key", "model"},
+		),
+		participantPrefillPerToken: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Name:    "devshard_gateway_participant_prefill_seconds_per_input_token",
+				Help:    "Time from receipt until first content divided by input tokens, by participant and model.",
+				Buckets: prometheus.ExponentialBuckets(0.0001, 2, 12),
+			},
+			[]string{"participant_key", "model"},
+		),
+		participantTotalSeconds: prometheus.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Name:    "devshard_gateway_participant_total_attempt_seconds",
+				Help:    "Total inference attempt time observed by the gateway, by participant and model.",
+				Buckets: prometheus.ExponentialBuckets(0.01, 2, 12),
+			},
+			[]string{"participant_key", "model"},
+		),
+		gatewayRequests: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_requests_total",
+				Help: "Total gateway chat requests by model, user-visible outcome, and bounded reason.",
+			},
+			[]string{"model", "outcome", "reason"},
+		),
+		criticalUserFailures: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_critical_user_failures_total",
+				Help: "Total critical user-visible gateway failures by model and bounded reason.",
+			},
+			[]string{"model", "reason"},
+		),
+		hiddenFailures: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_user_requests_with_hidden_failure_total",
+				Help: "Total successful user requests that hid gateway-visible participant or policy failures.",
+			},
+			[]string{"model", "severity", "reason"},
+		),
+		userVisibleWins: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_user_visible_wins_total",
+				Help: "Total user-visible winning responses by participant and model.",
+			},
+			[]string{"participant_key", "model"},
+		),
+		slotDecisions: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_slot_decisions_total",
+				Help: "Total gateway slot decisions by participant, model, escrow, decision, reason, and quarantine mode.",
+			},
+			[]string{"participant_key", "model", "escrow_id", "decision", "reason", "quarantine_mode"},
+		),
+		attemptsStarted: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_attempts_started_total",
+				Help: "Total real gateway attempts started by participant, model, role, reason, and quarantine mode.",
+			},
+			[]string{"participant_key", "model", "role", "reason", "quarantine_mode"},
+		),
+		attemptsTerminal: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_attempts_terminal_total",
+				Help: "Total real gateway attempts by terminal outcome and visibility.",
+			},
+			[]string{"participant_key", "model", "role", "outcome", "visibility"},
+		),
+		attemptFailures: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_attempt_failures_total",
+				Help: "Total failed real gateway attempts by bounded failure reason and visibility.",
+			},
+			[]string{"participant_key", "model", "role", "reason", "visibility"},
+		),
+		quarantineTransitions: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_participant_quarantine_transitions_total",
+				Help: "Total participant quarantine and no-winner state transitions by participant, model, mode, and reason.",
+			},
+			[]string{"participant_key", "model", "mode", "reason"},
+		),
+		noWinnerAttempts: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_no_winner_attempts_total",
+				Help: "Total real no-winner attempts by participant, model, reason, and quarantine mode.",
+			},
+			[]string{"participant_key", "model", "reason", "quarantine_mode"},
+		),
+		timeoutActions: prometheus.NewCounterVec(
+			prometheus.CounterOpts{
+				Name: "devshard_gateway_timeout_actions_total",
+				Help: "Total gateway timeout actions by participant, model, timeout kind, action, and reason.",
+			},
+			[]string{"participant_key", "model", "kind", "action", "reason"},
+		),
 	}
 
 	registry.MustRegister(
@@ -153,6 +323,21 @@ func NewDevshardMetrics() *DevshardMetrics {
 		m.hostFirstTokenSeconds,
 		m.hostCTTFLSecondsPerToken,
 		m.hostTotalSeconds,
+		m.participantReceiptSeconds,
+		m.participantFirstContent,
+		m.participantPrefillPerToken,
+		m.participantTotalSeconds,
+		m.gatewayRequests,
+		m.criticalUserFailures,
+		m.hiddenFailures,
+		m.userVisibleWins,
+		m.slotDecisions,
+		m.attemptsStarted,
+		m.attemptsTerminal,
+		m.attemptFailures,
+		m.quarantineTransitions,
+		m.noWinnerAttempts,
+		m.timeoutActions,
 	)
 
 	m.handler = promhttp.HandlerFor(registry, promhttp.HandlerOpts{})
@@ -202,18 +387,27 @@ func (m *DevshardMetrics) RecordLimitRejection(reason string) {
 	m.gatewayLimitRejections.WithLabelValues(reason).Inc()
 }
 
-func (m *DevshardMetrics) RecordParticipantLimitRejection(scope string) {
+func (m *DevshardMetrics) RecordParticipantLimitRejection(participantKey, model, scope string) {
 	if m == nil {
 		return
 	}
-	m.participantLimitRejections.WithLabelValues(scope).Inc()
+	m.participantLimitRejections.WithLabelValues(
+		metricLabel(participantKey, "unknown"),
+		metricLabel(model, "unknown"),
+		metricLabel(scope, "unknown"),
+	).Inc()
 }
 
-func (m *DevshardMetrics) RecordParticipantTransportError(pathKind string, statusCode int) {
+func (m *DevshardMetrics) RecordParticipantTransportError(participantKey, model, pathKind string, statusCode int) {
 	if m == nil {
 		return
 	}
-	m.participantTransportErrors.WithLabelValues(pathKind, strconv.Itoa(statusCode)).Inc()
+	m.participantTransportErrors.WithLabelValues(
+		metricLabel(participantKey, "unknown"),
+		metricLabel(model, "unknown"),
+		metricLabel(pathKind, "unknown"),
+		strconv.Itoa(statusCode),
+	).Inc()
 }
 
 func (m *DevshardMetrics) RecordSpeculativeDecision(reason string) {
@@ -244,47 +438,190 @@ func (m *DevshardMetrics) RecordPickerChoice(devshardID, model string) {
 	m.pickerChoices.WithLabelValues(devshardID, model).Inc()
 }
 
+func (m *DevshardMetrics) RecordGatewayRequest(model, outcome, reason string) {
+	if m == nil {
+		return
+	}
+	m.gatewayRequests.WithLabelValues(metricLabel(model, "unknown"), metricLabel(outcome, "unknown"), metricLabel(reason, "none")).Inc()
+}
+
+func (m *DevshardMetrics) RecordCriticalUserFailure(model, reason string) {
+	if m == nil {
+		return
+	}
+	m.criticalUserFailures.WithLabelValues(metricLabel(model, "unknown"), metricLabel(reason, "unknown")).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayHiddenFailure(model, severity, reason string) {
+	if m == nil {
+		return
+	}
+	m.hiddenFailures.WithLabelValues(metricLabel(model, "unknown"), metricLabel(severity, "unknown"), metricLabel(reason, "unknown")).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayUserVisibleWin(participantKey, model string) {
+	if m == nil {
+		return
+	}
+	m.userVisibleWins.WithLabelValues(metricLabel(participantKey, "unknown"), metricLabel(model, "unknown")).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewaySlotDecision(decision GatewaySlotDecisionMetric) {
+	if m == nil {
+		return
+	}
+	m.slotDecisions.WithLabelValues(
+		metricLabel(decision.ParticipantKey, "unknown"),
+		metricLabel(decision.Model, "unknown"),
+		metricLabel(decision.EscrowID, "unknown"),
+		metricLabel(decision.Decision, "unknown"),
+		metricLabel(decision.Reason, "unknown"),
+		metricLabel(decision.QuarantineMode, "none"),
+	).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayAttemptStarted(start GatewayAttemptStartMetric) {
+	if m == nil {
+		return
+	}
+	m.attemptsStarted.WithLabelValues(
+		metricLabel(start.ParticipantKey, "unknown"),
+		metricLabel(start.Model, "unknown"),
+		metricLabel(start.Role, "unknown"),
+		metricLabel(start.Reason, "none"),
+		metricLabel(start.QuarantineMode, "none"),
+	).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayAttemptTerminal(terminal GatewayAttemptTerminalMetric) {
+	if m == nil {
+		return
+	}
+	m.attemptsTerminal.WithLabelValues(
+		metricLabel(terminal.ParticipantKey, "unknown"),
+		metricLabel(terminal.Model, "unknown"),
+		metricLabel(terminal.Role, "unknown"),
+		metricLabel(terminal.Outcome, "unknown"),
+		metricLabel(terminal.Visibility, "unknown"),
+	).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayAttemptFailure(failure GatewayAttemptFailureMetric) {
+	if m == nil {
+		return
+	}
+	m.attemptFailures.WithLabelValues(
+		metricLabel(failure.ParticipantKey, "unknown"),
+		metricLabel(failure.Model, "unknown"),
+		metricLabel(failure.Role, "unknown"),
+		metricLabel(failure.Reason, "unknown"),
+		metricLabel(failure.Visibility, "unknown"),
+	).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayQuarantineTransition(participantKey, model, mode, reason string) {
+	if m == nil {
+		return
+	}
+	m.quarantineTransitions.WithLabelValues(
+		metricLabel(participantKey, "unknown"),
+		metricLabel(model, "all"),
+		metricLabel(mode, "none"),
+		metricLabel(reason, "unknown"),
+	).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayNoWinnerAttempt(participantKey, model, reason, quarantineMode string) {
+	if m == nil {
+		return
+	}
+	m.noWinnerAttempts.WithLabelValues(
+		metricLabel(participantKey, "unknown"),
+		metricLabel(model, "unknown"),
+		metricLabel(reason, "unknown"),
+		metricLabel(quarantineMode, "none"),
+	).Inc()
+}
+
+func (m *DevshardMetrics) RecordGatewayTimeoutAction(action GatewayTimeoutActionMetric) {
+	if m == nil {
+		return
+	}
+	m.timeoutActions.WithLabelValues(
+		metricLabel(action.ParticipantKey, "unknown"),
+		metricLabel(action.Model, "unknown"),
+		metricLabel(action.Kind, "unknown"),
+		metricLabel(action.Action, "unknown"),
+		metricLabel(action.Reason, "none"),
+	).Inc()
+}
+
 func (m *DevshardMetrics) ObserveRequestSample(devshardID string, sample RequestSample) {
 	if m == nil {
 		return
 	}
 
 	labels := []string{devshardID, strconv.Itoa(sample.HostIdx)}
+	participantLabels := []string{
+		metricLabel(sample.ParticipantKey, "unknown"),
+		metricLabel(sample.Model, "unknown"),
+	}
 	if receiptSeconds := sample.ReceiptMs() / 1000; receiptSeconds > 0 {
 		m.hostReceiptSeconds.WithLabelValues(labels...).Observe(receiptSeconds)
+		m.participantReceiptSeconds.WithLabelValues(participantLabels...).Observe(receiptSeconds)
 	}
 	if !sample.SendTime.IsZero() && !sample.FirstToken.IsZero() {
-		m.hostFirstTokenSeconds.WithLabelValues(labels...).Observe(sample.FirstToken.Sub(sample.SendTime).Seconds())
+		firstContentSeconds := sample.FirstToken.Sub(sample.SendTime).Seconds()
+		m.hostFirstTokenSeconds.WithLabelValues(labels...).Observe(firstContentSeconds)
+		m.participantFirstContent.WithLabelValues(participantLabels...).Observe(firstContentSeconds)
 	}
 	if cttfl := sample.CTTFL() / 1000; cttfl > 0 {
 		m.hostCTTFLSecondsPerToken.WithLabelValues(labels...).Observe(cttfl)
+		m.participantPrefillPerToken.WithLabelValues(participantLabels...).Observe(cttfl)
 	}
 	if sample.TotalTime > 0 {
 		m.hostTotalSeconds.WithLabelValues(labels...).Observe(sample.TotalTime.Seconds())
+		m.participantTotalSeconds.WithLabelValues(participantLabels...).Observe(sample.TotalTime.Seconds())
 	}
 }
 
+func metricLabel(value, fallback string) string {
+	value = strings.TrimSpace(value)
+	if value != "" {
+		return value
+	}
+	fallback = strings.TrimSpace(fallback)
+	if fallback != "" {
+		return fallback
+	}
+	return "unknown"
+}
+
 type gatewayMetricsCollector struct {
 	gateway         *Gateway
 	hostConnections hostConnectionSnapshotter
 
-	inflightRequestsDesc          *prometheus.Desc
-	inflightTokensDesc            *prometheus.Desc
-	effectiveMaxConcurrentDesc    *prometheus.Desc
-	effectiveMaxInputTokensDesc   *prometheus.Desc
-	capacityScaleDesc             *prometheus.Desc
-	capacityTotalDesc             *prometheus.Desc
-	capacityBaselineDesc          *prometheus.Desc
-	escrowWeightDesc              *prometheus.Desc
-	runtimeActiveDesc             *prometheus.Desc
-	runtimeRequestsDesc           *prometheus.Desc
-	runtimeReservedDesc           *prometheus.Desc
-	participantExhaustedDesc      *prometheus.Desc
-	participantTrackedDesc        *prometheus.Desc
-	escrowParticipantLimitedDesc  *prometheus.Desc
-	escrowBlockedParticipantsDesc *prometheus.Desc
-	hostOpenDesc                  *prometheus.Desc
-	hostStateDesc                 *prometheus.Desc
+	inflightRequestsDesc           *prometheus.Desc
+	inflightTokensDesc             *prometheus.Desc
+	effectiveMaxConcurrentDesc     *prometheus.Desc
+	effectiveMaxInputTokensDesc    *prometheus.Desc
+	capacityScaleDesc              *prometheus.Desc
+	capacityTotalDesc              *prometheus.Desc
+	capacityBaselineDesc           *prometheus.Desc
+	capacityScaleByModelDesc       *prometheus.Desc
+	capacityTotalByModelDesc       *prometheus.Desc
+	capacityBaselineByModelDesc    *prometheus.Desc
+	escrowWeightDesc               *prometheus.Desc
+	runtimeActiveDesc              *prometheus.Desc
+	runtimeRequestsDesc            *prometheus.Desc
+	runtimeReservedDesc            *prometheus.Desc
+	participantExhaustedDesc       *prometheus.Desc
+	participantTrackedDesc         *prometheus.Desc
+	participantQuarantineStateDesc *prometheus.Desc
+	escrowParticipantLimitedDesc   *prometheus.Desc
+	escrowBlockedParticipantsDesc  *prometheus.Desc
+	hostOpenDesc                   *prometheus.Desc
+	hostStateDesc                  *prometheus.Desc
 }
 
 func newGatewayMetricsCollector(gateway *Gateway) *gatewayMetricsCollector {
@@ -341,6 +678,24 @@ func newGatewayMetricsCollectorWithHostConnections(gateway *Gateway, hostConnect
 			nil,
 			nil,
 		),
+		capacityScaleByModelDesc: prometheus.NewDesc(
+			"devshard_gateway_capacity_scale_by_model",
+			"Ratio W_tot(model) / W_ref(model) for each model (1.0 = full model capacity).",
+			[]string{"model"},
+			nil,
+		),
+		capacityTotalByModelDesc: prometheus.NewDesc(
+			"devshard_gateway_capacity_total_weight_by_model",
+			"Current gateway-wide effective host weight (W_tot) for each model.",
+			[]string{"model"},
+			nil,
+		),
+		capacityBaselineByModelDesc: prometheus.NewDesc(
+			"devshard_gateway_capacity_baseline_weight_by_model",
+			"Baseline gateway-wide host weight (W_ref) for each model.",
+			[]string{"model"},
+			nil,
+		),
 		escrowWeightDesc: prometheus.NewDesc(
 			"devshard_gateway_escrow_weight",
 			"Per-escrow effective weight W(e) used by the capacity-aware picker.",
@@ -377,6 +732,12 @@ func newGatewayMetricsCollectorWithHostConnections(gateway *Gateway, hostConnect
 			nil,
 			nil,
 		),
+		participantQuarantineStateDesc: prometheus.NewDesc(
+			"devshard_gateway_participant_quarantine_state",
+			"Current participant quarantine or no-winner state by participant and model.",
+			[]string{"participant_key", "model", "mode"},
+			nil,
+		),
 		escrowParticipantLimitedDesc: prometheus.NewDesc(
 			"devshard_gateway_escrow_participant_limited",
 			"Whether an escrow is currently blocked by at least one participant budget.",
@@ -412,12 +773,16 @@ func (c *gatewayMetricsCollector) Describe(ch chan<- *prometheus.Desc) {
 	ch <- c.capacityScaleDesc
 	ch <- c.capacityTotalDesc
 	ch <- c.capacityBaselineDesc
+	ch <- c.capacityScaleByModelDesc
+	ch <- c.capacityTotalByModelDesc
+	ch <- c.capacityBaselineByModelDesc
 	ch <- c.escrowWeightDesc
 	ch <- c.runtimeActiveDesc
 	ch <- c.runtimeRequestsDesc
 	ch <- c.runtimeReservedDesc
 	ch <- c.participantExhaustedDesc
 	ch <- c.participantTrackedDesc
+	ch <- c.participantQuarantineStateDesc
 	ch <- c.escrowParticipantLimitedDesc
 	ch <- c.escrowBlockedParticipantsDesc
 	ch <- c.hostOpenDesc
@@ -429,6 +794,10 @@ func (c *gatewayMetricsCollector) Collect(ch chan<- prometheus.Metric) {
 		return
 	}
 
+	c.gateway.mu.Lock()
+	runtimes := append([]*devshardRuntime(nil), c.gateway.runtimeOrder...)
+	c.gateway.mu.Unlock()
+
 	if c.gateway.limiter != nil {
 		snapshot := c.gateway.limiter.Snapshot()
 		ch <- prometheus.MustNewConstMetric(c.inflightRequestsDesc, prometheus.GaugeValue, float64(snapshot.InFlightRequests))
@@ -444,6 +813,11 @@ func (c *gatewayMetricsCollector) Collect(ch chan<- prometheus.Metric) {
 		for id, w := range capSnap.EscrowWeights {
 			ch <- prometheus.MustNewConstMetric(c.escrowWeightDesc, prometheus.GaugeValue, w, id)
 		}
+		for _, model := range capacityMetricModels(c.gateway.capacity, runtimes) {
+			ch <- prometheus.MustNewConstMetric(c.capacityScaleByModelDesc, prometheus.GaugeValue, c.gateway.capacity.ScaleFactorForModel(model), model)
+			ch <- prometheus.MustNewConstMetric(c.capacityTotalByModelDesc, prometheus.GaugeValue, c.gateway.capacity.TotalWeightForModel(model), model)
+			ch <- prometheus.MustNewConstMetric(c.capacityBaselineByModelDesc, prometheus.GaugeValue, c.gateway.capacity.BaselineWeightForModel(model), model)
+		}
 	}
 	if c.gateway.participantLimiter != nil {
 		ch <- prometheus.MustNewConstMetric(
@@ -458,9 +832,7 @@ func (c *gatewayMetricsCollector) Collect(ch chan<- prometheus.Metric) {
 		)
 	}
 
-	c.gateway.mu.Lock()
-	runtimes := append([]*devshardRuntime(nil), c.gateway.runtimeOrder...)
-	c.gateway.mu.Unlock()
+	emittedParticipantStates := make(map[string]struct{})
 	for _, rt := range runtimes {
 		active := 0.0
 		if rt.active.Load() {
@@ -468,11 +840,31 @@ func (c *gatewayMetricsCollector) Collect(ch chan<- prometheus.Metric) {
 		}
 		labels := []string{rt.id, rt.model}
 		ch <- prometheus.MustNewConstMetric(c.runtimeActiveDesc, prometheus.GaugeValue, active, labels...)
-		ch <- prometheus.MustNewConstMetric(c.runtimeRequestsDesc, prometheus.GaugeValue, float64(rt.activeRequests.Load()), labels...)
+		ch <- prometheus.MustNewConstMetric(c.runtimeRequestsDesc, prometheus.GaugeValue, float64(rt.activeUserRequests.Load()), labels...)
 		ch <- prometheus.MustNewConstMetric(c.runtimeReservedDesc, prometheus.GaugeValue, float64(rt.reservedTokens.Load()), labels...)
 		blocked := 0
 		if c.gateway.participantLimiter != nil {
 			blocked = len(c.gateway.participantLimiter.BlockedParticipants(rt.participantKeys))
+			for participantKey, snapshot := range c.gateway.participantLimiter.Snapshot(rt.participantKeys) {
+				if !participantSnapshotAppliesToModel(snapshot, rt.model) {
+					continue
+				}
+				model := metricLabel(rt.model, "unknown")
+				mode := participantSnapshotMode(snapshot)
+				stateKey := participantKey + "\x00" + model + "\x00" + mode
+				if _, ok := emittedParticipantStates[stateKey]; ok {
+					continue
+				}
+				emittedParticipantStates[stateKey] = struct{}{}
+				ch <- prometheus.MustNewConstMetric(
+					c.participantQuarantineStateDesc,
+					prometheus.GaugeValue,
+					1,
+					participantKey,
+					model,
+					mode,
+				)
+			}
 		}
 		limited := 0.0
 		if blocked > 0 {
@@ -493,6 +885,138 @@ func (c *gatewayMetricsCollector) Collect(ch chan<- prometheus.Metric) {
 	}
 }
 
+func participantSnapshotAppliesToModel(snapshot ParticipantThrottleSnapshot, model string) bool {
+	if len(snapshot.ModelIDs) == 0 {
+		return true
+	}
+	model = normalizeModelID(model)
+	if model == "" {
+		return true
+	}
+	for _, modelID := range snapshot.ModelIDs {
+		if normalizeModelID(modelID) == model {
+			return true
+		}
+	}
+	return false
+}
+
+func capacityMetricModels(capacity *CapacityState, runtimes []*devshardRuntime) []string {
+	seen := make(map[string]struct{})
+	if capacity != nil {
+		for _, model := range capacity.Models() {
+			model = strings.TrimSpace(model)
+			if model != "" {
+				seen[model] = struct{}{}
+			}
+		}
+	}
+	for _, rt := range runtimes {
+		if rt == nil {
+			continue
+		}
+		model := strings.TrimSpace(rt.model)
+		if model != "" {
+			seen[model] = struct{}{}
+		}
+	}
+	models := make([]string, 0, len(seen))
+	for model := range seen {
+		models = append(models, model)
+	}
+	sort.Strings(models)
+	return models
+}
+
+func participantSnapshotMode(snapshot ParticipantThrottleSnapshot) string {
+	switch {
+	case snapshot.ProbeQuarantined:
+		return "probe"
+	case snapshot.ShadowQuarantined:
+		return "shadow"
+	case snapshot.Probationary:
+		return "probation"
+	default:
+		return "none"
+	}
+}
+
+type nonceFinishedChecker interface {
+	IsNonceFinished(uint64) bool
+}
+
+func gatewayAttemptFailureReason(inf *inflight, session nonceFinishedChecker) string {
+	if inf == nil {
+		return "unknown"
+	}
+	switch {
+	case inf.phaseTransitionAborted:
+		return "phase_transition_aborted"
+	case isErrorStreamAttempt(inf):
+		return "error_stream"
+	case isEmptyStreamAttempt(inf):
+		return "empty_stream"
+	}
+	if inf.err != nil {
+		var upstreamErr *transport.UpstreamStatusError
+		switch {
+		case errors.As(inf.err, &upstreamErr):
+			return gatewayHTTPFailureReason(upstreamErr.StatusCode)
+		case errors.Is(inf.err, transport.ErrSSEStreamTruncated):
+			return "sse_truncated"
+		case errors.Is(inf.err, io.EOF), errors.Is(inf.err, io.ErrUnexpectedEOF), strings.Contains(strings.ToLower(inf.err.Error()), "eof"):
+			return "eof_transport"
+		case errors.Is(inf.err, context.Canceled), errors.Is(inf.err, context.DeadlineExceeded):
+			return "client_cancelled"
+		default:
+			return "transport_error"
+		}
+	}
+	if inf.receiptTime.IsZero() {
+		return "no_receipt"
+	}
+	if session != nil && !session.IsNonceFinished(inf.nonce) {
+		return "not_finished"
+	}
+	return "unknown"
+}
+
+func gatewayHTTPFailureReason(statusCode int) string {
+	switch statusCode {
+	case http.StatusTooManyRequests:
+		return "http_429"
+	case http.StatusServiceUnavailable:
+		return "http_503"
+	case http.StatusForbidden:
+		return "http_forbidden"
+	case http.StatusNotFound:
+		return "http_not_found"
+	case http.StatusUnauthorized:
+		return "http_timestamp_drift"
+	default:
+		if statusCode >= 400 {
+			return "http_error"
+		}
+		return "transport_error"
+	}
+}
+
+func gatewayAttemptVisibility(inf *inflight, winnerNonce uint64, successful bool) string {
+	if inf == nil {
+		return "unknown"
+	}
+	if inf.suspicious {
+		return "no_winner"
+	}
+	if successful && winnerNonce != 0 && inf.nonce == winnerNonce {
+		return "user_visible_winner"
+	}
+	if successful {
+		return "suppressed_loser"
+	}
+	return "failed_not_finished"
+}
+
 type metricsResponseWriter struct {
 	http.ResponseWriter
 	status int
diff --git a/devshard/cmd/devshardctl/metrics_test.go b/devshard/cmd/devshardctl/metrics_test.go
new file mode 100644
index 0000000000..a0aebc4a36
--- /dev/null
+++ b/devshard/cmd/devshardctl/metrics_test.go
@@ -0,0 +1,257 @@
+package main
+
+import (
+	"io"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	dto "github.com/prometheus/client_model/go"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGatewayCoreV1MetricsRecordBoundedLabels(t *testing.T) {
+	m := NewDevshardMetrics()
+
+	m.RecordParticipantLimitRejection("participant-1", "Qwen/Test", "transport_request")
+	m.RecordParticipantTransportError("participant-1", "Qwen/Test", "inference", http.StatusServiceUnavailable)
+	m.RecordGatewayRequest("Qwen/Test", "success", "none")
+	m.RecordCriticalUserFailure("Qwen/Test", "runtime_unavailable")
+	m.RecordGatewayHiddenFailure("Qwen/Test", "protected", "empty_stream")
+	m.RecordGatewayUserVisibleWin("participant-1", "Qwen/Test")
+	m.RecordGatewaySlotDecision(GatewaySlotDecisionMetric{
+		ParticipantKey: "participant-1",
+		Model:          "Qwen/Test",
+		EscrowID:       "12",
+		Decision:       "ghost_no_send",
+		Reason:         "participant_throttled_no_send",
+		QuarantineMode: "probe",
+	})
+	m.RecordGatewayAttemptStarted(GatewayAttemptStartMetric{
+		ParticipantKey: "participant-1",
+		Model:          "Qwen/Test",
+		Role:           "extra",
+		Reason:         "receipt_timeout",
+		QuarantineMode: "none",
+	})
+	m.RecordGatewayAttemptTerminal(GatewayAttemptTerminalMetric{
+		ParticipantKey: "participant-1",
+		Model:          "Qwen/Test",
+		Role:           "extra",
+		Outcome:        "failed",
+		Visibility:     "failed_not_finished",
+	})
+	m.RecordGatewayAttemptFailure(GatewayAttemptFailureMetric{
+		ParticipantKey: "participant-1",
+		Model:          "Qwen/Test",
+		Role:           "extra",
+		Reason:         "empty_stream",
+		Visibility:     "failed_not_finished",
+	})
+	m.RecordGatewayNoWinnerAttempt("participant-1", "Qwen/Test", "shadow_quarantine", "shadow")
+	m.RecordGatewayTimeoutAction(GatewayTimeoutActionMetric{
+		ParticipantKey: "participant-1",
+		Model:          "Qwen/Test",
+		Kind:           "execution",
+		Action:         "completed",
+		Reason:         "none",
+	})
+
+	families, err := m.registry.Gather()
+	require.NoError(t, err)
+	requireMetricCounterValue(t, families, "devshard_gateway_participant_limit_rejections_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "scope": "transport_request"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_participant_transport_errors_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "path_kind": "inference", "status": "503"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_requests_total", map[string]string{"model": "Qwen/Test", "outcome": "success", "reason": "none"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_critical_user_failures_total", map[string]string{"model": "Qwen/Test", "reason": "runtime_unavailable"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_user_requests_with_hidden_failure_total", map[string]string{"model": "Qwen/Test", "severity": "protected", "reason": "empty_stream"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_user_visible_wins_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_slot_decisions_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "escrow_id": "12", "decision": "ghost_no_send", "reason": "participant_throttled_no_send", "quarantine_mode": "probe"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_attempts_started_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "role": "extra", "reason": "receipt_timeout", "quarantine_mode": "none"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_attempts_terminal_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "role": "extra", "outcome": "failed", "visibility": "failed_not_finished"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_attempt_failures_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "role": "extra", "reason": "empty_stream", "visibility": "failed_not_finished"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_no_winner_attempts_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "reason": "shadow_quarantine", "quarantine_mode": "shadow"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_timeout_actions_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "kind": "execution", "action": "completed", "reason": "none"}, 1)
+}
+
+func TestGatewayMetricsCollectorIncludesParticipantQuarantineState(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+	for i := 0; i < emptyStreamQuarantineThreshold; i++ {
+		limiter.ObserveEmptyStreamForModel("participant-1", "Qwen/Test")
+	}
+
+	g := &Gateway{
+		participantLimiter: limiter,
+		runtimeOrder: []*devshardRuntime{{
+			id:              "12",
+			model:           "Qwen/Test",
+			participantKeys: []string{"participant-1"},
+		}},
+	}
+	collector := newGatewayMetricsCollectorWithHostConnections(g, fakeHostConnectionSnapshotter(nil))
+
+	registry := prometheus.NewRegistry()
+	registry.MustRegister(collector)
+	families, err := registry.Gather()
+	require.NoError(t, err)
+	requireMetricGaugeValue(t, families, "devshard_gateway_participant_quarantine_state", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "mode": "shadow"}, 1)
+}
+
+func TestGatewayMetricsCollectorDedupesParticipantQuarantineState(t *testing.T) {
+	limiter := NewParticipantRequestLimiter(10, 10)
+	for i := 0; i < emptyStreamQuarantineThreshold; i++ {
+		limiter.ObserveEmptyStreamForModel("participant-1", "Qwen/Test")
+	}
+
+	g := &Gateway{
+		participantLimiter: limiter,
+		runtimeOrder: []*devshardRuntime{
+			{
+				id:              "12",
+				model:           "Qwen/Test",
+				participantKeys: []string{"participant-1"},
+			},
+			{
+				id:              "44",
+				model:           "Qwen/Test",
+				participantKeys: []string{"participant-1"},
+			},
+		},
+	}
+	collector := newGatewayMetricsCollectorWithHostConnections(g, fakeHostConnectionSnapshotter(nil))
+
+	registry := prometheus.NewRegistry()
+	registry.MustRegister(collector)
+	families, err := registry.Gather()
+	require.NoError(t, err)
+	requireMetricGaugeValue(t, families, "devshard_gateway_participant_quarantine_state", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "mode": "shadow"}, 1)
+}
+
+func TestGatewayMetricsCollectorIncludesModelCapacityScales(t *testing.T) {
+	capacity := NewCapacityState()
+	capacity.SetEscrowMembership("qwen", map[string]int{"host-q": 1})
+	capacity.SetEscrowMembership("kimi", map[string]int{"host-k": 1})
+	capacity.SetHostWeightViews(
+		map[string]float64{"host-q": 40, "host-k": 50},
+		map[string]float64{"host-q": 150, "host-k": 50},
+		map[string]map[string]float64{
+			"Qwen/Test": {"host-q": 40},
+			"Kimi/Test": {"host-k": 50},
+		},
+		map[string]map[string]float64{
+			"Qwen/Test": {"host-q": 150},
+			"Kimi/Test": {"host-k": 50},
+		},
+	)
+	g := &Gateway{
+		capacity: capacity,
+		runtimeOrder: []*devshardRuntime{
+			{id: "qwen", model: "Qwen/Test"},
+			{id: "kimi", model: "Kimi/Test"},
+			{id: "runtime-only", model: "Runtime/Only"},
+		},
+	}
+	collector := newGatewayMetricsCollectorWithHostConnections(g, fakeHostConnectionSnapshotter(nil))
+
+	registry := prometheus.NewRegistry()
+	registry.MustRegister(collector)
+	families, err := registry.Gather()
+	require.NoError(t, err)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_scale_by_model", map[string]string{"model": "Qwen/Test"}, 40.0/150.0)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_total_weight_by_model", map[string]string{"model": "Qwen/Test"}, 40)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_baseline_weight_by_model", map[string]string{"model": "Qwen/Test"}, 150)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_scale_by_model", map[string]string{"model": "Kimi/Test"}, 1)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_total_weight_by_model", map[string]string{"model": "Kimi/Test"}, 50)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_baseline_weight_by_model", map[string]string{"model": "Kimi/Test"}, 50)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_scale_by_model", map[string]string{"model": "Runtime/Only"}, 90.0/200.0)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_total_weight_by_model", map[string]string{"model": "Runtime/Only"}, 90)
+	requireMetricGaugeValue(t, families, "devshard_gateway_capacity_baseline_weight_by_model", map[string]string{"model": "Runtime/Only"}, 200)
+}
+
+func TestParticipantLimiterRecordsQuarantineTransitions(t *testing.T) {
+	m := NewDevshardMetrics()
+	limiter := NewParticipantRequestLimiter(10, 10)
+	limiter.SetMetrics(m)
+
+	limiter.ObserveResultWithBodyForModel("participant-1", "Qwen/Test", "/sessions/12/chat/completions", http.StatusServiceUnavailable, "")
+	for i := 0; i < emptyStreamQuarantineThreshold; i++ {
+		limiter.ObserveEmptyStreamForModel("participant-2", "Qwen/Test")
+	}
+
+	families, err := m.registry.Gather()
+	require.NoError(t, err)
+	requireMetricCounterValue(t, families, "devshard_gateway_participant_quarantine_transitions_total", map[string]string{"participant_key": "participant-1", "model": "Qwen/Test", "mode": "probe", "reason": "http_throttle_quarantine"}, 1)
+	requireMetricCounterValue(t, families, "devshard_gateway_participant_quarantine_transitions_total", map[string]string{"participant_key": "participant-2", "model": "Qwen/Test", "mode": "shadow", "reason": "empty_stream_quarantine"}, 1)
+}
+
+func TestGatewayParticipantTimingMetricsRecordAddressAndModel(t *testing.T) {
+	m := NewDevshardMetrics()
+	now := time.Now()
+
+	m.ObserveRequestSample("12", RequestSample{
+		HostIdx:        1,
+		ParticipantKey: "participant-1",
+		Model:          "Qwen/Test",
+		SendTime:       now,
+		ReceiptTime:    now.Add(100 * time.Millisecond),
+		FirstToken:     now.Add(300 * time.Millisecond),
+		TotalTime:      900 * time.Millisecond,
+		InputTokens:    10,
+	})
+
+	families, err := m.registry.Gather()
+	require.NoError(t, err)
+	labels := map[string]string{"participant_key": "participant-1", "model": "Qwen/Test"}
+	requireMetricHistogramCount(t, families, "devshard_gateway_participant_receipt_seconds", labels, 1)
+	requireMetricHistogramCount(t, families, "devshard_gateway_participant_first_content_seconds", labels, 1)
+	requireMetricHistogramCount(t, families, "devshard_gateway_participant_prefill_seconds_per_input_token", labels, 1)
+	requireMetricHistogramCount(t, families, "devshard_gateway_participant_total_attempt_seconds", labels, 1)
+}
+
+func TestGatewayAttemptMetricClassifiers(t *testing.T) {
+	now := time.Now()
+
+	require.Equal(t, "empty_stream", gatewayAttemptFailureReason(&inflight{receiptTime: now}, nil))
+	require.Equal(t, "error_stream", gatewayAttemptFailureReason(&inflight{receiptTime: now, errorSource: "error.BadRequestError"}, nil))
+	require.Equal(t, "eof_transport", gatewayAttemptFailureReason(&inflight{err: io.EOF}, nil))
+	require.Equal(t, "phase_transition_aborted", gatewayAttemptFailureReason(&inflight{phaseTransitionAborted: true}, nil))
+
+	require.Equal(t, "user_visible_winner", gatewayAttemptVisibility(&inflight{nonce: 7}, 7, true))
+	require.Equal(t, "no_winner", gatewayAttemptVisibility(&inflight{nonce: 7, suspicious: true}, 7, true))
+	require.Equal(t, "suppressed_loser", gatewayAttemptVisibility(&inflight{nonce: 8}, 7, true))
+	require.Equal(t, "failed_not_finished", gatewayAttemptVisibility(&inflight{nonce: 8}, 0, false))
+}
+
+func requireMetricCounterValue(t *testing.T, families []*dto.MetricFamily, name string, labels map[string]string, want float64) {
+	t.Helper()
+	for _, family := range families {
+		if family.GetName() != name {
+			continue
+		}
+		for _, metric := range family.GetMetric() {
+			if metricLabelsMatch(metric, labels) {
+				require.NotNil(t, metric.Counter)
+				require.Equal(t, want, metric.Counter.GetValue())
+				return
+			}
+		}
+	}
+	t.Fatalf("metric %s with labels %v not found", name, labels)
+}
+
+func requireMetricHistogramCount(t *testing.T, families []*dto.MetricFamily, name string, labels map[string]string, want uint64) {
+	t.Helper()
+	for _, family := range families {
+		if family.GetName() != name {
+			continue
+		}
+		for _, metric := range family.GetMetric() {
+			if metricLabelsMatch(metric, labels) {
+				require.NotNil(t, metric.Histogram)
+				require.Equal(t, want, metric.Histogram.GetSampleCount())
+				return
+			}
+		}
+	}
+	t.Fatalf("histogram %s with labels %v not found", name, labels)
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/context.go b/devshard/cmd/devshardctl/paramvalidators/context.go
index a3b54a71e7..d05e985d38 100644
--- a/devshard/cmd/devshardctl/paramvalidators/context.go
+++ b/devshard/cmd/devshardctl/paramvalidators/context.go
@@ -6,3 +6,18 @@ type ValidatorContext struct {
 	Document    map[string]any
 	RoutedModel string
 }
+
+// ParameterContext is the input bundle passed to ParameterHandler.HandleParameter.
+// Document is shared with the pipeline; handlers may mutate it (delete the field,
+// rewrite its value, etc.). Parameter is the field name the handler is wired against.
+type ParameterContext struct {
+	Document    map[string]any
+	Parameter   string
+	RoutedModel string
+}
+
+// ParameterHandler is the leaf type for stage-driven rewrites of a single field.
+// The caller wraps the returned error as HTTP 400.
+type ParameterHandler interface {
+	HandleParameter(ParameterContext) error
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/handlers.go b/devshard/cmd/devshardctl/paramvalidators/handlers.go
new file mode 100644
index 0000000000..e9fc6a679a
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/handlers.go
@@ -0,0 +1,309 @@
+package paramvalidators
+
+import (
+	"fmt"
+	"math"
+
+	"devshard"
+)
+
+// StripParameter deletes the parameter field from the document unconditionally.
+type StripParameter struct{}
+
+func (StripParameter) HandleParameter(ctx ParameterContext) error {
+	delete(ctx.Document, ctx.Parameter)
+	return nil
+}
+
+// ConditionalStripParameter deletes the parameter field when Predicate returns true.
+// Predicate is called only when the rule fires; nil predicate is a no-op.
+type ConditionalStripParameter struct {
+	Predicate func(ParameterContext) bool
+}
+
+func (h ConditionalStripParameter) HandleParameter(ctx ParameterContext) error {
+	if h.Predicate != nil && h.Predicate(ctx) {
+		delete(ctx.Document, ctx.Parameter)
+	}
+	return nil
+}
+
+// SanitizeStringListParameter filters a []string-shaped field. Non-string entries pass
+// through unchanged so other validators can flag them. DropFieldIfEmpty removes the
+// field entirely when the filter leaves it empty.
+type SanitizeStringListParameter struct {
+	Keep             func(string) bool
+	DropFieldIfEmpty bool
+}
+
+func (h SanitizeStringListParameter) HandleParameter(ctx ParameterContext) error {
+	raw, ok := ctx.Document[ctx.Parameter].([]any)
+	if !ok {
+		return nil
+	}
+	cleaned := raw[:0]
+	for _, item := range raw {
+		value, ok := item.(string)
+		if !ok {
+			cleaned = append(cleaned, item)
+			continue
+		}
+		if h.Keep == nil || h.Keep(value) {
+			cleaned = append(cleaned, value)
+		}
+	}
+	if len(cleaned) == 0 && h.DropFieldIfEmpty {
+		delete(ctx.Document, ctx.Parameter)
+		return nil
+	}
+	ctx.Document[ctx.Parameter] = cleaned
+	return nil
+}
+
+// SanitizeFloatParameter normalizes a numeric knob: parses string/json.Number inputs,
+// drops non-finite values when StripNonFinite is set, clamps to [Min, Max].
+type SanitizeFloatParameter struct {
+	StripNonFinite bool
+	Min            *float64
+	Max            *float64
+}
+
+func (h SanitizeFloatParameter) HandleParameter(ctx ParameterContext) error {
+	value, exists := ctx.Document[ctx.Parameter]
+	if !exists {
+		return nil
+	}
+	number, ok := devshard.JSONNumericFloat64(value)
+	if !ok {
+		delete(ctx.Document, ctx.Parameter)
+		return nil
+	}
+	if h.StripNonFinite && (math.IsNaN(number) || math.IsInf(number, 0)) {
+		delete(ctx.Document, ctx.Parameter)
+		return nil
+	}
+	if h.Min != nil && number < *h.Min {
+		number = *h.Min
+	}
+	if h.Max != nil && number > *h.Max {
+		number = *h.Max
+	}
+	ctx.Document[ctx.Parameter] = number
+	return nil
+}
+
+// SanitizeFloatMapParameter applies SanitizeFloatParameter semantics to every value in
+// a map-shaped field. Entries that fail clamping are dropped (not clamped) — vLLM
+// rejects out-of-range logit_bias entries.
+type SanitizeFloatMapParameter struct {
+	StripNonFinite   bool
+	Min              *float64
+	Max              *float64
+	DropFieldIfEmpty bool
+	MaxEntries       int
+}
+
+func (h SanitizeFloatMapParameter) HandleParameter(ctx ParameterContext) error {
+	raw, ok := ctx.Document[ctx.Parameter].(map[string]any)
+	if !ok {
+		return nil
+	}
+	if h.MaxEntries > 0 && len(raw) > h.MaxEntries {
+		return fmt.Errorf("%s: map size %d exceeds limit %d", ctx.Parameter, len(raw), h.MaxEntries)
+	}
+	for key, value := range raw {
+		number, ok := devshard.JSONNumericFloat64(value)
+		if !ok {
+			continue
+		}
+		if h.StripNonFinite && (math.IsNaN(number) || math.IsInf(number, 0)) {
+			delete(raw, key)
+			continue
+		}
+		if h.Min != nil && number < *h.Min {
+			delete(raw, key)
+			continue
+		}
+		if h.Max != nil && number > *h.Max {
+			delete(raw, key)
+		}
+	}
+	if len(raw) == 0 && h.DropFieldIfEmpty {
+		delete(ctx.Document, ctx.Parameter)
+		return nil
+	}
+	ctx.Document[ctx.Parameter] = raw
+	return nil
+}
+
+// ForceLiteralParameter writes Value into the document. OverwriteOnly leaves the
+// field untouched when it isn't already present.
+type ForceLiteralParameter struct {
+	Value         any
+	OverwriteOnly bool
+}
+
+func (h ForceLiteralParameter) HandleParameter(ctx ParameterContext) error {
+	if h.OverwriteOnly {
+		if _, exists := ctx.Document[ctx.Parameter]; !exists {
+			return nil
+		}
+	}
+	ctx.Document[ctx.Parameter] = h.Value
+	return nil
+}
+
+// CapUintParameter caps a uint64-shaped field to Max.
+type CapUintParameter struct {
+	Min uint64
+	Max uint64
+}
+
+func (h CapUintParameter) HandleParameter(ctx ParameterContext) error {
+	value, ok := numericJSONValueAsUint64FromMap(ctx.Document, ctx.Parameter)
+	if !ok {
+		return nil
+	}
+	if value < h.Min {
+		ctx.Document[ctx.Parameter] = h.Min
+	}
+	if value > h.Max {
+		ctx.Document[ctx.Parameter] = h.Max
+	}
+	return nil
+}
+
+// ClampUintToFieldParameter clamps the parameter to the value of another field
+// in the same document (e.g. thinking_token_budget ≤ max_tokens). A zero MaxField
+// value or missing MaxField is treated as "no clamp".
+type ClampUintToFieldParameter struct {
+	MaxField string
+}
+
+func (h ClampUintToFieldParameter) HandleParameter(ctx ParameterContext) error {
+	value, ok := numericJSONValueAsUint64FromMap(ctx.Document, ctx.Parameter)
+	if !ok {
+		return nil
+	}
+	maxValue, ok := numericJSONValueAsUint64FromMap(ctx.Document, h.MaxField)
+	if !ok || maxValue == 0 {
+		return nil
+	}
+	if value > maxValue {
+		ctx.Document[ctx.Parameter] = maxValue
+	}
+	return nil
+}
+
+// ValidateUintParameter rejects requests whose field is present but cannot be parsed
+// as a non-negative integer that fits in uint64. Pass-through when the field is absent.
+type ValidateUintParameter struct{}
+
+func (h ValidateUintParameter) HandleParameter(ctx ParameterContext) error {
+	raw, exists := ctx.Document[ctx.Parameter]
+	if !exists || raw == nil {
+		return nil
+	}
+	if _, ok := devshard.JSONNumericUint64(raw); !ok {
+		return fmt.Errorf("%s: must be a non-negative integer", ctx.Parameter)
+	}
+	return nil
+}
+
+// RejectNumberParameter rejects the request when the parameter is present and parses as a
+// number but Allow returns false for it. Non-numeric or absent values pass through so the
+// dedicated type/shape validators own those cases. Used for range gates whose lower bound is
+// exclusive (e.g. top_p > 0), where clamping to the bound would itself be an illegal value.
+type RejectNumberParameter struct {
+	Allow   func(float64) bool
+	Message string
+}
+
+func (h RejectNumberParameter) HandleParameter(ctx ParameterContext) error {
+	value, exists := ctx.Document[ctx.Parameter]
+	if !exists {
+		return nil
+	}
+	number, ok := devshard.JSONNumericFloat64(value)
+	if !ok {
+		return nil
+	}
+	if h.Allow == nil || h.Allow(number) {
+		return nil
+	}
+	return fmt.Errorf("%s: %s", ctx.Parameter, h.Message)
+}
+
+// ValidateScalarParameter rejects the request when the parameter is present (non-null) but
+// Valid returns false for its raw JSON value. Catches wrong-typed scalars at the boundary
+// instead of forwarding them for an opaque upstream 400.
+type ValidateScalarParameter struct {
+	Valid   func(any) bool
+	Message string
+}
+
+func (h ValidateScalarParameter) HandleParameter(ctx ParameterContext) error {
+	value, exists := ctx.Document[ctx.Parameter]
+	if !exists || value == nil {
+		return nil
+	}
+	if h.Valid == nil || h.Valid(value) {
+		return nil
+	}
+	return fmt.Errorf("%s: %s", ctx.Parameter, h.Message)
+}
+
+// ValidateListElementsParameter rejects the request when any array element fails Valid.
+// Pass-through when the field is absent or not an array.
+type ValidateListElementsParameter struct {
+	Valid   func(any) bool
+	Message string
+}
+
+func (h ValidateListElementsParameter) HandleParameter(ctx ParameterContext) error {
+	raw, ok := ctx.Document[ctx.Parameter].([]any)
+	if !ok {
+		return nil
+	}
+	for index, item := range raw {
+		if h.Valid != nil && !h.Valid(item) {
+			return fmt.Errorf("%s[%d]: %s", ctx.Parameter, index, h.Message)
+		}
+	}
+	return nil
+}
+
+// JSON type predicates for the Validate*Parameter handlers above.
+func IsJSONBool(value any) bool   { _, ok := value.(bool); return ok }
+func IsJSONString(value any) bool { _, ok := value.(string); return ok }
+func IsJSONUint(value any) bool   { _, ok := devshard.JSONNumericUint64(value); return ok }
+
+// LengthCapListParameter bounds the number of entries in an array field, and
+// optionally the byte length of each string entry. MaxEntries=0 disables the
+// array cap; MaxEntryLen=0 disables the per-string cap.
+type LengthCapListParameter struct {
+	MaxEntries  int
+	MaxEntryLen int
+}
+
+func (h LengthCapListParameter) HandleParameter(ctx ParameterContext) error {
+	raw, ok := ctx.Document[ctx.Parameter].([]any)
+	if !ok {
+		return nil
+	}
+	if h.MaxEntries > 0 && len(raw) > h.MaxEntries {
+		return fmt.Errorf("%s: array length %d exceeds limit %d", ctx.Parameter, len(raw), h.MaxEntries)
+	}
+	if h.MaxEntryLen > 0 {
+		for i, item := range raw {
+			s, ok := item.(string)
+			if !ok {
+				continue
+			}
+			if len(s) > h.MaxEntryLen {
+				return fmt.Errorf("%s[%d]: string length %d exceeds limit %d", ctx.Parameter, i, len(s), h.MaxEntryLen)
+			}
+		}
+	}
+	return nil
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/handlers_test.go b/devshard/cmd/devshardctl/paramvalidators/handlers_test.go
new file mode 100644
index 0000000000..a1d0e8c346
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/handlers_test.go
@@ -0,0 +1,450 @@
+package paramvalidators
+
+import (
+	"math"
+	"strings"
+	"testing"
+
+	"devshard/cmd/devshardctl/testutil"
+)
+
+// run is a tiny wrapper that builds a ParameterContext and dispatches the handler.
+func run(h ParameterHandler, doc map[string]any, param string) error {
+	return h.HandleParameter(ParameterContext{
+		Document:    doc,
+		Parameter:   param,
+		RoutedModel: "",
+	})
+}
+
+// ============================================================
+// StripParameter
+// ============================================================
+
+func TestStripParameter(t *testing.T) {
+	doc := map[string]any{"x": "y", "keep": 1}
+	if err := run(StripParameter{}, doc, "x"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["x"]; has {
+		t.Fatal("x must be stripped")
+	}
+	if _, has := doc["keep"]; !has {
+		t.Fatal("other fields must remain")
+	}
+}
+
+func TestStripParameter_NoopWhenAbsent(t *testing.T) {
+	doc := map[string]any{"keep": 1}
+	if err := run(StripParameter{}, doc, "x"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// ============================================================
+// ConditionalStripParameter
+// ============================================================
+
+func TestConditionalStripParameter_PredicateTrue(t *testing.T) {
+	doc := map[string]any{"min_tokens": 10, "stop_token_ids": []any{42}}
+	h := ConditionalStripParameter{
+		Predicate: func(ctx ParameterContext) bool {
+			_, ok := ctx.Document["stop_token_ids"]
+			return ok
+		},
+	}
+	if err := run(h, doc, "min_tokens"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["min_tokens"]; has {
+		t.Fatal("min_tokens must be stripped when stop_token_ids present")
+	}
+}
+
+func TestConditionalStripParameter_PredicateFalse(t *testing.T) {
+	doc := map[string]any{"min_tokens": 10}
+	h := ConditionalStripParameter{
+		Predicate: func(ctx ParameterContext) bool {
+			_, ok := ctx.Document["stop_token_ids"]
+			return ok
+		},
+	}
+	if err := run(h, doc, "min_tokens"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["min_tokens"]; !has {
+		t.Fatal("min_tokens must remain when predicate is false")
+	}
+}
+
+func TestConditionalStripParameter_NilPredicateNoop(t *testing.T) {
+	doc := map[string]any{"x": 1}
+	if err := run(ConditionalStripParameter{}, doc, "x"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["x"]; !has {
+		t.Fatal("nil predicate is a no-op")
+	}
+}
+
+// ============================================================
+// SanitizeStringListParameter
+// ============================================================
+
+func TestSanitizeStringListParameter_Filters(t *testing.T) {
+	doc := map[string]any{"bad_words": []any{"keep", "", "  ", "also-keep"}}
+	h := SanitizeStringListParameter{
+		Keep:             func(s string) bool { return strings.TrimSpace(s) != "" },
+		DropFieldIfEmpty: true,
+	}
+	if err := run(h, doc, "bad_words"); err != nil {
+		t.Fatal(err)
+	}
+	out := doc["bad_words"].([]any)
+	if len(out) != 2 || out[0] != "keep" || out[1] != "also-keep" {
+		t.Fatalf("want [keep, also-keep], got %v", out)
+	}
+}
+
+func TestSanitizeStringListParameter_DropsFieldWhenEmpty(t *testing.T) {
+	doc := map[string]any{"bad_words": []any{"", "  "}}
+	h := SanitizeStringListParameter{
+		Keep:             func(s string) bool { return strings.TrimSpace(s) != "" },
+		DropFieldIfEmpty: true,
+	}
+	if err := run(h, doc, "bad_words"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["bad_words"]; has {
+		t.Fatal("empty post-filter array must be removed when DropFieldIfEmpty=true")
+	}
+}
+
+func TestSanitizeStringListParameter_NonStringElementsPreserved(t *testing.T) {
+	// Non-strings pass through so later validators can flag them; the filter
+	// only acts on strings.
+	doc := map[string]any{"x": []any{"a", 42, true, "b"}}
+	h := SanitizeStringListParameter{Keep: func(s string) bool { return true }}
+	if err := run(h, doc, "x"); err != nil {
+		t.Fatal(err)
+	}
+	out := doc["x"].([]any)
+	if len(out) != 4 {
+		t.Fatalf("want 4 elements, got %d", len(out))
+	}
+}
+
+func TestSanitizeStringListParameter_AbsentFieldNoop(t *testing.T) {
+	doc := map[string]any{}
+	if err := run(SanitizeStringListParameter{}, doc, "x"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// ============================================================
+// SanitizeFloatParameter
+// ============================================================
+
+func TestSanitizeFloatParameter_Clamps(t *testing.T) {
+	doc := map[string]any{"t": 5.0}
+	h := SanitizeFloatParameter{Min: testutil.FloatPtr(0), Max: testutil.FloatPtr(2.0)}
+	if err := run(h, doc, "t"); err != nil {
+		t.Fatal(err)
+	}
+	if doc["t"].(float64) != 2.0 {
+		t.Fatalf("want clamped to 2.0, got %v", doc["t"])
+	}
+}
+
+func TestSanitizeFloatParameter_StripsNonFinite(t *testing.T) {
+	for _, v := range []float64{math.NaN(), math.Inf(1), math.Inf(-1)} {
+		doc := map[string]any{"t": v}
+		h := SanitizeFloatParameter{StripNonFinite: true}
+		if err := run(h, doc, "t"); err != nil {
+			t.Fatal(err)
+		}
+		if _, has := doc["t"]; has {
+			t.Fatalf("non-finite %v must be stripped", v)
+		}
+	}
+}
+
+func TestSanitizeFloatParameter_NonNumericStripped(t *testing.T) {
+	doc := map[string]any{"t": "not-a-number"}
+	if err := run(SanitizeFloatParameter{}, doc, "t"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["t"]; has {
+		t.Fatal("non-numeric must be stripped")
+	}
+}
+
+func TestSanitizeFloatParameter_StringNumericCoerced(t *testing.T) {
+	// Some SDKs serialize numbers as strings for high-precision fields.
+	doc := map[string]any{"t": "1.5"}
+	if err := run(SanitizeFloatParameter{}, doc, "t"); err != nil {
+		t.Fatal(err)
+	}
+	if doc["t"].(float64) != 1.5 {
+		t.Fatalf("want 1.5, got %v", doc["t"])
+	}
+}
+
+// ============================================================
+// SanitizeFloatMapParameter
+// ============================================================
+
+func TestSanitizeFloatMapParameter_DropsOutOfRange(t *testing.T) {
+	doc := map[string]any{"logit_bias": map[string]any{
+		"a": 50.0,   // out of [-100, 100]? No, in range
+		"b": 150.0,  // > 100 → drop
+		"c": -200.0, // < -100 → drop
+		"d": 0.0,
+	}}
+	h := SanitizeFloatMapParameter{Min: testutil.FloatPtr(-100), Max: testutil.FloatPtr(100)}
+	if err := run(h, doc, "logit_bias"); err != nil {
+		t.Fatal(err)
+	}
+	out := doc["logit_bias"].(map[string]any)
+	if _, has := out["b"]; has {
+		t.Fatal("b must be dropped")
+	}
+	if _, has := out["c"]; has {
+		t.Fatal("c must be dropped")
+	}
+	if len(out) != 2 {
+		t.Fatalf("want 2 surviving entries, got %d", len(out))
+	}
+}
+
+func TestSanitizeFloatMapParameter_DropsNonFinite(t *testing.T) {
+	doc := map[string]any{"m": map[string]any{
+		"a": 1.0,
+		"b": math.NaN(),
+		"c": math.Inf(1),
+	}}
+	h := SanitizeFloatMapParameter{StripNonFinite: true}
+	if err := run(h, doc, "m"); err != nil {
+		t.Fatal(err)
+	}
+	out := doc["m"].(map[string]any)
+	if len(out) != 1 {
+		t.Fatalf("want 1 surviving, got %d", len(out))
+	}
+}
+
+func TestSanitizeFloatMapParameter_RejectsOversizeMap(t *testing.T) {
+	doc := map[string]any{"m": map[string]any{}}
+	for i := 0; i < 5; i++ {
+		doc["m"].(map[string]any)[string(rune('a'+i))] = 1.0
+	}
+	h := SanitizeFloatMapParameter{MaxEntries: 3}
+	err := run(h, doc, "m")
+	if err == nil || !strings.Contains(err.Error(), "exceeds limit") {
+		t.Fatalf("want 'exceeds limit', got %v", err)
+	}
+}
+
+func TestSanitizeFloatMapParameter_DropFieldIfEmpty(t *testing.T) {
+	doc := map[string]any{"m": map[string]any{"a": math.NaN(), "b": math.Inf(1)}}
+	h := SanitizeFloatMapParameter{StripNonFinite: true, DropFieldIfEmpty: true}
+	if err := run(h, doc, "m"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["m"]; has {
+		t.Fatal("post-filter empty map must be removed")
+	}
+}
+
+// ============================================================
+// ForceLiteralParameter
+// ============================================================
+
+func TestForceLiteralParameter_Overwrites(t *testing.T) {
+	doc := map[string]any{"logprobs": false}
+	if err := run(ForceLiteralParameter{Value: true}, doc, "logprobs"); err != nil {
+		t.Fatal(err)
+	}
+	if doc["logprobs"] != true {
+		t.Fatalf("want true, got %v", doc["logprobs"])
+	}
+}
+
+func TestForceLiteralParameter_CreatesWhenAbsent(t *testing.T) {
+	doc := map[string]any{}
+	if err := run(ForceLiteralParameter{Value: 5}, doc, "n"); err != nil {
+		t.Fatal(err)
+	}
+	if doc["n"] != 5 {
+		t.Fatalf("want 5, got %v", doc["n"])
+	}
+}
+
+func TestForceLiteralParameter_OverwriteOnlySkipsAbsent(t *testing.T) {
+	doc := map[string]any{}
+	h := ForceLiteralParameter{Value: 0.0, OverwriteOnly: true}
+	if err := run(h, doc, "frequency_penalty"); err != nil {
+		t.Fatal(err)
+	}
+	if _, has := doc["frequency_penalty"]; has {
+		t.Fatal("OverwriteOnly must not create absent field")
+	}
+}
+
+func TestForceLiteralParameter_OverwriteOnlyTouchesPresent(t *testing.T) {
+	doc := map[string]any{"frequency_penalty": 0.5}
+	h := ForceLiteralParameter{Value: 0.0, OverwriteOnly: true}
+	if err := run(h, doc, "frequency_penalty"); err != nil {
+		t.Fatal(err)
+	}
+	if doc["frequency_penalty"] != 0.0 {
+		t.Fatalf("want 0.0, got %v", doc["frequency_penalty"])
+	}
+}
+
+// ============================================================
+// CapUintParameter
+// ============================================================
+
+func TestCapUintParameter(t *testing.T) {
+	cases := []struct {
+		name string
+		in   any
+		max  uint64
+		want any
+	}{
+		{"caps-when-over", float64(100), 10, uint64(10)},
+		{"leaves-when-under", float64(5), 10, float64(5)},
+		{"leaves-when-equal", float64(10), 10, float64(10)},
+		{"non-numeric-noop", "x", 10, "x"},
+		{"negative-noop", float64(-1), 10, float64(-1)}, // not coerced → not capped
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			doc := map[string]any{"n": tc.in}
+			if err := run(CapUintParameter{Max: tc.max}, doc, "n"); err != nil {
+				t.Fatal(err)
+			}
+			if doc["n"] != tc.want {
+				t.Fatalf("want %v, got %v", tc.want, doc["n"])
+			}
+		})
+	}
+}
+
+// ============================================================
+// ClampUintToFieldParameter
+// ============================================================
+
+func TestClampUintToFieldParameter(t *testing.T) {
+	t.Run("clamps-to-other-field", func(t *testing.T) {
+		doc := map[string]any{"min_tokens": float64(1000), "max_tokens": float64(100)}
+		if err := run(ClampUintToFieldParameter{MaxField: "max_tokens"}, doc, "min_tokens"); err != nil {
+			t.Fatal(err)
+		}
+		if doc["min_tokens"] != uint64(100) {
+			t.Fatalf("want clamped to 100, got %v", doc["min_tokens"])
+		}
+	})
+	t.Run("max-field-absent-noop", func(t *testing.T) {
+		doc := map[string]any{"min_tokens": float64(1000)}
+		if err := run(ClampUintToFieldParameter{MaxField: "max_tokens"}, doc, "min_tokens"); err != nil {
+			t.Fatal(err)
+		}
+		if doc["min_tokens"] != float64(1000) {
+			t.Fatal("must not clamp when max field is absent")
+		}
+	})
+	t.Run("max-field-zero-noop", func(t *testing.T) {
+		// max_tokens=0 means "no max set" — don't clamp to 0.
+		doc := map[string]any{"min_tokens": float64(1000), "max_tokens": float64(0)}
+		if err := run(ClampUintToFieldParameter{MaxField: "max_tokens"}, doc, "min_tokens"); err != nil {
+			t.Fatal(err)
+		}
+		if doc["min_tokens"] != float64(1000) {
+			t.Fatal("max=0 must not clamp")
+		}
+	})
+}
+
+// ============================================================
+// ValidateUintParameter
+// ============================================================
+
+func TestValidateUintParameter(t *testing.T) {
+	cases := []struct {
+		name      string
+		in        any
+		errSubstr string
+	}{
+		{"valid-int", float64(42), ""},
+		{"absent", nil, ""},
+		{"negative-rejected", float64(-1), "must be a non-negative integer"},
+		{"float-rejected", float64(1.5), "must be a non-negative integer"},
+		{"string-rejected", "42", "must be a non-negative integer"},
+		{"bool-rejected", true, "must be a non-negative integer"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			doc := map[string]any{}
+			if tc.name != "absent" {
+				doc["seed"] = tc.in
+			}
+			err := run(ValidateUintParameter{}, doc, "seed")
+			if tc.errSubstr == "" {
+				if err != nil {
+					t.Fatalf("want no error, got %v", err)
+				}
+				return
+			}
+			if err == nil {
+				t.Fatalf("want error containing %q, got nil", tc.errSubstr)
+			}
+			if !strings.Contains(err.Error(), tc.errSubstr) {
+				t.Fatalf("want %q, got %q", tc.errSubstr, err.Error())
+			}
+		})
+	}
+}
+
+// ============================================================
+// LengthCapListParameter
+// ============================================================
+
+func TestLengthCapListParameter_CapsArray(t *testing.T) {
+	doc := map[string]any{"stop": []any{"a", "b", "c"}}
+	err := run(LengthCapListParameter{MaxEntries: 2}, doc, "stop")
+	if err == nil || !strings.Contains(err.Error(), "array length") {
+		t.Fatalf("want 'array length' error, got %v", err)
+	}
+}
+
+func TestLengthCapListParameter_CapsEntryLen(t *testing.T) {
+	doc := map[string]any{"stop": []any{"short", strings.Repeat("x", 100)}}
+	err := run(LengthCapListParameter{MaxEntryLen: 10}, doc, "stop")
+	if err == nil || !strings.Contains(err.Error(), "string length") {
+		t.Fatalf("want 'string length' error, got %v", err)
+	}
+}
+
+func TestLengthCapListParameter_NonStringEntriesSkipped(t *testing.T) {
+	// stop_token_ids is an int array — string cap doesn't apply.
+	doc := map[string]any{"stop_token_ids": []any{1, 2, 3, 4}}
+	if err := run(LengthCapListParameter{MaxEntries: 0, MaxEntryLen: 5}, doc, "stop_token_ids"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestLengthCapListParameter_WithinCapOK(t *testing.T) {
+	doc := map[string]any{"stop": []any{"a", "b"}}
+	if err := run(LengthCapListParameter{MaxEntries: 5, MaxEntryLen: 10}, doc, "stop"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestLengthCapListParameter_AbsentFieldNoop(t *testing.T) {
+	doc := map[string]any{}
+	if err := run(LengthCapListParameter{MaxEntries: 1}, doc, "stop"); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/kimi_max_tokens_floor.go b/devshard/cmd/devshardctl/paramvalidators/kimi_max_tokens_floor.go
new file mode 100644
index 0000000000..67fb2bcc67
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/kimi_max_tokens_floor.go
@@ -0,0 +1,27 @@
+package paramvalidators
+
+// KimiMaxTokensFloorValidator lifts max_tokens and max_completion_tokens to
+// Min for Kimi-K2.6. Below 16 the model emits only </think>, stripped by vLLM.
+type KimiMaxTokensFloorValidator struct {
+	Model string
+	Min   uint64
+}
+
+func (v KimiMaxTokensFloorValidator) Validate(vctx ValidatorContext) error {
+	if vctx.RoutedModel != v.Model {
+		return nil
+	}
+	floorUintField(vctx.Document, "max_tokens", v.Min)
+	floorUintField(vctx.Document, "max_completion_tokens", v.Min)
+	return nil
+}
+
+func floorUintField(doc map[string]any, key string, min uint64) {
+	value, ok := numericAsUint64(doc[key])
+	if !ok {
+		return
+	}
+	if value < min {
+		doc[key] = min
+	}
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/kimi_max_tokens_floor_test.go b/devshard/cmd/devshardctl/paramvalidators/kimi_max_tokens_floor_test.go
new file mode 100644
index 0000000000..0b97f9fa8b
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/kimi_max_tokens_floor_test.go
@@ -0,0 +1,51 @@
+package paramvalidators
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestKimiMaxTokensFloorValidator(t *testing.T) {
+	v := KimiMaxTokensFloorValidator{Model: "moonshotai/Kimi-K2.6", Min: 16}
+
+	t.Run("lifts max_tokens below floor", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":1}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: v.Model}))
+		require.EqualValues(t, 16, doc["max_tokens"])
+	})
+
+	t.Run("lifts max_completion_tokens below floor", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_completion_tokens":8}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: v.Model}))
+		require.EqualValues(t, 16, doc["max_completion_tokens"])
+	})
+
+	t.Run("lifts both fields when both below floor", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":4,"max_completion_tokens":8}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: v.Model}))
+		require.EqualValues(t, 16, doc["max_tokens"])
+		require.EqualValues(t, 16, doc["max_completion_tokens"])
+	})
+
+	t.Run("leaves values at or above floor", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":16,"max_completion_tokens":100}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: v.Model}))
+		require.Equal(t, json.Number("16"), doc["max_tokens"])
+		require.Equal(t, json.Number("100"), doc["max_completion_tokens"])
+	})
+
+	t.Run("skips missing fields", func(t *testing.T) {
+		doc := parseDocument(t, `{}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: v.Model}))
+		_, hasMax := doc["max_tokens"]
+		require.False(t, hasMax)
+	})
+
+	t.Run("no-op for other models", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":1}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: "some/other-model"}))
+		require.Equal(t, json.Number("1"), doc["max_tokens"])
+	})
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/kimi_thinking_token_budget.go b/devshard/cmd/devshardctl/paramvalidators/kimi_thinking_token_budget.go
new file mode 100644
index 0000000000..3661f2c5dd
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/kimi_thinking_token_budget.go
@@ -0,0 +1,45 @@
+package paramvalidators
+
+// KimiThinkingTokenBudgetValidator resolves thinking_token_budget for Kimi-K2.6:
+// force 0 at small max_tokens, else default to max_tokens/Divisor, cap at
+// AbsoluteMax, clamp to (max_tokens - ContentHeadroom). No-op for other models.
+type KimiThinkingTokenBudgetValidator struct {
+	Model                   string
+	DefaultDivisor          uint64
+	AbsoluteMax             uint64
+	ContentHeadroom         uint64
+	ForceZeroBelowMaxTokens uint64
+}
+
+func (v KimiThinkingTokenBudgetValidator) Validate(vctx ValidatorContext) error {
+	if vctx.RoutedModel != v.Model {
+		return nil
+	}
+	maxTokens, ok := numericAsUint64(vctx.Document["max_tokens"])
+	if !ok || maxTokens == 0 {
+		return nil
+	}
+	if v.ForceZeroBelowMaxTokens > 0 && maxTokens < v.ForceZeroBelowMaxTokens {
+		vctx.Document["thinking_token_budget"] = uint64(0)
+		return nil
+	}
+	if _, exists := vctx.Document["thinking_token_budget"]; !exists && v.DefaultDivisor > 0 {
+		vctx.Document["thinking_token_budget"] = maxTokens / v.DefaultDivisor
+	}
+	ttb, ok := numericAsUint64(vctx.Document["thinking_token_budget"])
+	if !ok {
+		return nil
+	}
+	if v.AbsoluteMax > 0 && ttb > v.AbsoluteMax {
+		ttb = v.AbsoluteMax
+	}
+	var headroomCap uint64
+	if maxTokens > v.ContentHeadroom {
+		headroomCap = maxTokens - v.ContentHeadroom
+	}
+	if ttb > headroomCap {
+		ttb = headroomCap
+	}
+	vctx.Document["thinking_token_budget"] = ttb
+	return nil
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/kimi_thinking_token_budget_test.go b/devshard/cmd/devshardctl/paramvalidators/kimi_thinking_token_budget_test.go
new file mode 100644
index 0000000000..585ec78636
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/kimi_thinking_token_budget_test.go
@@ -0,0 +1,81 @@
+package paramvalidators
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func defaultKimiTTBValidator() KimiThinkingTokenBudgetValidator {
+	return KimiThinkingTokenBudgetValidator{
+		Model:                   "moonshotai/Kimi-K2.6",
+		DefaultDivisor:          2,
+		AbsoluteMax:             96_000,
+		ContentHeadroom:         64,
+		ForceZeroBelowMaxTokens: 256,
+	}
+}
+
+func TestKimiThinkingTokenBudgetValidator(t *testing.T) {
+	v := defaultKimiTTBValidator()
+	ctx := func(doc map[string]any) ValidatorContext {
+		return ValidatorContext{Document: doc, RoutedModel: v.Model}
+	}
+
+	t.Run("defaults to half when ttb absent and max_tokens above force-zero", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":4096}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		require.EqualValues(t, 2048, doc["thinking_token_budget"])
+	})
+
+	t.Run("force-zero at small max_tokens overrides client value", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":100,"thinking_token_budget":50}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		require.EqualValues(t, 0, doc["thinking_token_budget"])
+	})
+
+	t.Run("boundary at force-zero threshold keeps half split", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":256}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		require.EqualValues(t, 128, doc["thinking_token_budget"])
+	})
+
+	t.Run("content headroom clamps above max_tokens minus headroom", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":4096,"thinking_token_budget":10000}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		require.EqualValues(t, 4032, doc["thinking_token_budget"])
+	})
+
+	t.Run("absolute max caps very large ttb", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":200000,"thinking_token_budget":150000}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		require.EqualValues(t, 96_000, doc["thinking_token_budget"])
+	})
+
+	t.Run("preserves client ttb under headroom", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":4096,"thinking_token_budget":500}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		require.EqualValues(t, 500, doc["thinking_token_budget"])
+	})
+
+	t.Run("skips when max_tokens absent", func(t *testing.T) {
+		doc := parseDocument(t, `{}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		_, has := doc["thinking_token_budget"]
+		require.False(t, has)
+	})
+
+	t.Run("skips when max_tokens is zero", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":0}`)
+		require.NoError(t, v.Validate(ctx(doc)))
+		_, has := doc["thinking_token_budget"]
+		require.False(t, has)
+	})
+
+	t.Run("no-op for other models", func(t *testing.T) {
+		doc := parseDocument(t, `{"max_tokens":100,"thinking_token_budget":50}`)
+		require.NoError(t, v.Validate(ValidatorContext{Document: doc, RoutedModel: "some/other-model"}))
+		require.Equal(t, json.Number("50"), doc["thinking_token_budget"])
+	})
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/numeric.go b/devshard/cmd/devshardctl/paramvalidators/numeric.go
new file mode 100644
index 0000000000..3fa3017396
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/numeric.go
@@ -0,0 +1,14 @@
+package paramvalidators
+
+import "devshard"
+
+// numericJSONValueAsUint64FromMap reads document[field] and coerces it to a uint64
+// using the shared devshard primitive. Convenience helper for handlers that read
+// integer fields out of the raw document by name.
+func numericJSONValueAsUint64FromMap(document map[string]any, field string) (uint64, bool) {
+	value, ok := document[field]
+	if !ok {
+		return 0, false
+	}
+	return devshard.JSONNumericUint64(value)
+}
diff --git a/devshard/cmd/devshardctl/paramvalidators/response_format.go b/devshard/cmd/devshardctl/paramvalidators/response_format.go
index cc61193883..a4982961e3 100644
--- a/devshard/cmd/devshardctl/paramvalidators/response_format.go
+++ b/devshard/cmd/devshardctl/paramvalidators/response_format.go
@@ -98,7 +98,7 @@ func (v ResponseFormatValidator) validateJSONSchemaWrapper(rf map[string]any) er
 		return fmt.Errorf("%w: must be an object", ErrResponseFormatJSONSchema)
 	}
 	name, ok := wrapper["name"].(string)
-	if !ok || name == "" {
+	if !ok || strings.TrimSpace(name) == "" {
 		return fmt.Errorf("%w: must be a non-empty string", ErrResponseFormatName)
 	}
 	if len(name) > v.MaxNameLen {
diff --git a/devshard/cmd/devshardctl/paramvalidators/response_format_test.go b/devshard/cmd/devshardctl/paramvalidators/response_format_test.go
index af2c9d918e..b47e4af5ff 100644
--- a/devshard/cmd/devshardctl/paramvalidators/response_format_test.go
+++ b/devshard/cmd/devshardctl/paramvalidators/response_format_test.go
@@ -77,6 +77,7 @@ func TestResponseFormatValidatorRejects(t *testing.T) {
 		{name: "unknown type", body: `{"response_format":{"type":"banana"}}`, wantErr: ErrResponseFormatType},
 		{name: "json_schema wrapper missing", body: `{"response_format":{"type":"json_schema"}}`, wantErr: ErrResponseFormatJSONSchema},
 		{name: "json_schema missing name", body: `{"response_format":{"type":"json_schema","json_schema":{"schema":{"type":"object"}}}}`, wantErr: ErrResponseFormatName},
+		{name: "json_schema whitespace name", body: `{"response_format":{"type":"json_schema","json_schema":{"name":"   ","schema":{"type":"object"}}}}`, wantErr: ErrResponseFormatName},
 		{name: "json_schema name has bad chars", body: `{"response_format":{"type":"json_schema","json_schema":{"name":"bad name","schema":{"type":"object"}}}}`, wantErr: ErrResponseFormatName},
 		{name: "json_schema name too long", body: `{"response_format":{"type":"json_schema","json_schema":{"name":"` + strings.Repeat("a", 65) + `","schema":{"type":"object"}}}}`, wantErr: ErrResponseFormatName},
 		{name: "json_schema missing schema", body: `{"response_format":{"type":"json_schema","json_schema":{"name":"r"}}}`, wantErr: ErrResponseFormatSchemaShape},
diff --git a/devshard/cmd/devshardctl/paramvalidators/structured_outputs.go b/devshard/cmd/devshardctl/paramvalidators/structured_outputs.go
index ac1c9ba891..a2906397df 100644
--- a/devshard/cmd/devshardctl/paramvalidators/structured_outputs.go
+++ b/devshard/cmd/devshardctl/paramvalidators/structured_outputs.go
@@ -1,10 +1,13 @@
 package paramvalidators
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"regexp"
 	"strings"
+
+	"devshard/cmd/devshardctl/filtercore"
 )
 
 var (
@@ -86,10 +89,8 @@ func (v StructuredOutputsValidator) Validate(vctx ValidatorContext) error {
 	if !exists {
 		return nil
 	}
-	for _, m := range v.RejectedModels {
-		if m == vctx.RoutedModel {
-			return fmt.Errorf("%w", ErrStructuredOutputsNotSupportedOnRoute)
-		}
+	if filtercore.MatchesModel(vctx.RoutedModel, v.RejectedModels) {
+		return fmt.Errorf("%w", ErrStructuredOutputsNotSupportedOnRoute)
 	}
 	obj, ok := raw.(map[string]any)
 	if !ok {
@@ -279,13 +280,21 @@ func (v StructuredOutputsValidator) validateGrammar(value any) error {
 	return nil
 }
 
+// validateStructuralTag accepts only the OBJECT form (vLLM's
+// StructuralTagResponseFormat: {type, structures[], triggers[]}). A JSON-encoded
+// STRING form crashes the engine with an HTTP 500 on the request handler, so it
+// is rejected here regardless of route. Size is bounded on the serialized object.
 func (v StructuredOutputsValidator) validateStructuralTag(value any) error {
-	s, ok := value.(string)
+	obj, ok := value.(map[string]any)
 	if !ok {
-		return fmt.Errorf("%w: must be a string", ErrStructuredOutputsStructuralTagShape)
+		return fmt.Errorf("%w: must be an object (a JSON-encoded string crashes the engine)", ErrStructuredOutputsStructuralTagShape)
+	}
+	encoded, err := json.Marshal(obj)
+	if err != nil {
+		return fmt.Errorf("%w: %v", ErrStructuredOutputsStructuralTagShape, err)
 	}
-	if len(s) > v.MaxStructuralTagLen {
-		return fmt.Errorf("%w: %d > %d", ErrStructuredOutputsStructuralTagLength, len(s), v.MaxStructuralTagLen)
+	if len(encoded) > v.MaxStructuralTagLen {
+		return fmt.Errorf("%w: %d > %d", ErrStructuredOutputsStructuralTagLength, len(encoded), v.MaxStructuralTagLen)
 	}
 	return nil
 }
diff --git a/devshard/cmd/devshardctl/paramvalidators/structured_outputs_test.go b/devshard/cmd/devshardctl/paramvalidators/structured_outputs_test.go
index ea0d41fbca..56053ccfb6 100644
--- a/devshard/cmd/devshardctl/paramvalidators/structured_outputs_test.go
+++ b/devshard/cmd/devshardctl/paramvalidators/structured_outputs_test.go
@@ -268,20 +268,27 @@ func TestStructuredOutputsValidatorJSONObject(t *testing.T) {
 func TestStructuredOutputsValidatorStructuralTag(t *testing.T) {
 	v := defaultStructuredOutputsValidator()
 
-	t.Run("accepts a normal tag", func(t *testing.T) {
-		body := `{"structured_outputs":{"structural_tag":"<tool>...</tool>"}}`
+	t.Run("accepts the object form", func(t *testing.T) {
+		body := `{"structured_outputs":{"structural_tag":{"type":"structural_tag","structures":[],"triggers":[]}}}`
 		require.NoError(t, v.Validate(ValidatorContext{Document: parseDocument(t, body)}))
 	})
 
-	t.Run("rejects non-string", func(t *testing.T) {
+	t.Run("rejects the engine-crashing string form", func(t *testing.T) {
+		// A JSON-encoded string structural_tag returns HTTP 500 from vLLM; reject it here.
+		body := `{"structured_outputs":{"structural_tag":"<tool>...</tool>"}}`
+		err := v.Validate(ValidatorContext{Document: parseDocument(t, body)})
+		require.ErrorIs(t, err, ErrStructuredOutputsStructuralTagShape)
+	})
+
+	t.Run("rejects a non-object scalar", func(t *testing.T) {
 		body := `{"structured_outputs":{"structural_tag":42}}`
 		err := v.Validate(ValidatorContext{Document: parseDocument(t, body)})
 		require.ErrorIs(t, err, ErrStructuredOutputsStructuralTagShape)
 	})
 
-	t.Run("rejects oversize", func(t *testing.T) {
+	t.Run("rejects oversize object", func(t *testing.T) {
 		long := strings.Repeat("a", 4*1024+1)
-		body := `{"structured_outputs":{"structural_tag":"` + long + `"}}`
+		body := `{"structured_outputs":{"structural_tag":{"type":"structural_tag","blob":"` + long + `"}}}`
 		err := v.Validate(ValidatorContext{Document: parseDocument(t, body)})
 		require.ErrorIs(t, err, ErrStructuredOutputsStructuralTagLength)
 	})
diff --git a/devshard/cmd/devshardctl/paramvalidators/thinking.go b/devshard/cmd/devshardctl/paramvalidators/thinking.go
index 61f4a07b13..6dc172acf9 100644
--- a/devshard/cmd/devshardctl/paramvalidators/thinking.go
+++ b/devshard/cmd/devshardctl/paramvalidators/thinking.go
@@ -3,6 +3,8 @@ package paramvalidators
 import (
 	"errors"
 	"fmt"
+
+	"devshard/cmd/devshardctl/filtercore"
 )
 
 // ErrThinkingShape covers the wrapper-level rejection. ErrThinkingType covers the inner
@@ -70,12 +72,7 @@ func resolveThinkingType(typeStr string) (bool, bool) {
 }
 
 func (v ThinkingValidator) shouldMirror(routedModel string) bool {
-	for _, m := range v.MirrorToTemplateKwargsForModels {
-		if m == routedModel {
-			return true
-		}
-	}
-	return false
+	return filtercore.MatchesModel(routedModel, v.MirrorToTemplateKwargsForModels)
 }
 
 func mirrorThinkingToTemplateKwargs(document map[string]any, enabled bool) error {
diff --git a/devshard/cmd/devshardctl/paramvalidators/thinking_token_budget.go b/devshard/cmd/devshardctl/paramvalidators/thinking_token_budget.go
deleted file mode 100644
index c78e87f333..0000000000
--- a/devshard/cmd/devshardctl/paramvalidators/thinking_token_budget.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package paramvalidators
-
-// ThinkingTokenBudgetDefaultsValidator injects a default `thinking_token_budget` derived
-// from `max_tokens` when the client did not supply one. Model routing is the catalog's
-// concern — wrap this validator in a ModelScopedParameterHandler.
-type ThinkingTokenBudgetDefaultsValidator struct {
-	DefaultDivisor uint64
-}
-
-func (v ThinkingTokenBudgetDefaultsValidator) Validate(vctx ValidatorContext) error {
-	if _, exists := vctx.Document["thinking_token_budget"]; exists {
-		return nil
-	}
-	maxTokens, ok := numericAsUint64(vctx.Document["max_tokens"])
-	if !ok || maxTokens == 0 {
-		return nil
-	}
-	value := maxTokens
-	if v.DefaultDivisor > 0 {
-		value = maxTokens / v.DefaultDivisor
-	}
-	vctx.Document["thinking_token_budget"] = value
-	return nil
-}
diff --git a/devshard/cmd/devshardctl/paramvalidators/thinking_token_budget_test.go b/devshard/cmd/devshardctl/paramvalidators/thinking_token_budget_test.go
deleted file mode 100644
index 6f78d7b51d..0000000000
--- a/devshard/cmd/devshardctl/paramvalidators/thinking_token_budget_test.go
+++ /dev/null
@@ -1,57 +0,0 @@
-package paramvalidators
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestThinkingTokenBudgetDefaultsValidator(t *testing.T) {
-	v := ThinkingTokenBudgetDefaultsValidator{DefaultDivisor: 2}
-
-	t.Run("injects default when absent", func(t *testing.T) {
-		doc := parseDocument(t, `{"max_tokens":4096}`)
-		require.NoError(t, v.Validate(ValidatorContext{Document: doc}))
-		require.EqualValues(t, 2048, doc["thinking_token_budget"])
-	})
-
-	t.Run("preserves client value when present", func(t *testing.T) {
-		doc := parseDocument(t, `{"max_tokens":4096,"thinking_token_budget":500}`)
-		require.NoError(t, v.Validate(ValidatorContext{Document: doc}))
-		require.Equal(t, json.Number("500"), doc["thinking_token_budget"])
-	})
-
-	t.Run("splits in half regardless of size", func(t *testing.T) {
-		doc := parseDocument(t, `{"max_tokens":400}`)
-		require.NoError(t, v.Validate(ValidatorContext{Document: doc}))
-		require.EqualValues(t, 200, doc["thinking_token_budget"])
-	})
-
-	t.Run("small max_tokens still leaves content room", func(t *testing.T) {
-		doc := parseDocument(t, `{"max_tokens":100}`)
-		require.NoError(t, v.Validate(ValidatorContext{Document: doc}))
-		require.EqualValues(t, 50, doc["thinking_token_budget"])
-	})
-
-	t.Run("skips when max_tokens absent", func(t *testing.T) {
-		doc := parseDocument(t, `{}`)
-		require.NoError(t, v.Validate(ValidatorContext{Document: doc}))
-		_, exists := doc["thinking_token_budget"]
-		require.False(t, exists)
-	})
-
-	t.Run("skips when max_tokens is zero", func(t *testing.T) {
-		doc := parseDocument(t, `{"max_tokens":0}`)
-		require.NoError(t, v.Validate(ValidatorContext{Document: doc}))
-		_, exists := doc["thinking_token_budget"]
-		require.False(t, exists)
-	})
-
-	t.Run("zero divisor uses max_tokens", func(t *testing.T) {
-		vZero := ThinkingTokenBudgetDefaultsValidator{DefaultDivisor: 0}
-		doc := parseDocument(t, `{"max_tokens":4096}`)
-		require.NoError(t, vZero.Validate(ValidatorContext{Document: doc}))
-		require.EqualValues(t, 4096, doc["thinking_token_budget"])
-	})
-}
diff --git a/devshard/cmd/devshardctl/paramvalidators/tool_choice.go b/devshard/cmd/devshardctl/paramvalidators/tool_choice.go
index 5fa634871b..8cc7e53b69 100644
--- a/devshard/cmd/devshardctl/paramvalidators/tool_choice.go
+++ b/devshard/cmd/devshardctl/paramvalidators/tool_choice.go
@@ -3,6 +3,7 @@ package paramvalidators
 import (
 	"errors"
 	"fmt"
+	"strings"
 )
 
 var (
@@ -37,7 +38,7 @@ func (v ToolChoiceValidator) Validate(vctx ValidatorContext) error {
 			return fmt.Errorf("%w: function must be an object", ErrToolChoiceFunctionShape)
 		}
 		name, ok := fn["name"].(string)
-		if !ok || name == "" {
+		if !ok || strings.TrimSpace(name) == "" {
 			return fmt.Errorf("%w: function.name must be a non-empty string", ErrToolChoiceFunctionShape)
 		}
 		if v.MaxNameLen > 0 && len(name) > v.MaxNameLen {
diff --git a/devshard/cmd/devshardctl/paramvalidators/tool_choice_test.go b/devshard/cmd/devshardctl/paramvalidators/tool_choice_test.go
index b9829d3135..9937f9da56 100644
--- a/devshard/cmd/devshardctl/paramvalidators/tool_choice_test.go
+++ b/devshard/cmd/devshardctl/paramvalidators/tool_choice_test.go
@@ -46,6 +46,7 @@ func TestToolChoiceValidatorRejects(t *testing.T) {
 		{name: "object function not object", body: `{"tool_choice":{"type":"function","function":"x"}}`, wantErr: ErrToolChoiceFunctionShape},
 		{name: "object missing name", body: `{"tool_choice":{"type":"function","function":{}}}`, wantErr: ErrToolChoiceFunctionShape},
 		{name: "object empty name", body: `{"tool_choice":{"type":"function","function":{"name":""}}}`, wantErr: ErrToolChoiceFunctionShape},
+		{name: "object whitespace name", body: `{"tool_choice":{"type":"function","function":{"name":"   "}}}`, wantErr: ErrToolChoiceFunctionShape},
 		{name: "object non-string name", body: `{"tool_choice":{"type":"function","function":{"name":42}}}`, wantErr: ErrToolChoiceFunctionShape},
 		{name: "name exceeds length cap", body: `{"tool_choice":{"type":"function","function":{"name":"` + longString(65) + `"}}}`, wantErr: ErrToolChoiceFunctionShape},
 	}
diff --git a/devshard/cmd/devshardctl/paramvalidators/tools.go b/devshard/cmd/devshardctl/paramvalidators/tools.go
index 5856bb760c..4311639d6e 100644
--- a/devshard/cmd/devshardctl/paramvalidators/tools.go
+++ b/devshard/cmd/devshardctl/paramvalidators/tools.go
@@ -3,6 +3,7 @@ package paramvalidators
 import (
 	"errors"
 	"fmt"
+	"strings"
 )
 
 // Tool-specific sentinels. Schema-walk rejections (depth/nodes/ref/enum/branch/size) flow
@@ -80,7 +81,7 @@ func (v ToolsValidator) Validate(vctx ValidatorContext) error {
 			return fmt.Errorf("%w: tools[%d].function must be an object", ErrToolFunctionShape, i)
 		}
 		name, ok := fn["name"].(string)
-		if !ok || name == "" {
+		if !ok || strings.TrimSpace(name) == "" {
 			return fmt.Errorf("%w (tools[%d])", ErrToolFunctionName, i)
 		}
 		// OpenAI Structured Outputs flag. vLLM accepts but does not honor it
diff --git a/devshard/cmd/devshardctl/paramvalidators/tools_test.go b/devshard/cmd/devshardctl/paramvalidators/tools_test.go
index 7ab4291650..74750a8450 100644
--- a/devshard/cmd/devshardctl/paramvalidators/tools_test.go
+++ b/devshard/cmd/devshardctl/paramvalidators/tools_test.go
@@ -65,6 +65,7 @@ func TestToolsValidatorRejects(t *testing.T) {
 		// function.name required.
 		{name: "function name missing", body: `{"tools":[{"type":"function","function":{}}]}`, wantErr: ErrToolFunctionName},
 		{name: "function name empty", body: `{"tools":[{"type":"function","function":{"name":""}}]}`, wantErr: ErrToolFunctionName},
+		{name: "function name whitespace", body: `{"tools":[{"type":"function","function":{"name":"   "}}]}`, wantErr: ErrToolFunctionName},
 		{name: "function name not a string", body: `{"tools":[{"type":"function","function":{"name":42}}]}`, wantErr: ErrToolFunctionName},
 		{name: "depth exceeds limit", body: `{"tools":[` + toolWithParams(nestedPropertiesSchema(17)) + `]}`, wantErr: ErrSchemaDepth},
 		{name: "deep recursion attack hidden in tool", body: `{"tools":[` + toolWithParams(nestedPropertiesSchema(200)) + `]}`, wantErr: ErrSchemaDepth},
diff --git a/devshard/cmd/devshardctl/paramvalidators/validate_test.go b/devshard/cmd/devshardctl/paramvalidators/validate_test.go
new file mode 100644
index 0000000000..0445bbbe63
--- /dev/null
+++ b/devshard/cmd/devshardctl/paramvalidators/validate_test.go
@@ -0,0 +1,102 @@
+package paramvalidators
+
+import (
+	"strings"
+	"testing"
+)
+
+// ============================================================
+// RejectNumberParameter
+// ============================================================
+
+func TestRejectNumberParameter(t *testing.T) {
+	positive := RejectNumberParameter{Allow: func(v float64) bool { return v > 0 }, Message: "must be greater than 0"}
+
+	// Absent and non-numeric values pass through — dedicated shape validators own those.
+	if err := run(positive, map[string]any{}, "top_p"); err != nil {
+		t.Fatalf("absent field must pass through, got %v", err)
+	}
+	if err := run(positive, map[string]any{"top_p": "not-a-number"}, "top_p"); err != nil {
+		t.Fatalf("non-numeric must pass through, got %v", err)
+	}
+	if err := run(positive, map[string]any{"top_p": 0.5}, "top_p"); err != nil {
+		t.Fatalf("allowed value must pass, got %v", err)
+	}
+
+	err := run(positive, map[string]any{"top_p": 0}, "top_p")
+	if err == nil || !strings.Contains(err.Error(), "top_p") || !strings.Contains(err.Error(), "greater than 0") {
+		t.Fatalf("non-positive must be rejected with a field-named error, got %v", err)
+	}
+}
+
+func TestRejectNumberParameter_TopKPredicate(t *testing.T) {
+	topK := RejectNumberParameter{Allow: func(v float64) bool { return v == -1 || v >= 1 }, Message: "must be -1 or a positive integer"}
+	for _, good := range []any{-1, 1, 50} {
+		if err := run(topK, map[string]any{"top_k": good}, "top_k"); err != nil {
+			t.Fatalf("top_k=%v must pass, got %v", good, err)
+		}
+	}
+	for _, bad := range []any{0, -2} {
+		if err := run(topK, map[string]any{"top_k": bad}, "top_k"); err == nil {
+			t.Fatalf("top_k=%v must be rejected", bad)
+		}
+	}
+}
+
+// ============================================================
+// ValidateScalarParameter
+// ============================================================
+
+func TestValidateScalarParameter(t *testing.T) {
+	mustBeBool := ValidateScalarParameter{Valid: IsJSONBool, Message: "must be a boolean"}
+
+	// Absent or explicit null passes through.
+	if err := run(mustBeBool, map[string]any{}, "stream"); err != nil {
+		t.Fatalf("absent must pass, got %v", err)
+	}
+	if err := run(mustBeBool, map[string]any{"stream": nil}, "stream"); err != nil {
+		t.Fatalf("null must pass, got %v", err)
+	}
+	if err := run(mustBeBool, map[string]any{"stream": true}, "stream"); err != nil {
+		t.Fatalf("bool must pass, got %v", err)
+	}
+	if err := run(mustBeBool, map[string]any{"stream": "yes"}, "stream"); err == nil {
+		t.Fatal("non-bool must be rejected")
+	}
+}
+
+// ============================================================
+// ValidateListElementsParameter
+// ============================================================
+
+func TestValidateListElementsParameter(t *testing.T) {
+	elementsMustBeString := ValidateListElementsParameter{Valid: IsJSONString, Message: "must be a string"}
+
+	// Absent or non-array passes through.
+	if err := run(elementsMustBeString, map[string]any{}, "stop"); err != nil {
+		t.Fatalf("absent must pass, got %v", err)
+	}
+	if err := run(elementsMustBeString, map[string]any{"stop": "single"}, "stop"); err != nil {
+		t.Fatalf("non-array must pass, got %v", err)
+	}
+	if err := run(elementsMustBeString, map[string]any{"stop": []any{"a", "b"}}, "stop"); err != nil {
+		t.Fatalf("all-string array must pass, got %v", err)
+	}
+
+	err := run(elementsMustBeString, map[string]any{"stop": []any{"a", 5, "c"}}, "stop")
+	if err == nil || !strings.Contains(err.Error(), "stop[1]") {
+		t.Fatalf("bad element must be rejected with its index, got %v", err)
+	}
+}
+
+func TestJSONTypePredicates(t *testing.T) {
+	if !IsJSONBool(true) || IsJSONBool("x") {
+		t.Fatal("IsJSONBool")
+	}
+	if !IsJSONString("x") || IsJSONString(1) {
+		t.Fatal("IsJSONString")
+	}
+	if !IsJSONUint(5) || IsJSONUint(-1) || IsJSONUint(3.5) {
+		t.Fatal("IsJSONUint")
+	}
+}
diff --git a/devshard/cmd/devshardctl/participant_limiter.go b/devshard/cmd/devshardctl/participant_limiter.go
index d4cd07fcf1..510dcf7a7a 100644
--- a/devshard/cmd/devshardctl/participant_limiter.go
+++ b/devshard/cmd/devshardctl/participant_limiter.go
@@ -28,16 +28,14 @@ const (
 	// stalledWinnerQuarantine is used when a crowned winner emits some
 	// content, then goes silent long enough to fail the user-visible stream.
 	stalledWinnerQuarantine = 30 * time.Minute
-	// emptyStreamQuarantineThreshold is the number of consecutive empty
-	// content responses before the host is temporarily quarantined.
-	emptyStreamQuarantineThreshold = 3
-	// eofTransportFailureThreshold is the number of consecutive EOF-style
-	// inference transport failures before the host is temporarily quarantined.
-	eofTransportFailureThreshold = 3
-	// participantProbationSuccessesAfterQuarantine keeps recently recovered hosts
-	// out of proactive pairwise/A-B routing until they prove they can finish
-	// normal inference requests again.
-	participantProbationSuccessesAfterQuarantine = 3
+	// participantFailureStrikeThreshold is the unified per-model strike count
+	// where soft bad signals move from probation to quarantine.
+	participantFailureStrikeThreshold = 3
+	emptyStreamQuarantineThreshold    = participantFailureStrikeThreshold
+	eofTransportFailureThreshold      = participantFailureStrikeThreshold
+	// participantStrikesAfterQuarantine keeps recently recovered hosts one bad
+	// signal away from re-quarantine while they prove they can finish normally.
+	participantStrikesAfterQuarantine = participantFailureStrikeThreshold - 1
 	// participantStatusTransport is persisted in last_throttle_status when
 	// the last signal was a transport failure (not an HTTP 429/503).
 	participantStatusTransport = 0
@@ -52,11 +50,141 @@ const (
 	participantStatusEOFTransport = -3
 )
 
+type participantQuarantineMode int
+
+const (
+	participantQuarantineNone participantQuarantineMode = iota
+	participantQuarantineProbe
+	participantQuarantineShadow
+)
+
+func participantQuarantineModeFromStatus(status int) participantQuarantineMode {
+	switch status {
+	case participantStatusEmptyStream, participantStatusStalledWinner:
+		return participantQuarantineShadow
+	default:
+		return participantQuarantineProbe
+	}
+}
+
+func (m participantQuarantineMode) String() string {
+	switch m {
+	case participantQuarantineProbe:
+		return "probe"
+	case participantQuarantineShadow:
+		return "shadow"
+	default:
+		return ""
+	}
+}
+
+func normalizeModelID(modelID string) string {
+	return strings.TrimSpace(modelID)
+}
+
+func normalizeModelIDs(modelIDs []string) []string {
+	if len(modelIDs) == 0 {
+		return nil
+	}
+	seen := make(map[string]struct{}, len(modelIDs))
+	out := make([]string, 0, len(modelIDs))
+	for _, modelID := range modelIDs {
+		modelID = normalizeModelID(modelID)
+		if modelID == "" {
+			continue
+		}
+		if _, ok := seen[modelID]; ok {
+			continue
+		}
+		seen[modelID] = struct{}{}
+		out = append(out, modelID)
+	}
+	sort.Strings(out)
+	return out
+}
+
+func splitModelIDs(modelIDs string) []string {
+	modelIDs = strings.TrimSpace(modelIDs)
+	if modelIDs == "" {
+		return nil
+	}
+	return normalizeModelIDs(strings.Split(modelIDs, ","))
+}
+
+func modelIDSet(modelIDs []string) map[string]struct{} {
+	modelIDs = normalizeModelIDs(modelIDs)
+	if len(modelIDs) == 0 {
+		return nil
+	}
+	set := make(map[string]struct{}, len(modelIDs))
+	for _, modelID := range modelIDs {
+		set[modelID] = struct{}{}
+	}
+	return set
+}
+
+func modelIDsFromSet(set map[string]struct{}) []string {
+	if len(set) == 0 {
+		return nil
+	}
+	modelIDs := make([]string, 0, len(set))
+	for modelID := range set {
+		modelIDs = append(modelIDs, modelID)
+	}
+	sort.Strings(modelIDs)
+	return modelIDs
+}
+
+func stateAppliesToModel(state *participantRequestState, modelID string) bool {
+	if state == nil || len(state.modelIDs) == 0 {
+		return true
+	}
+	modelID = normalizeModelID(modelID)
+	if modelID == "" {
+		return true
+	}
+	_, ok := state.modelIDs[modelID]
+	return ok
+}
+
 var sharedParticipantRequestLimiter = NewParticipantRequestLimiter(
 	defaultParticipantRequestBurst,
 	defaultParticipantRequestRecoveryPerMinute,
 )
 
+type modelScopedParticipantAdmission struct {
+	limiter *ParticipantRequestLimiter
+	modelID string
+}
+
+func (a modelScopedParticipantAdmission) AllowRequest(participantKey, path string) error {
+	if a.limiter == nil {
+		return nil
+	}
+	return a.limiter.AllowRequestForModel(participantKey, a.modelID, path)
+}
+
+func (a modelScopedParticipantAdmission) ObserveResult(participantKey, path string, statusCode int) {
+	if a.limiter == nil {
+		return
+	}
+	a.limiter.ObserveResultForModel(participantKey, a.modelID, path, statusCode)
+}
+
+func (a modelScopedParticipantAdmission) ObserveResultWithBody(participantKey, path string, statusCode int, body string) {
+	if a.limiter == nil {
+		return
+	}
+	a.limiter.ObserveResultWithBodyForModel(participantKey, a.modelID, path, statusCode, body)
+}
+
+func (a modelScopedParticipantAdmission) ObserveTransportFailure(participantKey, path string, err error) {
+	if a.limiter == nil {
+		return
+	}
+	a.limiter.ObserveTransportFailureForModel(participantKey, a.modelID, path, err)
+}
+
 func DefaultParticipantThrottleSettings() ParticipantThrottleSettings {
 	return ParticipantThrottleSettings{
 		RequestBurst:                   defaultParticipantRequestBurst,
@@ -65,8 +193,8 @@ func DefaultParticipantThrottleSettings() ParticipantThrottleSettings {
 		TransportFailureQuarantineMS:   transportFailureQuarantine.Milliseconds(),
 		EmptyStreamQuarantineMS:        emptyStreamQuarantine.Milliseconds(),
 		StalledWinnerQuarantineMS:      stalledWinnerQuarantine.Milliseconds(),
-		EmptyStreamQuarantineThreshold: emptyStreamQuarantineThreshold,
-		EOFTransportFailureThreshold:   eofTransportFailureThreshold,
+		EmptyStreamQuarantineThreshold: participantFailureStrikeThreshold,
+		EOFTransportFailureThreshold:   participantFailureStrikeThreshold,
 	}
 }
 
@@ -96,52 +224,59 @@ func (e *EscrowParticipantRateLimitError) Error() string {
 
 // ParticipantThrottleStore is the persistence interface for reactive throttle state.
 type ParticipantThrottleStore interface {
-	SaveParticipantThrottle(key string, tokens float64, lastRefillAt time.Time, status int, quarantineUntil time.Time, emptyStreamStreak int, eofTransportFailureStreak int) error
+	SaveParticipantThrottle(key string, modelIDs []string, tokens float64, lastRefillAt time.Time, status int, quarantineUntil time.Time, failureStrikes int) error
 	DeleteParticipantThrottle(key string) error
 }
 
-// ParticipantRequestLimiter is a reactive, per-host limiter. After 429/503
-// the host is quarantined for the configured HTTP throttle duration; after
-// a transport failure (no HTTP response) or configured consecutive
-// empty-stream responses for the configured short quarantine. Longer of the
-// overlapping quarantines wins. Legacy rows without quarantine use the
-// token-bucket refill only.
+// ParticipantRequestLimiter is a reactive, per-host limiter. Probe quarantine
+// is no-send and burns silent probes; shadow quarantine still sends real
+// attempts but marks them no-winner. Longer of the overlapping quarantines
+// wins. Legacy rows without quarantine use the token-bucket refill only.
 type ParticipantRequestLimiter struct {
-	mu                             sync.Mutex
-	burst                          float64
-	recoveryPerSecond              float64
-	httpThrottleQuarantine         time.Duration
-	transportFailureQuarantine     time.Duration
-	emptyStreamQuarantine          time.Duration
-	stalledWinnerQuarantine        time.Duration
-	emptyStreamQuarantineThreshold int
-	eofTransportFailureThreshold   int
-	participants                   map[string]*participantRequestState
-	metrics                        *DevshardMetrics
-	store                          ParticipantThrottleStore
+	mu                         sync.Mutex
+	burst                      float64
+	recoveryPerSecond          float64
+	httpThrottleQuarantine     time.Duration
+	transportFailureQuarantine time.Duration
+	emptyStreamQuarantine      time.Duration
+	stalledWinnerQuarantine    time.Duration
+	failureStrikeThreshold     int
+	participants               map[string]*participantRequestState
+	metrics                    *DevshardMetrics
+	store                      ParticipantThrottleStore
 }
 
 type participantRequestState struct {
-	tokens                      float64
-	lastRefill                  time.Time
-	quarantineUntil             time.Time // non-zero: wall-clock unavailability
-	probationSuccessesRemaining int       // recently exited quarantine; not blocked
-	emptyStreamStreak           int
-	eofTransportFailureStreak   int
+	tokens          float64
+	lastRefill      time.Time
+	modelIDs        map[string]struct{} // empty means all models / legacy global
+	quarantineUntil time.Time           // non-zero: wall-clock unavailability
+	quarantineMode  participantQuarantineMode
+	failureStrikes  int
 }
 
 type ParticipantThrottleSnapshot struct {
-	Tracked               bool    `json:"tracked"`
-	Quarantined           bool    `json:"quarantined"`
-	Blocked               bool    `json:"blocked"`
-	RequestAllowed        bool    `json:"request_allowed"`
-	AvailableForCapacity  bool    `json:"available_for_capacity"`
-	Tokens                float64 `json:"tokens"`
-	Burst                 float64 `json:"burst"`
-	QuarantineUntil       string  `json:"quarantine_until,omitempty"`
-	QuarantineRemainingMS int64   `json:"quarantine_remaining_ms,omitempty"`
-	EmptyStreamStreak     int     `json:"empty_stream_streak,omitempty"`
-	EOFTransportStreak    int     `json:"eof_transport_failure_streak,omitempty"`
+	Tracked               bool     `json:"tracked"`
+	Quarantined           bool     `json:"quarantined"`
+	Blocked               bool     `json:"blocked"`
+	RequestAllowed        bool     `json:"request_allowed"`
+	AvailableForCapacity  bool     `json:"available_for_capacity"`
+	QuarantineMode        string   `json:"quarantine_mode,omitempty"`
+	ModelIDs              []string `json:"model_ids,omitempty"`
+	ShadowQuarantined     bool     `json:"shadow_quarantined,omitempty"`
+	ProbeQuarantined      bool     `json:"probe_quarantined,omitempty"`
+	Probationary          bool     `json:"probationary,omitempty"`
+	Tokens                float64  `json:"tokens"`
+	Burst                 float64  `json:"burst"`
+	QuarantineUntil       string   `json:"quarantine_until,omitempty"`
+	QuarantineRemainingMS int64    `json:"quarantine_remaining_ms,omitempty"`
+	FailureStrikes        int      `json:"failure_strikes,omitempty"`
+}
+
+type participantNoWinnerStatus struct {
+	reason         string
+	quarantineMode string
+	failureStrikes int
 }
 
 func NewParticipantRequestLimiter(burst int, recoveryPerMinute int) *ParticipantRequestLimiter {
@@ -197,8 +332,10 @@ func (l *ParticipantRequestLimiter) applySettingsLocked(settings ParticipantThro
 	l.transportFailureQuarantine = time.Duration(settings.TransportFailureQuarantineMS) * time.Millisecond
 	l.emptyStreamQuarantine = time.Duration(settings.EmptyStreamQuarantineMS) * time.Millisecond
 	l.stalledWinnerQuarantine = time.Duration(settings.StalledWinnerQuarantineMS) * time.Millisecond
-	l.emptyStreamQuarantineThreshold = settings.EmptyStreamQuarantineThreshold
-	l.eofTransportFailureThreshold = settings.EOFTransportFailureThreshold
+	l.failureStrikeThreshold = settings.EmptyStreamQuarantineThreshold
+	if settings.EOFTransportFailureThreshold < l.failureStrikeThreshold {
+		l.failureStrikeThreshold = settings.EOFTransportFailureThreshold
+	}
 	for _, state := range l.participants {
 		if state.tokens > l.burst {
 			state.tokens = l.burst
@@ -210,12 +347,12 @@ func (l *ParticipantRequestLimiter) applySettingsLocked(settings ParticipantThro
 // Time-based recovery since lastRefill is applied. If the participant has fully
 // recovered (tokens >= burst), the record is deleted from the store instead.
 func (l *ParticipantRequestLimiter) LoadState(key string, tokens float64, lastRefill time.Time) {
-	l.LoadStateWithQuarantine(key, tokens, lastRefill, 0, time.Time{}, 0, 0)
+	l.LoadStateWithQuarantine(key, nil, tokens, lastRefill, 0, time.Time{}, 0)
 }
 
 // LoadStateWithQuarantine is like LoadState but supports persisted quarantine
 // and upgrades legacy 429/503 rows to a quarantine end time when needed.
-func (l *ParticipantRequestLimiter) LoadStateWithQuarantine(key string, tokens float64, lastRefill time.Time, status int, quarantineFromDB time.Time, emptyStreamStreak int, eofTransportFailureStreak int) {
+func (l *ParticipantRequestLimiter) LoadStateWithQuarantine(key string, modelIDs []string, tokens float64, lastRefill time.Time, status int, quarantineFromDB time.Time, failureStrikes int) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
@@ -223,31 +360,36 @@ func (l *ParticipantRequestLimiter) LoadStateWithQuarantine(key string, tokens f
 
 	if !quarantineFromDB.IsZero() {
 		if now.Before(quarantineFromDB) {
+			if failureStrikes < l.failureStrikeThreshold {
+				failureStrikes = l.failureStrikeThreshold
+			}
 			l.participants[key] = &participantRequestState{
-				tokens:                    0,
-				lastRefill:                now,
-				quarantineUntil:           quarantineFromDB,
-				emptyStreamStreak:         emptyStreamStreak,
-				eofTransportFailureStreak: eofTransportFailureStreak,
+				tokens:          0,
+				lastRefill:      now,
+				modelIDs:        modelIDSet(modelIDs),
+				quarantineUntil: quarantineFromDB,
+				quarantineMode:  participantQuarantineModeFromStatus(status),
+				failureStrikes:  failureStrikes,
 			}
 			log.Printf("participant_limit_loaded_from_db participant_key=%s quarantine_until=%s", key, quarantineFromDB.Format(time.RFC3339))
 			return
 		}
-		// already expired; drop persisted row
-		if l.store != nil {
-			if err := l.store.DeleteParticipantThrottle(key); err != nil {
-				log.Printf("participant_throttle_cleanup_failed participant_key=%s error=%v", key, err)
-			}
+		// Already expired; resume in persisted probation instead of deleting
+		// so rebooting cannot bypass the post-quarantine proof period.
+		if failureStrikes < participantStrikesAfterQuarantine {
+			failureStrikes = participantStrikesAfterQuarantine
 		}
+		tokens = l.burst
+		quarantineFromDB = time.Time{}
+		status = participantStatusTransport
 		log.Printf("participant_limit_stale_on_load participant_key=%s", key)
-		return
 	}
 
 	elapsed := now.Sub(lastRefill).Seconds()
 	if elapsed > 0 {
 		tokens += elapsed * l.recoveryPerSecond
 	}
-	if tokens >= l.burst && emptyStreamStreak == 0 && eofTransportFailureStreak == 0 {
+	if tokens >= l.burst && failureStrikes == 0 {
 		if l.store != nil {
 			if err := l.store.DeleteParticipantThrottle(key); err != nil {
 				log.Printf("participant_throttle_cleanup_failed participant_key=%s error=%v", key, err)
@@ -258,11 +400,12 @@ func (l *ParticipantRequestLimiter) LoadStateWithQuarantine(key string, tokens f
 	}
 
 	st := &participantRequestState{
-		tokens:                    tokens,
-		lastRefill:                now,
-		quarantineUntil:           time.Time{},
-		emptyStreamStreak:         emptyStreamStreak,
-		eofTransportFailureStreak: eofTransportFailureStreak,
+		tokens:          tokens,
+		lastRefill:      now,
+		modelIDs:        modelIDSet(modelIDs),
+		quarantineUntil: time.Time{},
+		quarantineMode:  participantQuarantineNone,
+		failureStrikes:  failureStrikes,
 	}
 	// Legacy rows from 429/503: time-to-full (token refill) approximates the old
 	// IsAvailable horizon; cap at 60m.
@@ -274,6 +417,7 @@ func (l *ParticipantRequestLimiter) LoadStateWithQuarantine(key string, tokens f
 				toFull = l.httpThrottleQuarantine
 			}
 			st.quarantineUntil = now.Add(toFull)
+			st.quarantineMode = participantQuarantineProbe
 		}
 	}
 	l.participants[key] = st
@@ -293,23 +437,31 @@ func (l *ParticipantRequestLimiter) SetStore(store ParticipantThrottleStore) {
 // when capacity-aware mode is on we keep the reactive throttle active
 // and rely on CapacityState-driven scaling for relief instead.
 func (l *ParticipantRequestLimiter) AllowRequest(participantKey, _ string) error {
+	return l.AllowRequestForModel(participantKey, "", "")
+}
+
+func (l *ParticipantRequestLimiter) AllowRequestForModel(participantKey, modelID, _ string) error {
 	if participantKey == "" {
 		return nil
 	}
 	if !capacityAwareLimitsEnabled() && relaxedPoCBypassActive() {
 		return nil
 	}
-	if l.allow(participantKey, time.Now()) {
+	if l.allowForModel(participantKey, modelID, time.Now()) {
 		return nil
 	}
 	if l.metrics != nil {
-		l.metrics.RecordParticipantLimitRejection("transport_request")
+		l.metrics.RecordParticipantLimitRejection(participantKey, normalizeModelID(modelID), "transport_request")
 	}
 	log.Printf("participant_limit_rejected participant_key=%s", participantKey)
 	return &ParticipantRateLimitError{ParticipantKey: participantKey}
 }
 
 func (l *ParticipantRequestLimiter) allow(participantKey string, now time.Time) bool {
+	return l.allowForModel(participantKey, "", now)
+}
+
+func (l *ParticipantRequestLimiter) allowForModel(participantKey string, modelID string, now time.Time) bool {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
@@ -322,15 +474,18 @@ func (l *ParticipantRequestLimiter) allow(participantKey string, now time.Time)
 		return true
 	}
 	state = l.participants[participantKey]
+	if !stateAppliesToModel(state, modelID) {
+		return true
+	}
 
-	if l.inQuarantineLocked(state, now) {
+	if l.inProbeQuarantineLocked(state, now) {
 		return false
 	}
+	if l.inShadowQuarantineLocked(state, now) {
+		return true
+	}
 	l.refillLocked(state, now)
 	if state.tokens >= l.burst {
-		if state.emptyStreamStreak > 0 || state.eofTransportFailureStreak > 0 {
-			return true
-		}
 		if l.probationActiveLocked(state) {
 			return true
 		}
@@ -362,15 +517,23 @@ func (l *ParticipantRequestLimiter) CanAcceptEscrow(participantKeys []string) er
 }
 
 func (l *ParticipantRequestLimiter) ObserveResult(participantKey, path string, statusCode int) {
-	l.ObserveResultWithBody(participantKey, path, statusCode, "")
+	l.ObserveResultWithBodyForModel(participantKey, "", path, statusCode, "")
 }
 
 func (l *ParticipantRequestLimiter) ObserveResultWithBody(participantKey, path string, statusCode int, body string) {
+	l.ObserveResultWithBodyForModel(participantKey, "", path, statusCode, body)
+}
+
+func (l *ParticipantRequestLimiter) ObserveResultForModel(participantKey, modelID, path string, statusCode int) {
+	l.ObserveResultWithBodyForModel(participantKey, modelID, path, statusCode, "")
+}
+
+func (l *ParticipantRequestLimiter) ObserveResultWithBodyForModel(participantKey, modelID, path string, statusCode int, body string) {
 	if participantKey == "" || statusCode <= 0 {
 		return
 	}
 	if l.metrics != nil && statusCode >= http.StatusBadRequest {
-		l.metrics.RecordParticipantTransportError(participantPathKind(path), statusCode)
+		l.metrics.RecordParticipantTransportError(participantKey, normalizeModelID(modelID), participantPathKind(path), statusCode)
 	}
 	quarantineFor := l.participantHTTPQuarantine(path, statusCode, body)
 	if quarantineFor == 0 {
@@ -380,11 +543,8 @@ func (l *ParticipantRequestLimiter) ObserveResultWithBody(participantKey, path s
 	now := time.Now()
 	l.mu.Lock()
 	defer l.mu.Unlock()
-	l.applyQuarantineLocked(participantKey, now.Add(quarantineFor), now)
-	if st := l.participants[participantKey]; st != nil {
-		st.emptyStreamStreak = 0
-		st.eofTransportFailureStreak = 0
-	}
+	l.applyQuarantineLocked(participantKey, modelID, now.Add(quarantineFor), now, participantQuarantineProbe)
+	l.recordQuarantineTransition(participantKey, modelID, participantQuarantineProbe.String(), participantHTTPQuarantineReason(path, statusCode, body))
 
 	log.Printf("participant_limit_activated participant_key=%s status=%d path_kind=%s",
 		participantKey, statusCode, participantPathKind(path))
@@ -397,12 +557,16 @@ func (l *ParticipantRequestLimiter) ObserveResultWithBody(participantKey, path s
 // quarantine. EOF-style inference failures require consecutive strikes; other
 // inference transport failures still quarantine immediately.
 func (l *ParticipantRequestLimiter) ObserveTransportFailure(participantKey, path string, err error) {
+	l.ObserveTransportFailureForModel(participantKey, "", path, err)
+}
+
+func (l *ParticipantRequestLimiter) ObserveTransportFailureForModel(participantKey, modelID, path string, err error) {
 	if participantKey == "" {
 		return
 	}
 	kind := participantPathKind(path)
 	if l.metrics != nil {
-		l.metrics.RecordParticipantTransportError(kind, 0)
+		l.metrics.RecordParticipantTransportError(participantKey, normalizeModelID(modelID), kind, 0)
 	}
 	if kind != "inference" {
 		log.Printf("participant_transport_failure_ignored participant_key=%s path_kind=%s error=%q",
@@ -423,27 +587,24 @@ func (l *ParticipantRequestLimiter) ObserveTransportFailure(participantKey, path
 		if l.inQuarantineLocked(state, now) {
 			return
 		}
-		state.eofTransportFailureStreak++
-		if state.eofTransportFailureStreak >= l.eofTransportFailureThreshold {
-			l.applyQuarantineLocked(participantKey, now.Add(l.transportFailureQuarantine), now)
-			state.eofTransportFailureStreak = 0
-			state.emptyStreamStreak = 0
-			log.Printf("participant_limit_eof_transport_quarantine participant_key=%s threshold=%d error=%q",
-				participantKey, l.eofTransportFailureThreshold, truncateError(err))
+		l.addModelLocked(state, modelID)
+		state.failureStrikes++
+		if state.failureStrikes >= l.failureStrikeThreshold {
+			l.applyQuarantineLocked(participantKey, modelID, now.Add(l.transportFailureQuarantine), now, participantQuarantineProbe)
+			l.recordQuarantineTransition(participantKey, modelID, participantQuarantineProbe.String(), "eof_transport_quarantine")
+			log.Printf("participant_limit_eof_transport_quarantine participant_key=%s model_id=%q reason=eof_transport strikes=%d threshold=%d quarantine_mode=%s error=%q",
+				participantKey, normalizeModelID(modelID), state.failureStrikes, l.failureStrikeThreshold, participantQuarantineProbe.String(), truncateError(err))
 			l.persistThrottledStateLocked(participantKey, state, participantStatusEOFTransport)
 			return
 		}
-		log.Printf("participant_limit_eof_transport_streak participant_key=%s streak=%d error=%q",
-			participantKey, state.eofTransportFailureStreak, truncateError(err))
+		log.Printf("participant_limit_eof_transport_streak participant_key=%s model_id=%q reason=eof_transport strikes=%d threshold=%d error=%q",
+			participantKey, normalizeModelID(modelID), state.failureStrikes, l.failureStrikeThreshold, truncateError(err))
 		l.persistThrottledStateLocked(participantKey, state, participantStatusEOFTransport)
 		return
 	}
 
-	l.applyQuarantineLocked(participantKey, now.Add(l.transportFailureQuarantine), now)
-	if st := l.participants[participantKey]; st != nil {
-		st.emptyStreamStreak = 0
-		st.eofTransportFailureStreak = 0
-	}
+	l.applyQuarantineLocked(participantKey, modelID, now.Add(l.transportFailureQuarantine), now, participantQuarantineProbe)
+	l.recordQuarantineTransition(participantKey, modelID, participantQuarantineProbe.String(), "transport_failure_quarantine")
 	log.Printf("participant_limit_transport_failure participant_key=%s path_kind=%s error=%q",
 		participantKey, kind, truncateError(err))
 	l.persistThrottledStateLocked(participantKey, l.participants[participantKey], participantStatusTransport)
@@ -470,10 +631,23 @@ func truncateError(err error) string {
 	return s
 }
 
-// ObserveEmptyStream increments the consecutive empty-stream streak for a
-// participant. On the third consecutive strike, the participant enters the
-// short quarantine and the streak resets to zero.
+// ObserveModelBurnEmpty: empty stream caused by model behavior, not host
+// fault. Telemetry-only — no streak, no quarantine.
+func (l *ParticipantRequestLimiter) ObserveModelBurnEmpty(participantKey, modelID string) {
+	if participantKey == "" {
+		return
+	}
+	log.Printf("participant_limit_model_burn_empty participant_key=%s model_id=%q", participantKey, normalizeModelID(modelID))
+}
+
+// ObserveEmptyStream increments the unified failure-strike counter for a
+// participant. On the threshold strike, the participant enters shadow
+// quarantine.
 func (l *ParticipantRequestLimiter) ObserveEmptyStream(participantKey string) {
+	l.ObserveEmptyStreamForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) ObserveEmptyStreamForModel(participantKey, modelID string) {
 	if participantKey == "" {
 		return
 	}
@@ -490,16 +664,18 @@ func (l *ParticipantRequestLimiter) ObserveEmptyStream(participantKey string) {
 	if l.inQuarantineLocked(state, now) {
 		return
 	}
-	state.emptyStreamStreak++
-	if state.emptyStreamStreak >= l.emptyStreamQuarantineThreshold {
-		l.applyQuarantineLocked(participantKey, now.Add(l.emptyStreamQuarantine), now)
-		state.emptyStreamStreak = 0
-		state.eofTransportFailureStreak = 0
-		log.Printf("participant_limit_empty_stream_quarantine participant_key=%s threshold=%d", participantKey, l.emptyStreamQuarantineThreshold)
+	l.addModelLocked(state, modelID)
+	state.failureStrikes++
+	if state.failureStrikes >= l.failureStrikeThreshold {
+		l.applyQuarantineLocked(participantKey, modelID, now.Add(l.emptyStreamQuarantine), now, participantQuarantineShadow)
+		l.recordQuarantineTransition(participantKey, modelID, participantQuarantineShadow.String(), "empty_stream_quarantine")
+		log.Printf("participant_limit_empty_stream_quarantine participant_key=%s model_id=%q reason=empty_stream strikes=%d threshold=%d quarantine_mode=%s",
+			participantKey, normalizeModelID(modelID), state.failureStrikes, l.failureStrikeThreshold, participantQuarantineShadow.String())
 		l.persistThrottledStateLocked(participantKey, state, participantStatusEmptyStream)
 		return
 	}
-	log.Printf("participant_limit_empty_stream_streak participant_key=%s streak=%d", participantKey, state.emptyStreamStreak)
+	log.Printf("participant_limit_empty_stream_streak participant_key=%s model_id=%q reason=empty_stream strikes=%d threshold=%d",
+		participantKey, normalizeModelID(modelID), state.failureStrikes, l.failureStrikeThreshold)
 	l.persistThrottledStateLocked(participantKey, state, participantStatusEmptyStream)
 }
 
@@ -508,6 +684,10 @@ func (l *ParticipantRequestLimiter) ObserveEmptyStream(participantKey string) {
 // short quarantine because it is user-visible breakage, not just a loser-side
 // transport blip.
 func (l *ParticipantRequestLimiter) ObserveStalledWinner(participantKey string) {
+	l.ObserveStalledWinnerForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) ObserveStalledWinnerForModel(participantKey, modelID string) {
 	if participantKey == "" {
 		return
 	}
@@ -516,16 +696,19 @@ func (l *ParticipantRequestLimiter) ObserveStalledWinner(participantKey string)
 	defer l.mu.Unlock()
 
 	state := l.ensureStateLocked(participantKey, now)
-	l.applyQuarantineLocked(participantKey, now.Add(l.stalledWinnerQuarantine), now)
-	state.emptyStreamStreak = 0
-	state.eofTransportFailureStreak = 0
+	l.applyQuarantineLocked(participantKey, modelID, now.Add(l.stalledWinnerQuarantine), now, participantQuarantineShadow)
+	l.recordQuarantineTransition(participantKey, modelID, participantQuarantineShadow.String(), "stalled_winner_quarantine")
 	log.Printf("participant_limit_stalled_winner_quarantine participant_key=%s", participantKey)
 	l.persistThrottledStateLocked(participantKey, state, participantStatusStalledWinner)
 }
 
-// ObserveSuccessfulInference clears accumulated soft-failure streaks and
-// advances post-quarantine probation after a good finished response.
+// ObserveSuccessfulInference decrements the unified failure-strike counter after
+// a good finished response. When the counter reaches zero, probation ends.
 func (l *ParticipantRequestLimiter) ObserveSuccessfulInference(participantKey string) {
+	l.ObserveSuccessfulInferenceForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) ObserveSuccessfulInferenceForModel(participantKey, modelID string) {
 	if participantKey == "" {
 		return
 	}
@@ -542,16 +725,17 @@ func (l *ParticipantRequestLimiter) ObserveSuccessfulInference(participantKey st
 	if !ok {
 		return
 	}
-	if state.emptyStreamStreak == 0 && state.eofTransportFailureStreak == 0 && state.probationSuccessesRemaining == 0 {
+	if !stateAppliesToModel(state, modelID) {
+		return
+	}
+	if state.failureStrikes == 0 {
 		return
 	}
-	state.emptyStreamStreak = 0
-	state.eofTransportFailureStreak = 0
-	if state.probationSuccessesRemaining > 0 {
-		state.probationSuccessesRemaining--
+	if state.failureStrikes > 0 {
+		state.failureStrikes--
 	}
 	if state.tokens >= l.burst && state.quarantineUntil.IsZero() {
-		if state.probationSuccessesRemaining > 0 {
+		if state.failureStrikes > 0 {
 			return
 		}
 		delete(l.participants, participantKey)
@@ -579,10 +763,9 @@ func (l *ParticipantRequestLimiter) ClearQuarantine(participantKey string) bool
 	state.tokens = l.burst
 	state.lastRefill = now
 	state.quarantineUntil = time.Time{}
-	state.emptyStreamStreak = 0
-	state.eofTransportFailureStreak = 0
-	state.probationSuccessesRemaining = participantProbationSuccessesAfterQuarantine
-	l.persistDeleteLocked(participantKey)
+	state.quarantineMode = participantQuarantineNone
+	state.failureStrikes = participantStrikesAfterQuarantine
+	l.persistThrottledStateLocked(participantKey, state, participantStatusTransport)
 	log.Printf("participant_quarantine_cleared participant_key=%s", participantKey)
 	return true
 }
@@ -620,10 +803,13 @@ func (l *ParticipantRequestLimiter) BlockedParticipants(participantKeys []string
 			continue
 		}
 		state = l.participants[key]
-		if l.inQuarantineLocked(state, now) {
+		if l.inProbeQuarantineLocked(state, now) {
 			blocked = append(blocked, key)
 			continue
 		}
+		if l.inShadowQuarantineLocked(state, now) {
+			continue
+		}
 		l.refillLocked(state, now)
 		if state.tokens < 1 {
 			blocked = append(blocked, key)
@@ -692,18 +878,25 @@ func (l *ParticipantRequestLimiter) Snapshot(participantKeys []string) map[strin
 		}
 
 		quarantined := l.inQuarantineLocked(state, now)
+		probeQuarantined := l.inProbeQuarantineLocked(state, now)
+		shadowQuarantined := l.inShadowQuarantineLocked(state, now)
+		probationary := l.probationActiveLocked(state)
 		if !quarantined {
 			l.refillLocked(state, now)
-			if state.tokens >= l.burst && state.emptyStreamStreak == 0 && state.eofTransportFailureStreak == 0 {
-				if l.probationActiveLocked(state) {
+			if state.tokens >= l.burst && state.failureStrikes == 0 {
+				if probationary {
 					snapshot := ParticipantThrottleSnapshot{
 						Tracked:              true,
 						Quarantined:          false,
 						Blocked:              false,
 						RequestAllowed:       true,
 						AvailableForCapacity: true,
+						ShadowQuarantined:    true,
+						Probationary:         true,
+						ModelIDs:             modelIDsFromSet(state.modelIDs),
 						Tokens:               state.tokens,
 						Burst:                l.burst,
+						FailureStrikes:       state.failureStrikes,
 					}
 					snapshots[key] = snapshot
 					continue
@@ -722,18 +915,22 @@ func (l *ParticipantRequestLimiter) Snapshot(participantKeys []string) map[strin
 				continue
 			}
 		}
-		blocked := quarantined || state.tokens < 1
-		available := !quarantined && (state.tokens >= l.burst || state.emptyStreamStreak > 0 || state.eofTransportFailureStreak > 0)
+		blocked := probeQuarantined || (!shadowQuarantined && state.tokens < 1)
+		available := !probeQuarantined && (shadowQuarantined || state.tokens >= l.burst || state.failureStrikes > 0)
 		snapshot := ParticipantThrottleSnapshot{
 			Tracked:              true,
 			Quarantined:          quarantined,
 			Blocked:              blocked,
 			RequestAllowed:       !blocked,
 			AvailableForCapacity: available,
+			QuarantineMode:       state.quarantineMode.String(),
+			ModelIDs:             modelIDsFromSet(state.modelIDs),
+			ShadowQuarantined:    shadowQuarantined,
+			ProbeQuarantined:     probeQuarantined,
+			Probationary:         probationary,
 			Tokens:               state.tokens,
 			Burst:                l.burst,
-			EmptyStreamStreak:    state.emptyStreamStreak,
-			EOFTransportStreak:   state.eofTransportFailureStreak,
+			FailureStrikes:       state.failureStrikes,
 		}
 		if quarantined {
 			snapshot.QuarantineUntil = state.quarantineUntil.UTC().Format(time.RFC3339)
@@ -763,7 +960,7 @@ func (l *ParticipantRequestLimiter) persistThrottledStateLocked(key string, stat
 	if !state.quarantineUntil.IsZero() {
 		quar = state.quarantineUntil
 	}
-	if err := l.store.SaveParticipantThrottle(key, state.tokens, state.lastRefill, status, quar, state.emptyStreamStreak, state.eofTransportFailureStreak); err != nil {
+	if err := l.store.SaveParticipantThrottle(key, modelIDsFromSet(state.modelIDs), state.tokens, state.lastRefill, status, quar, state.failureStrikes); err != nil {
 		log.Printf("participant_throttle_persist_failed participant_key=%s error=%v", key, err)
 	}
 }
@@ -793,10 +990,13 @@ func (l *ParticipantRequestLimiter) ExhaustedCount() int {
 	}
 	n := 0
 	for _, state := range l.participants {
-		if l.inQuarantineLocked(state, now) {
+		if l.inProbeQuarantineLocked(state, now) {
 			n++
 			continue
 		}
+		if l.inShadowQuarantineLocked(state, now) {
+			continue
+		}
 		l.refillLocked(state, now)
 		if state.tokens < 1 {
 			n++
@@ -813,6 +1013,10 @@ func (l *ParticipantRequestLimiter) TrackedCount() int {
 }
 
 func (l *ParticipantRequestLimiter) IsRecentlyQuarantined(participantKey string) bool {
+	return l.IsRecentlyQuarantinedForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) IsRecentlyQuarantinedForModel(participantKey, modelID string) bool {
 	if participantKey == "" {
 		return false
 	}
@@ -829,19 +1033,71 @@ func (l *ParticipantRequestLimiter) IsRecentlyQuarantined(participantKey string)
 	if !tracked {
 		return false
 	}
+	if !stateAppliesToModel(state, modelID) {
+		return false
+	}
 	if l.inQuarantineLocked(state, now) {
 		return true
 	}
+	return l.probationActiveLocked(state)
+}
+
+// IsShadowQuarantined reports whether the participant should receive only
+// no-winner attempts. That includes temporary shadow quarantine and the
+// post-quarantine probation window.
+func (l *ParticipantRequestLimiter) IsShadowQuarantined(participantKey string) bool {
+	return l.IsShadowQuarantinedForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) IsShadowQuarantinedForModel(participantKey, modelID string) bool {
+	_, ok := l.NoWinnerStatusForModel(participantKey, modelID)
+	return ok
+}
+
+func (l *ParticipantRequestLimiter) NoWinnerStatusForModel(participantKey, modelID string) (participantNoWinnerStatus, bool) {
+	if participantKey == "" {
+		return participantNoWinnerStatus{}, false
+	}
+	now := time.Now()
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	state, tracked := l.participants[participantKey]
+	if !tracked {
+		return participantNoWinnerStatus{}, false
+	}
+	l.clearExpiredQuarantineIfAnyLocked(participantKey, state, now)
+	state, tracked = l.participants[participantKey]
+	if !tracked {
+		return participantNoWinnerStatus{}, false
+	}
+	if !stateAppliesToModel(state, modelID) {
+		return participantNoWinnerStatus{}, false
+	}
+	if l.inShadowQuarantineLocked(state, now) {
+		return participantNoWinnerStatus{
+			reason:         "shadow_quarantine",
+			quarantineMode: participantQuarantineShadow.String(),
+			failureStrikes: state.failureStrikes,
+		}, true
+	}
 	if l.probationActiveLocked(state) {
-		return true
+		return participantNoWinnerStatus{
+			reason:         "probation",
+			failureStrikes: state.failureStrikes,
+		}, true
 	}
-	return false
+	return participantNoWinnerStatus{}, false
 }
 
 // IsAvailable reports whether the participant is currently considered
 // available for capacity-aware routing. During quarantine the host is
 // unavailable; after legacy refills, full burst means available.
 func (l *ParticipantRequestLimiter) IsAvailable(participantKey string) bool {
+	return l.IsAvailableForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) IsAvailableForModel(participantKey, modelID string) bool {
 	if participantKey == "" {
 		return true
 	}
@@ -858,12 +1114,18 @@ func (l *ParticipantRequestLimiter) IsAvailable(participantKey string) bool {
 		return true
 	}
 	state = l.participants[participantKey]
-	if l.inQuarantineLocked(state, now) {
+	if !stateAppliesToModel(state, modelID) {
+		return true
+	}
+	if l.inProbeQuarantineLocked(state, now) {
 		return false
 	}
+	if l.inShadowQuarantineLocked(state, now) {
+		return true
+	}
 	l.refillLocked(state, now)
 	if state.tokens >= l.burst {
-		if state.emptyStreamStreak > 0 || state.eofTransportFailureStreak > 0 {
+		if state.failureStrikes > 0 {
 			return true
 		}
 		if l.probationActiveLocked(state) {
@@ -876,10 +1138,14 @@ func (l *ParticipantRequestLimiter) IsAvailable(participantKey string) bool {
 	return false
 }
 
-// IsBlocked reports whether AllowRequest would currently reject, or
-// the host is in quarantine (same unified notion for 429/503, transport
-// failure, and legacy token exhaustion).
+// IsBlocked reports whether AllowRequest would currently reject. Shadow
+// quarantine is intentionally not blocked: it still sends real attempts, but
+// redundancy marks them no-winner.
 func (l *ParticipantRequestLimiter) IsBlocked(participantKey string) bool {
+	return l.IsBlockedForModel(participantKey, "")
+}
+
+func (l *ParticipantRequestLimiter) IsBlockedForModel(participantKey, modelID string) bool {
 	if participantKey == "" {
 		return false
 	}
@@ -896,9 +1162,15 @@ func (l *ParticipantRequestLimiter) IsBlocked(participantKey string) bool {
 		return false
 	}
 	state = l.participants[participantKey]
-	if l.inQuarantineLocked(state, now) {
+	if !stateAppliesToModel(state, modelID) {
+		return false
+	}
+	if l.inProbeQuarantineLocked(state, now) {
 		return true
 	}
+	if l.inShadowQuarantineLocked(state, now) {
+		return false
+	}
 	l.refillLocked(state, now)
 	return state.tokens < 1
 }
@@ -907,18 +1179,48 @@ func (l *ParticipantRequestLimiter) inQuarantineLocked(state *participantRequest
 	return !state.quarantineUntil.IsZero() && now.Before(state.quarantineUntil)
 }
 
+func (l *ParticipantRequestLimiter) inProbeQuarantineLocked(state *participantRequestState, now time.Time) bool {
+	return l.inQuarantineLocked(state, now) && state.quarantineMode != participantQuarantineShadow
+}
+
+func (l *ParticipantRequestLimiter) inShadowQuarantineLocked(state *participantRequestState, now time.Time) bool {
+	return l.inQuarantineLocked(state, now) && state.quarantineMode == participantQuarantineShadow
+}
+
 func (l *ParticipantRequestLimiter) probationActiveLocked(state *participantRequestState) bool {
-	return state != nil && state.probationSuccessesRemaining > 0
+	return state != nil && state.failureStrikes > 0 && state.quarantineUntil.IsZero()
 }
 
-func (l *ParticipantRequestLimiter) applyQuarantineLocked(participantKey string, end time.Time, now time.Time) {
+func (l *ParticipantRequestLimiter) applyQuarantineLocked(participantKey, modelID string, end time.Time, now time.Time, mode participantQuarantineMode) {
 	st := l.ensureStateLocked(participantKey, now)
-	st.tokens = 0
+	l.addModelLocked(st, modelID)
+	if mode == participantQuarantineProbe {
+		st.tokens = 0
+	} else if st.tokens < l.burst {
+		st.tokens = l.burst
+	}
 	st.lastRefill = now
-	st.probationSuccessesRemaining = 0
+	if st.failureStrikes < l.failureStrikeThreshold {
+		st.failureStrikes = l.failureStrikeThreshold
+	}
 	if st.quarantineUntil.IsZero() || end.After(st.quarantineUntil) {
 		st.quarantineUntil = end
+		st.quarantineMode = mode
+	}
+}
+
+func (l *ParticipantRequestLimiter) addModelLocked(state *participantRequestState, modelID string) {
+	if state == nil {
+		return
+	}
+	modelID = normalizeModelID(modelID)
+	if modelID == "" || len(state.modelIDs) == 0 && state.quarantineMode != participantQuarantineNone {
+		return
+	}
+	if state.modelIDs == nil {
+		state.modelIDs = make(map[string]struct{}, 1)
 	}
+	state.modelIDs[modelID] = struct{}{}
 }
 
 func (l *ParticipantRequestLimiter) clearExpiredQuarantineIfAnyLocked(key string, state *participantRequestState, now time.Time) {
@@ -930,16 +1232,38 @@ func (l *ParticipantRequestLimiter) clearExpiredQuarantineIfAnyLocked(key string
 	}
 	if !state.quarantineUntil.IsZero() && !now.Before(state.quarantineUntil) {
 		state.quarantineUntil = time.Time{}
+		state.quarantineMode = participantQuarantineNone
 		state.tokens = l.burst
 		state.lastRefill = now
-		state.emptyStreamStreak = 0
-		state.eofTransportFailureStreak = 0
-		state.probationSuccessesRemaining = participantProbationSuccessesAfterQuarantine
-		l.persistDeleteLocked(key)
+		state.failureStrikes = participantStrikesAfterQuarantine
+		l.recordQuarantineTransition(key, "", "probation", "quarantine_expired")
+		l.persistThrottledStateLocked(key, state, participantStatusTransport)
 		log.Printf("participant_quarantine_ended participant_key=%s", key)
 	}
 }
 
+func (l *ParticipantRequestLimiter) recordQuarantineTransition(participantKey, modelID, mode, reason string) {
+	if l == nil || l.metrics == nil {
+		return
+	}
+	l.metrics.RecordGatewayQuarantineTransition(participantKey, normalizeModelID(modelID), mode, reason)
+}
+
+func participantHTTPQuarantineReason(path string, statusCode int, body string) string {
+	switch {
+	case isParticipantThrottleStatus(statusCode):
+		return "http_throttle_quarantine"
+	case statusCode == http.StatusUnauthorized && participantPathKind(path) == "inference" && strings.Contains(strings.ToLower(body), "timestamp drift"):
+		return "http_timestamp_drift"
+	case statusCode == http.StatusNotFound && participantPathKind(path) == "inference":
+		return "http_not_found"
+	case statusCode == http.StatusForbidden && participantPathKind(path) == "inference":
+		return "http_forbidden"
+	default:
+		return "transport_failure_quarantine"
+	}
+}
+
 func (l *ParticipantRequestLimiter) participantHTTPQuarantine(path string, statusCode int, body string) time.Duration {
 	switch {
 	case isParticipantThrottleStatus(statusCode):
diff --git a/devshard/cmd/devshardctl/phase_gate.go b/devshard/cmd/devshardctl/phase_gate.go
index b6801f9b6b..43607dcba0 100644
--- a/devshard/cmd/devshardctl/phase_gate.go
+++ b/devshard/cmd/devshardctl/phase_gate.go
@@ -1,10 +1,12 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
+	"maps"
 	"net/http"
 	"sort"
 	"strconv"
@@ -15,6 +17,10 @@ import (
 
 const (
 	defaultChainPhasePollInterval = 5 * time.Second
+	// versionsTTLPollMultiplier scales the poll interval into how long a
+	// /v1/versions fetch stays fresh, so entries survive a couple of missed polls
+	// but never outlive the poller's cadence.
+	versionsTTLPollMultiplier = 3
 
 	epochPhaseInference           = "Inference"
 	epochPhasePoCGenerate         = "PoCGenerate"
@@ -66,6 +72,9 @@ type ChainPhaseGate struct {
 	capacityState  *CapacityState
 	scaleApplyHook func(scale float64)
 
+	// versions polls each candidate miner's /v1/versions endpoint
+	versions *VersionsCache
+
 	stopCh chan struct{}
 	doneCh chan struct{}
 }
@@ -241,12 +250,14 @@ func NewChainPhaseGate(baseURL string, pollInterval time.Duration) *ChainPhaseGa
 	if pollInterval <= 0 {
 		pollInterval = defaultChainPhasePollInterval
 	}
+	client := &http.Client{Timeout: 5 * time.Second}
 	return &ChainPhaseGate{
 		endpoint:                      strings.TrimRight(baseURL, "/") + "/v1/epochs/latest",
 		participantsEndpoint:          strings.TrimRight(baseURL, "/") + "/v1/epochs/current/participants",
-		client:                        &http.Client{Timeout: 5 * time.Second},
+		client:                        client,
 		pollInterval:                  pollInterval,
 		defaultMaxSpeculativeAttempts: CurrentMaxSpeculativeAttempts(),
+		versions:                      NewVersionsCache(client, versionsTTLPollMultiplier*pollInterval),
 		stopCh:                        make(chan struct{}),
 		doneCh:                        make(chan struct{}),
 	}
@@ -269,6 +280,16 @@ func (g *ChainPhaseGate) Start() {
 	if g == nil {
 		return
 	}
+	if g.versions != nil {
+		// Derive a context whose lifetime matches the gate's stopCh so the
+		// versions poller stops cleanly without introducing a second lifecycle.
+		ctx, cancel := context.WithCancel(context.Background())
+		go func() {
+			<-g.stopCh
+			cancel()
+		}()
+		go g.versions.Run(ctx, g.pollInterval)
+	}
 	go g.run()
 }
 
@@ -388,26 +409,44 @@ func (g *ChainPhaseGate) refresh() {
 			g.recordError(perr)
 			g.logPreservedParticipantFetchFailure(snapshot, perr)
 		} else {
-			if needPreservedFetch {
-				setPoCPreservedParticipantsByModel(state.preservedByModel)
-				g.logPreservedParticipantsLoaded(snapshot, state.preserved, state.excluded)
+			// Keep the versions poller pointed at the current candidate set.
+			if g.versions != nil {
+				g.versions.SetCandidates(state.inferenceURLs)
 			}
-			if capacityState != nil {
-				// pocActive routes the observation: outside PoC it
-				// updates both fullWeights (steady-state baseline) and
-				// currentWeights, inside PoC it only nudges
-				// currentWeights so the live W_tot reflects PoC's
-				// transient drop while W_ref keeps the pre-PoC baseline.
-				capacityState.SetHostWeights(state.weights, active)
-				capacityState.SetHostWeightsByModel(state.weightsByModel, active)
-				if active && relaxedPoCModeEnabled() {
-					capacityState.SetPoCPreserved(state.preserved)
-				} else {
-					// Outside relaxed PoC every host is "preserved"
-					// from the limiter's perspective; nil tells the
-					// state to treat the preserved set as not-yet-loaded
-					// and therefore not block anyone on PoC grounds.
-					capacityState.SetPoCPreserved(nil)
+
+			isValidation := rawPoCValidationState(snapshot.EpochPhase, snapshot.ConfirmationPoCPhase)
+			if active && relaxedPoCModeEnabled() && isValidation && g.versions != nil {
+				preserved, preservedByModel, curWeights, curWeightsByModel :=
+					mergePreservedWithValidationCapable(state, g.versions.IsNodeValidationCapable)
+				if capacityState != nil {
+					capacityState.SetHostWeightViews(curWeights, state.fullWeights, curWeightsByModel, state.fullWeightsByModel)
+					capacityState.SetPoCPreserved(preserved)
+				}
+				if needPreservedFetch {
+					setPoCPreservedParticipantsByModel(preservedByModel)
+					g.logPreservedParticipantsLoaded(snapshot, preserved, state.excluded)
+				}
+			} else {
+				if needPreservedFetch {
+					setPoCPreservedParticipantsByModel(state.preservedByModel)
+					g.logPreservedParticipantsLoaded(snapshot, state.preserved, state.excluded)
+				}
+				if capacityState != nil {
+					// The participants response has enough ML-node data to compute
+					// both views on every poll: current is PoC/CPoC-filtered,
+					// full is the all-node steady-state baseline. Updating both
+					// prevents cold starts during PoC from falling back to unknown
+					// baseline capacity.
+					capacityState.SetHostWeightViews(state.weights, state.fullWeights, state.weightsByModel, state.fullWeightsByModel)
+					if active && relaxedPoCModeEnabled() {
+						capacityState.SetPoCPreserved(state.preserved)
+					} else {
+						// Outside relaxed PoC every host is "preserved"
+						// from the limiter's perspective; nil tells the
+						// state to treat the preserved set as not-yet-loaded
+						// and therefore not block anyone on PoC grounds.
+						capacityState.SetPoCPreserved(nil)
+					}
 				}
 			}
 		}
@@ -444,6 +483,13 @@ func (g *ChainPhaseGate) fetchEpochInfo() (*chainEpochInfoResponse, error) {
 	return &payload, nil
 }
 
+// participantNode holds the per-node data for one ML node belonging to a participant
+type participantNode struct {
+	model  string
+	nodeID string
+	weight float64
+}
+
 // participantsState is the parsed form of the chain participants
 // endpoint used by both the relaxed-PoC preserved-set logic and the
 // CapacityState weight ingestion. We collect everything in one fetch
@@ -457,11 +503,15 @@ func (g *ChainPhaseGate) fetchEpochInfo() (*chainEpochInfoResponse, error) {
 // outside PoC every ML node contributes, while during active PoC only
 // preserved ML nodes contribute.
 type participantsState struct {
-	preserved        []string
-	preservedByModel map[string][]string
-	excluded         []string
-	weights          map[string]float64
-	weightsByModel   map[string]map[string]float64
+	preserved          []string
+	preservedByModel   map[string][]string
+	excluded           []string
+	weights            map[string]float64
+	weightsByModel     map[string]map[string]float64
+	fullWeights        map[string]float64
+	fullWeightsByModel map[string]map[string]float64
+	inferenceURLs      map[string]string
+	nodesByParticipant map[string][]participantNode
 }
 
 func (g *ChainPhaseGate) fetchPreservedParticipantKeys() ([]string, []string, error) {
@@ -504,9 +554,13 @@ func (g *ChainPhaseGate) fetchParticipantsState(pocActive bool, expectedSnapshot
 	}
 
 	state := &participantsState{
-		preservedByModel: make(map[string][]string),
-		weights:          make(map[string]float64, len(payload.ActiveParticipants.Participants)),
-		weightsByModel:   make(map[string]map[string]float64),
+		preservedByModel:   make(map[string][]string),
+		weights:            make(map[string]float64, len(payload.ActiveParticipants.Participants)),
+		weightsByModel:     make(map[string]map[string]float64),
+		fullWeights:        make(map[string]float64, len(payload.ActiveParticipants.Participants)),
+		fullWeightsByModel: make(map[string]map[string]float64),
+		inferenceURLs:      make(map[string]string, len(payload.ActiveParticipants.Participants)),
+		nodesByParticipant: make(map[string][]participantNode, len(payload.ActiveParticipants.Participants)),
 	}
 	seenPreserved := make(map[string]struct{}, len(payload.ActiveParticipants.Participants))
 	seenPreservedByModel := make(map[string]map[string]struct{})
@@ -521,7 +575,14 @@ func (g *ChainPhaseGate) fetchParticipantsState(pocActive bool, expectedSnapshot
 			// receive PoC weight, or be matched against group slots.
 			continue
 		}
+		if inferenceURL := strings.TrimSpace(participant.InferenceURL); inferenceURL != "" {
+			state.inferenceURLs[key] = inferenceURL
+		}
+		if nodes := participantNodes(participant); len(nodes) > 0 {
+			state.nodesByParticipant[key] = nodes
+		}
 		state.weights[key] = participantWeight(participant, pocActive, preservedSnapshot, preservation)
+		state.fullWeights[key] = participantWeight(participant, false, nil, preservationModeAll)
 		for model, weight := range participantWeightsByModel(participant, pocActive, preservedSnapshot, preservation) {
 			modelWeights := state.weightsByModel[model]
 			if modelWeights == nil {
@@ -530,6 +591,14 @@ func (g *ChainPhaseGate) fetchParticipantsState(pocActive bool, expectedSnapshot
 			}
 			modelWeights[key] = weight
 		}
+		for model, weight := range participantWeightsByModel(participant, false, nil, preservationModeAll) {
+			modelWeights := state.fullWeightsByModel[model]
+			if modelWeights == nil {
+				modelWeights = map[string]float64{}
+				state.fullWeightsByModel[model] = modelWeights
+			}
+			modelWeights[key] = weight
+		}
 		for _, model := range preservedModelsForParticipant(participant, preservedSnapshot, preservation) {
 			modelSet := seenPreservedByModel[model]
 			if modelSet == nil {
@@ -896,6 +965,26 @@ func rawPoCBlockingState(epochPhase, confirmationPhase string) (bool, string) {
 	return false, ""
 }
 
+func rawPoCGenerationState(epochPhase, confirmationPhase string) bool {
+	switch epochPhase {
+	case epochPhasePoCGenerate, epochPhasePoCGenerateWindDown:
+		return true
+	}
+	switch confirmationPhase {
+	case confirmationPoCGracePeriod, confirmationPoCGeneration:
+		return true
+	}
+	return false
+}
+
+func rawPoCValidationState(epochPhase, confirmationPhase string) bool {
+	switch epochPhase {
+	case epochPhasePoCValidate, epochPhasePoCValidateWindDown:
+		return true
+	}
+	return confirmationPhase == confirmationPoCValidation
+}
+
 func shouldRefreshPoCPreservedParticipants(previous, next ChainPhaseSnapshot) bool {
 	previousActive, _ := rawPoCBlockingState(previous.EpochPhase, previous.ConfirmationPoCPhase)
 	nextActive, _ := rawPoCBlockingState(next.EpochPhase, next.ConfirmationPoCPhase)
@@ -1023,6 +1112,29 @@ func effectivePreservationMode(pocActive bool, preservation preservationMode) pr
 	return preservation
 }
 
+// participantNodes extracts the flat list of (model, nodeID, weight)
+func participantNodes(participant chainActiveParticipant) []participantNode {
+	var nodes []participantNode
+	for i, rawModel := range participant.Models {
+		model := strings.TrimSpace(rawModel)
+		if model == "" || i >= len(participant.MLNodes) {
+			continue
+		}
+		for _, node := range participant.MLNodes[i].MLNodes {
+			nodeID := strings.TrimSpace(node.NodeID)
+			if nodeID == "" {
+				continue
+			}
+			nodes = append(nodes, participantNode{
+				model:  model,
+				nodeID: nodeID,
+				weight: float64(node.PoCWeight),
+			})
+		}
+	}
+	return nodes
+}
+
 func participantModelAt(participant chainActiveParticipant, index int) string {
 	if index < 0 || index >= len(participant.Models) {
 		return ""
@@ -1150,3 +1262,59 @@ func parseFlexibleUint64(data []byte) (uint64, error) {
 
 	return 0, fmt.Errorf("unsupported uint64 value %s", string(data))
 }
+
+// Returns per model chain weight of the participant's PoC-validation-inference-capable nodes.
+func participantValidationInferenceWeights(nodes []participantNode, miner string, capable func(miner, nodeID string) bool) (map[string]float64, float64) {
+	weights := map[string]float64{}
+	if capable == nil {
+		return weights, 0
+	}
+	var total float64
+	for _, node := range nodes {
+		if capable(miner, node.nodeID) {
+			weights[node.model] += node.weight
+			total += node.weight
+		}
+	}
+	return weights, total
+}
+
+// Returns the validation-phase availability and weight views:
+// preserved miners keep their PoC-filtered current weight, and each non-preserved ("excluded") miner
+// that has a validation-inference-capable node is added with the summed weight of those capable nodes (per model).
+func mergePreservedWithValidationCapable(
+	state *participantsState,
+	capable func(miner, nodeID string) bool,
+) (preserved []string, preservedByModel map[string][]string, currentWeights map[string]float64, currentWeightsByModel map[string]map[string]float64) {
+	preserved = append(preserved, state.preserved...)
+
+	preservedByModel = make(map[string][]string, len(state.preservedByModel))
+	for model, miners := range state.preservedByModel {
+		preservedByModel[model] = append([]string(nil), miners...)
+	}
+
+	currentWeights = make(map[string]float64, len(state.weights))
+	maps.Copy(currentWeights, state.weights)
+	currentWeightsByModel = cloneModelWeights(state.weightsByModel)
+
+	for _, miner := range state.excluded {
+		nodes := state.nodesByParticipant[miner]
+		weightsByModel, total := participantValidationInferenceWeights(nodes, miner, capable)
+		if total <= 0 {
+			continue
+		}
+		preserved = append(preserved, miner)
+		currentWeights[miner] = total
+		for model, weight := range weightsByModel {
+			if currentWeightsByModel[model] == nil {
+				currentWeightsByModel[model] = map[string]float64{}
+			}
+			currentWeightsByModel[model][miner] = weight
+			preservedByModel[model] = append(preservedByModel[model], miner)
+		}
+	}
+	for model := range preservedByModel {
+		sort.Strings(preservedByModel[model])
+	}
+	return preserved, preservedByModel, currentWeights, currentWeightsByModel
+}
diff --git a/devshard/cmd/devshardctl/phase_gate_test.go b/devshard/cmd/devshardctl/phase_gate_test.go
index c2cdd15785..1c02aa1fa5 100644
--- a/devshard/cmd/devshardctl/phase_gate_test.go
+++ b/devshard/cmd/devshardctl/phase_gate_test.go
@@ -341,11 +341,19 @@ func TestChainPhaseGateUsesPreservedNodePoCWeightDuringPoC(t *testing.T) {
 	require.Equal(t, map[string]float64{
 		"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 40,
 	}, state.weights)
+	require.Equal(t, map[string]float64{
+		"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 100,
+	}, state.fullWeights)
 	require.Equal(t, map[string]map[string]float64{
 		"Model/A": {
 			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 40,
 		},
 	}, state.weightsByModel)
+	require.Equal(t, map[string]map[string]float64{
+		"Model/A": {
+			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 100,
+		},
+	}, state.fullWeightsByModel)
 }
 
 func TestChainPhaseGateUsesRawPoCWeightOutsidePoC(t *testing.T) {
@@ -383,6 +391,9 @@ func TestChainPhaseGateUsesRawPoCWeightOutsidePoC(t *testing.T) {
 	require.Equal(t, map[string]float64{
 		"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 110,
 	}, state.weights)
+	require.Equal(t, map[string]float64{
+		"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 110,
+	}, state.fullWeights)
 	require.Equal(t, map[string]map[string]float64{
 		"Model/A": {
 			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 50,
@@ -391,6 +402,14 @@ func TestChainPhaseGateUsesRawPoCWeightOutsidePoC(t *testing.T) {
 			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 60,
 		},
 	}, state.weightsByModel)
+	require.Equal(t, map[string]map[string]float64{
+		"Model/A": {
+			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 50,
+		},
+		"Model/B": {
+			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 60,
+		},
+	}, state.fullWeightsByModel)
 }
 
 func TestChainPhaseGateUsesPreservedSnapshotDuringPoC(t *testing.T) {
@@ -464,12 +483,22 @@ func TestChainPhaseGateUsesPreservedSnapshotDuringPoC(t *testing.T) {
 		"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 60,
 		"gonka1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2": 0,
 	}, state.weights)
+	require.Equal(t, map[string]float64{
+		"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 100,
+		"gonka1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2": 70,
+	}, state.fullWeights)
 	require.Equal(t, map[string]map[string]float64{
 		"Model/A": {
 			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 60,
 			"gonka1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2": 0,
 		},
 	}, state.weightsByModel)
+	require.Equal(t, map[string]map[string]float64{
+		"Model/A": {
+			"gonka1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1": 100,
+			"gonka1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2": 70,
+		},
+	}, state.fullWeightsByModel)
 }
 
 func TestShouldRefreshPoCPreservedParticipantsOnConfirmationGenerationTransition(t *testing.T) {
@@ -819,3 +848,152 @@ func TestChainPhaseGateLogsLoadedPreservedParticipantsSorted(t *testing.T) {
 	require.True(t, strings.Contains(output, "participants=aaaaaaaa,zzzzzzzz"), output)
 	require.True(t, strings.Contains(output, "excluded_participants=bbbbbbbb,yyyyyyyy"), output)
 }
+
+func TestRawPoCGenerationState(t *testing.T) {
+	cases := []struct {
+		name              string
+		epochPhase        string
+		confirmationPhase string
+		want              bool
+	}{
+		{"poc generate", epochPhasePoCGenerate, confirmationPoCInactive, true},
+		{"poc generate winddown", epochPhasePoCGenerateWindDown, confirmationPoCInactive, true},
+		{"confirmation grace", epochPhaseInference, confirmationPoCGracePeriod, true},
+		{"confirmation generation", epochPhaseInference, confirmationPoCGeneration, true},
+		{"poc validate", epochPhasePoCValidate, confirmationPoCInactive, false},
+		{"poc validate winddown", epochPhasePoCValidateWindDown, confirmationPoCInactive, false},
+		{"confirmation validation", epochPhaseInference, confirmationPoCValidation, false},
+		{"steady inference", epochPhaseInference, confirmationPoCInactive, false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := rawPoCGenerationState(tc.epochPhase, tc.confirmationPhase); got != tc.want {
+				t.Fatalf("rawPoCGenerationState(%q,%q)=%v want %v", tc.epochPhase, tc.confirmationPhase, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestRawPoCValidationState(t *testing.T) {
+	cases := []struct {
+		name              string
+		epochPhase        string
+		confirmationPhase string
+		want              bool
+	}{
+		{"poc validate", epochPhasePoCValidate, confirmationPoCInactive, true},
+		{"poc validate winddown", epochPhasePoCValidateWindDown, confirmationPoCInactive, true},
+		{"confirmation validation", epochPhaseInference, confirmationPoCValidation, true},
+		{"poc generate", epochPhasePoCGenerate, confirmationPoCInactive, false},
+		{"poc generate winddown", epochPhasePoCGenerateWindDown, confirmationPoCInactive, false},
+		{"confirmation generation", epochPhaseInference, confirmationPoCGeneration, false},
+		{"confirmation grace", epochPhaseInference, confirmationPoCGracePeriod, false},
+		{"steady inference", epochPhaseInference, confirmationPoCInactive, false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := rawPoCValidationState(tc.epochPhase, tc.confirmationPhase); got != tc.want {
+				t.Fatalf("rawPoCValidationState(%q,%q)=%v want %v", tc.epochPhase, tc.confirmationPhase, got, tc.want)
+			}
+		})
+	}
+}
+
+func newTestGatewayWithSnapshot(t *testing.T, snap ChainPhaseSnapshot) *Gateway {
+	g := &Gateway{
+		phaseGate: &ChainPhaseGate{},
+	}
+	g.phaseGate.storeSnapshot(snap)
+	return g
+}
+
+func TestCurrentMaxConcurrent_GenerationOnly(t *testing.T) {
+	g := newTestGatewayWithSnapshot(t, ChainPhaseSnapshot{EpochPhase: epochPhasePoCGenerate, ConfirmationPoCPhase: confirmationPoCInactive})
+	g.settings.MaxConcurrentPer10000Weight = 5
+	g.settings.PoCMaxConcurrentPer10000Weight = 10
+	if got := g.currentMaxConcurrentPer10000Weight(); got != 10 {
+		t.Fatalf("generation: got %v want 10", got)
+	}
+
+	g2 := newTestGatewayWithSnapshot(t, ChainPhaseSnapshot{EpochPhase: epochPhasePoCValidate, ConfirmationPoCPhase: confirmationPoCInactive})
+	g2.settings.MaxConcurrentPer10000Weight = 5
+	g2.settings.PoCMaxConcurrentPer10000Weight = 10
+	if got := g2.currentMaxConcurrentPer10000Weight(); got != 5 {
+		t.Fatalf("validation: got %v want 5", got)
+	}
+}
+
+func TestMergePreservedWithValidationCapable(t *testing.T) {
+	state := &participantsState{
+		preserved:        []string{"p1"},
+		excluded:         []string{"x1", "x2"},
+		preservedByModel: map[string][]string{"m": {"p1"}},
+		weights:          map[string]float64{"p1": 100},
+		weightsByModel:   map[string]map[string]float64{"m": {"p1": 100}},
+		nodesByParticipant: map[string][]participantNode{
+			"x1": {{model: "m", nodeID: "x1n1", weight: 30}, {model: "m", nodeID: "x1n2", weight: 20}},
+			"x2": {{model: "m", nodeID: "x2n1", weight: 70}},
+		},
+	}
+	// x1n1 capable; x1n2 not; x2n1 not -> x1 available with weight 30, x2 excluded.
+	capable := func(miner, nodeID string) bool { return miner == "x1" && nodeID == "x1n1" }
+
+	preserved, preservedByModel, weights, weightsByModel := mergePreservedWithValidationCapable(state, capable)
+
+	if !contains(preserved, "p1") || !contains(preserved, "x1") || contains(preserved, "x2") {
+		t.Fatalf("preserved = %v, want p1+x1, not x2", preserved)
+	}
+	if weights["x1"] != 30 {
+		t.Fatalf("x1 weight = %v want 30 (only capable node x1n1)", weights["x1"])
+	}
+	if weights["p1"] != 100 {
+		t.Fatalf("p1 weight = %v want 100 (preserved keeps PoC weight)", weights["p1"])
+	}
+	if _, ok := weights["x2"]; ok {
+		t.Fatalf("x2 must not be weighted (no capable node)")
+	}
+	if weightsByModel["m"]["x1"] != 30 {
+		t.Fatalf("weightsByModel[m][x1] = %v want 30", weightsByModel["m"]["x1"])
+	}
+	if !contains(preservedByModel["m"], "x1") {
+		t.Fatalf("preservedByModel[m] = %v want x1 included", preservedByModel["m"])
+	}
+	// purity: inputs unmutated
+	if _, ok := state.weights["x1"]; ok {
+		t.Fatalf("input state.weights mutated")
+	}
+	if len(state.preserved) != 1 {
+		t.Fatalf("input state.preserved mutated")
+	}
+}
+
+func TestParticipantValidationInferenceWeights(t *testing.T) {
+	nodes := []participantNode{
+		{model: "m", nodeID: "n1", weight: 30},
+		{model: "m", nodeID: "n2", weight: 20},
+		{model: "other", nodeID: "n3", weight: 40},
+	}
+
+	capable := func(miner, nodeID string) bool { return nodeID == "n1" || nodeID == "n3" }
+	weights, total := participantValidationInferenceWeights(nodes, "p1", capable)
+	if total != 70 {
+		t.Fatalf("total = %v want 70", total)
+	}
+	if weights["m"] != 30 || weights["other"] != 40 {
+		t.Fatalf("weights = %v want m=30 other=40", weights)
+	}
+
+	weights, total = participantValidationInferenceWeights(nodes, "p1", nil)
+	if total != 0 || len(weights) != 0 {
+		t.Fatalf("nil capable weights=%v total=%v, want empty/0", weights, total)
+	}
+}
+
+func contains(ss []string, s string) bool {
+	for _, v := range ss {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}
diff --git a/devshard/cmd/devshardctl/proxy.go b/devshard/cmd/devshardctl/proxy.go
index b875ecb616..938df72776 100644
--- a/devshard/cmd/devshardctl/proxy.go
+++ b/devshard/cmd/devshardctl/proxy.go
@@ -23,7 +23,15 @@ import (
 
 var sseDoneMarker = []byte("data: [DONE]")
 
-const defaultMetaDrainTimeout = 10 * time.Second
+// defaultMetaDrainTimeout is a last-resort backstop, not an active policy:
+// it must exceed every natural completion window (SecondaryWaitAfterWinner,
+// nonStreamingNoContentTimeout, nonStreamingMaxAttemptWait) so that hosts
+// which are still legitimately generating after a client disconnect get to
+// finish and settle their nonce normally. Cutting a host early records it
+// as a timeout / empty stream through no fault of its own. The only thing
+// this cap should ever terminate is a host that streams forever without
+// tripping any of the normal race timeouts.
+const defaultMetaDrainTimeout = 40 * time.Minute
 
 // metaDrainTimeout applies only after client disconnect (flag.Done() in
 // withMetaDrain), not during normal connected flows. If devshard_meta /
@@ -82,14 +90,36 @@ func (cf *cancelFlag) Done() <-chan struct{} {
 
 // watchClientCancel triggers flag when r's context is canceled (client
 // disconnected). Spawns one short-lived goroutine bounded by request lifetime.
-func watchClientCancel(r *http.Request, flag *cancelFlag) {
+//
+// net/http also cancels the request context when the handler returns after a
+// normal response, which is indistinguishable from a disconnect here. Callers
+// must invoke the returned stop func once RunInference has returned (i.e. the
+// response was fully delivered) so that normal completion does not trip the
+// flag and metaDrain-cancel speculative attempts that are still running under
+// the SecondaryWaitAfterWinner grace window.
+func watchClientCancel(r *http.Request, flag *cancelFlag) (stop func()) {
 	if flag == nil || r == nil {
-		return
+		return func() {}
 	}
+	stopped := make(chan struct{})
 	go func() {
-		<-r.Context().Done()
-		flag.Trigger()
+		select {
+		case <-r.Context().Done():
+			// stop() happens-before the handler returns, which happens-before
+			// net/http cancels the request context, so this non-blocking
+			// re-check deterministically ignores the post-completion cancel
+			// even when the goroutine first wakes up here.
+			select {
+			case <-stopped:
+				return
+			default:
+			}
+			flag.Trigger()
+		case <-stopped:
+		}
 	}()
+	var once sync.Once
+	return func() { once.Do(func() { close(stopped) }) }
 }
 
 // withMetaDrain caps upstream host reads after client disconnect so a
@@ -342,7 +372,7 @@ func (d *deferredWriter) logFlushFailedOnce(err error, where string) {
 func (p *Proxy) handleStreaming(w http.ResponseWriter, r *http.Request, params user.InferenceParams) {
 	started := time.Now()
 	flag := newCancelFlag()
-	watchClientCancel(r, flag)
+	stopClientWatch := watchClientCancel(r, flag)
 	dw := newDeferredWriter(r.Context(), w, p.escrowID, flag)
 
 	// Upstream redundancy is NOT bound to r.Context(): host SSE must be
@@ -351,6 +381,10 @@ func (p *Proxy) handleStreaming(w http.ResponseWriter, r *http.Request, params u
 	// upstream may run after the client is gone.
 	var doneWriteErr error
 	err := p.redundancy.RunInference(context.Background(), params, dw, flag)
+	// The response is fully delivered; detach the disconnect watcher so the
+	// handler returning does not masquerade as a client disconnect and cut
+	// down speculative losers still draining in the background finalizer.
+	stopClientWatch()
 	if flag.Gone() {
 		logRequestStage(r.Context(), "proxy_stream_client_gone",
 			"escrow", p.escrowID,
@@ -508,9 +542,14 @@ func logProxyResponseFinished(ctx context.Context, escrowID, outcome string, dw
 func (p *Proxy) handleNonStreaming(w http.ResponseWriter, r *http.Request, params user.InferenceParams) {
 	var buf bytes.Buffer
 	flag := newCancelFlag()
-	watchClientCancel(r, flag)
+	stopClientWatch := watchClientCancel(r, flag)
 
 	err := p.redundancy.RunInference(context.Background(), params, &buf, flag)
+	// Winner settled and the response body is buffered; detach the disconnect
+	// watcher so the handler returning does not masquerade as a client
+	// disconnect and cut down speculative losers still draining in the
+	// background finalizer.
+	stopClientWatch()
 	if flag.Gone() {
 		return
 	}
@@ -719,20 +758,23 @@ func (p *Proxy) handleDebugPairwise(w http.ResponseWriter, r *http.Request) {
 }
 
 func (p *Proxy) handleDebugState(w http.ResponseWriter, r *http.Request) {
-	st := p.sm.SnapshotState()
+	// Live counts come from InferenceStatusCounts (computed under the read
+	// lock without deep-copying records); sealed records are evicted from the
+	// live map, so they are reported separately from the seal-nonce index.
+	liveTotal, statusCounts := p.sm.InferenceStatusCounts()
 	sealed := p.sm.ExportSealedNonces()
 
-	liveStatusCounts := make(map[string]int)
-	for _, rec := range st.Inferences {
-		name := inferenceStatusName[rec.Status]
+	liveStatusCounts := make(map[string]int, len(statusCounts))
+	for status, n := range statusCounts {
+		name := inferenceStatusName[status]
 		if name == "" {
-			name = fmt.Sprintf("unknown(%d)", rec.Status)
+			name = fmt.Sprintf("unknown(%d)", status)
 		}
-		liveStatusCounts[name]++
+		liveStatusCounts[name] = n
 	}
 
 	phaseStr := "active"
-	switch st.Phase {
+	switch p.sm.Phase() {
 	case types.PhaseFinalizing:
 		phaseStr = "finalizing"
 	case types.PhaseSettlement:
@@ -740,14 +782,14 @@ func (p *Proxy) handleDebugState(w http.ResponseWriter, r *http.Request) {
 	}
 
 	writeJSON(w, map[string]any{
-		"nonce":              st.LatestNonce,
+		"nonce":              p.sm.LatestNonce(),
 		"phase":              phaseStr,
-		"balance":            st.Balance,
-		"live_inferences":    len(st.Inferences),
+		"balance":            p.sm.Balance(),
+		"live_inferences":    liveTotal,
 		"sealed_inferences":  len(sealed),
 		"live_status_counts": liveStatusCounts,
 		// Deprecated: same as live_inferences; kept for older scripts.
-		"total_inferences": len(st.Inferences),
+		"total_inferences": liveTotal,
 		"status_counts":    liveStatusCounts,
 	})
 }
@@ -771,13 +813,12 @@ func (p *Proxy) handleStatus(w http.ResponseWriter, r *http.Request) {
 		phaseStr = fmt.Sprintf("unknown(%d)", phase)
 	}
 
-	st := p.sm.SnapshotState()
-	cfg := st.Config
+	cfg := p.sm.Config()
 	status := statusResponse{
 		EscrowID: p.escrowID,
 		Nonce:    p.session.Nonce(),
 		Phase:    phaseStr,
-		Balance:  st.Balance,
+		Balance:  p.sm.Balance(),
 		Config: statusSessionConfig{
 			RefusalTimeout:            cfg.RefusalTimeout,
 			ExecutionTimeout:          cfg.ExecutionTimeout,
@@ -1015,8 +1056,27 @@ func (p *Proxy) handleSyncHosts(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
+func hostStatsDebugEntry(hs *types.HostStats) map[string]any {
+	entry := map[string]any{
+		"missed":  hs.Missed,
+		"invalid": hs.Invalid,
+		"cost":    hs.Cost,
+	}
+	if hs.RequiredValidations != 0 {
+		entry["required_validations"] = hs.RequiredValidations
+	}
+	if hs.CompletedValidations != 0 {
+		entry["completed_validations"] = hs.CompletedValidations
+	}
+	return entry
+}
+
+// handleState returns the escrow summary: session scalars, config, group, and
+// the small per-slot maps. It deliberately omits the (potentially large)
+// inference map -- that lives at /v1/debug/inferences -- so this endpoint stays
+// bounded regardless of how many inferences an escrow has accumulated.
 func (p *Proxy) handleState(w http.ResponseWriter, r *http.Request) {
-	st := p.sm.SnapshotState()
+	st := p.sm.SnapshotStateNoInferences()
 
 	var phaseStr string
 	switch st.Phase {
@@ -1053,9 +1113,38 @@ func (p *Proxy) handleState(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	allInferences := p.sm.ExportAllInferenceRecords()
-	inferences := make(map[string]any, len(allInferences))
-	for id, rec := range allInferences {
+	hostStats := make(map[string]any, len(st.HostStats))
+	for slot, hs := range st.HostStats {
+		hostStats[fmt.Sprintf("%d", slot)] = hostStatsDebugEntry(hs)
+	}
+
+	revealedSeeds := map[string]int64{}
+
+	warmKeys := make(map[string]string, len(st.WarmKeys))
+	for slot, addr := range st.WarmKeys {
+		warmKeys[fmt.Sprintf("%d", slot)] = addr
+	}
+
+	resp := map[string]any{
+		"session":        session,
+		"group":          group,
+		"host_stats":     hostStats,
+		"revealed_seeds": revealedSeeds,
+		"warm_keys":      warmKeys,
+	}
+
+	writeJSON(w, resp)
+}
+
+// handleDebugInferences returns the full inference map for the escrow. It is a
+// debug-only endpoint (potentially large: up to the per-escrow inference cap)
+// split out of /v1/state so that summary reads stay cheap. It uses
+// ExportAllInferenceRecords rather than the live map so records already
+// sealed to storage still appear in the dump.
+func (p *Proxy) handleDebugInferences(w http.ResponseWriter, r *http.Request) {
+	inferenceMap := p.sm.ExportAllInferenceRecords()
+	inferences := make(map[string]any, len(inferenceMap))
+	for id, rec := range inferenceMap {
 		name := inferenceStatusName[rec.Status]
 		if name == "" {
 			name = fmt.Sprintf("unknown(%d)", rec.Status)
@@ -1080,32 +1169,8 @@ func (p *Proxy) handleState(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	hostStats := make(map[string]any, len(st.HostStats))
-	for slot, hs := range st.HostStats {
-		hostStats[fmt.Sprintf("%d", slot)] = map[string]any{
-			"missed":                hs.Missed,
-			"invalid":               hs.Invalid,
-			"cost":                  hs.Cost,
-			"required_validations":  hs.RequiredValidations,
-			"completed_validations": hs.CompletedValidations,
-		}
-	}
-
-	revealedSeeds := map[string]int64{}
-
-	warmKeys := make(map[string]string, len(st.WarmKeys))
-	for slot, addr := range st.WarmKeys {
-		warmKeys[fmt.Sprintf("%d", slot)] = addr
-	}
-
-	resp := map[string]any{
-		"session":        session,
-		"group":          group,
-		"inferences":     inferences,
-		"host_stats":     hostStats,
-		"revealed_seeds": revealedSeeds,
-		"warm_keys":      warmKeys,
-	}
-
-	writeJSON(w, resp)
+	writeJSON(w, map[string]any{
+		"total_inferences": len(inferences),
+		"inferences":       inferences,
+	})
 }
diff --git a/devshard/cmd/devshardctl/proxy_test.go b/devshard/cmd/devshardctl/proxy_test.go
index c4c97ed219..59b5528f94 100644
--- a/devshard/cmd/devshardctl/proxy_test.go
+++ b/devshard/cmd/devshardctl/proxy_test.go
@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -127,6 +128,37 @@ func TestCancelFlag_NilSafeAndOneShot(t *testing.T) {
 	}
 }
 
+func TestWatchClientCancel_TriggersOnDisconnect(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	r := httptest.NewRequest(http.MethodPost, "/v1/chat/completions", nil).WithContext(ctx)
+	flag := newCancelFlag()
+	stop := watchClientCancel(r, flag)
+	defer stop()
+
+	cancel()
+
+	select {
+	case <-flag.Done():
+	case <-time.After(time.Second):
+		t.Fatal("flag should trigger when the request context is canceled mid-request")
+	}
+}
+
+func TestWatchClientCancel_StopPreventsTriggerOnNormalCompletion(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	r := httptest.NewRequest(http.MethodPost, "/v1/chat/completions", nil).WithContext(ctx)
+	flag := newCancelFlag()
+	stop := watchClientCancel(r, flag)
+
+	stop()
+	stop() // must be idempotent
+	cancel()
+
+	time.Sleep(50 * time.Millisecond)
+	require.False(t, flag.Gone(), "normal handler return must not be treated as a client disconnect")
+}
+
 func TestDeferredWriter_SwallowsAfterClientGone(t *testing.T) {
 	rec := httptest.NewRecorder()
 	flag := newCancelFlag()
@@ -223,6 +255,107 @@ func TestRaceWriterDetachedWinnerSinksAfterContextCancel(t *testing.T) {
 	require.Zero(t, w.flushes)
 }
 
+func TestRaceWriterDefersSuspiciousWinnerUntilFallback(t *testing.T) {
+	rec := httptest.NewRecorder()
+	ctx := context.Background()
+	rg := newRaceGroup(ctx, ctx, "escrow-proxy", rec)
+	inf := &inflight{
+		hostID:       "host-1",
+		escrowID:     "escrow-proxy",
+		nonce:        1,
+		suspicious:   true,
+		done:         make(chan struct{}),
+		receiptCh:    make(chan struct{}),
+		firstTokenCh: make(chan struct{}),
+	}
+	rw := &raceWriter{group: rg, nonce: 1, inf: inf}
+	payload := []byte(`data: {"choices":[{"delta":{"content":"suspect"}}]}` + "\n\n")
+
+	n, err := rw.Write(payload)
+	require.NoError(t, err)
+	require.Equal(t, len(payload), n)
+	require.Zero(t, rg.winnerNonce())
+	require.Empty(t, rec.Body.String())
+	require.Equal(t, payload, inf.pendingBuf)
+
+	require.NoError(t, rg.promoteFallbackWinner(inf))
+	require.EqualValues(t, 1, rg.winnerNonce())
+	require.Equal(t, string(payload), rec.Body.String())
+	require.Empty(t, inf.pendingBuf)
+}
+
+func TestRaceWriterLogsSuspiciousWinnerDeferredOncePerAttempt(t *testing.T) {
+	var logs bytes.Buffer
+	oldOutput := log.Writer()
+	oldFlags := log.Flags()
+	log.SetOutput(&logs)
+	log.SetFlags(0)
+	t.Cleanup(func() {
+		log.SetOutput(oldOutput)
+		log.SetFlags(oldFlags)
+	})
+
+	rec := httptest.NewRecorder()
+	ctx := context.Background()
+	rg := newRaceGroup(ctx, ctx, "escrow-proxy", rec)
+	inf := &inflight{
+		hostID:       "host-1",
+		escrowID:     "escrow-proxy",
+		nonce:        1,
+		suspicious:   true,
+		done:         make(chan struct{}),
+		receiptCh:    make(chan struct{}),
+		firstTokenCh: make(chan struct{}),
+	}
+	rw := &raceWriter{group: rg, nonce: 1, inf: inf}
+
+	for _, payload := range [][]byte{
+		[]byte(`data: {"choices":[{"delta":{"content":"chunk-1"}}]}` + "\n\n"),
+		[]byte(`data: {"choices":[{"delta":{"content":"chunk-2"}}]}` + "\n\n"),
+		[]byte(`data: {"choices":[{"delta":{"content":"chunk-3"}}]}` + "\n\n"),
+	} {
+		_, err := rw.Write(payload)
+		require.NoError(t, err)
+	}
+
+	require.Equal(t, 1, strings.Count(logs.String(), "stage=suspicious_winner_deferred"))
+	require.Equal(t, int64(3), inf.contentChunks.Load())
+	require.Zero(t, rg.winnerNonce())
+}
+
+func TestRaceWriterNonSuspiciousBeatsSuspiciousAttempt(t *testing.T) {
+	rec := httptest.NewRecorder()
+	ctx := context.Background()
+	rg := newRaceGroup(ctx, ctx, "escrow-proxy", rec)
+	suspicious := &inflight{
+		hostID:       "host-1",
+		escrowID:     "escrow-proxy",
+		nonce:        1,
+		suspicious:   true,
+		done:         make(chan struct{}),
+		receiptCh:    make(chan struct{}),
+		firstTokenCh: make(chan struct{}),
+	}
+	normal := &inflight{
+		hostID:       "host-2",
+		escrowID:     "escrow-proxy",
+		nonce:        2,
+		done:         make(chan struct{}),
+		receiptCh:    make(chan struct{}),
+		firstTokenCh: make(chan struct{}),
+	}
+
+	_, err := (&raceWriter{group: rg, nonce: 1, inf: suspicious}).Write([]byte(`data: {"choices":[{"delta":{"content":"suspect"}}]}` + "\n\n"))
+	require.NoError(t, err)
+	require.Zero(t, rg.winnerNonce())
+
+	normalPayload := []byte(`data: {"choices":[{"delta":{"content":"normal"}}]}` + "\n\n")
+	_, err = (&raceWriter{group: rg, nonce: 2, inf: normal}).Write(normalPayload)
+	require.NoError(t, err)
+	require.EqualValues(t, 2, rg.winnerNonce())
+	require.Equal(t, string(normalPayload), rec.Body.String())
+}
+
 func TestDeferredWriterRewritesCompletionPayloadToStreamingChunks(t *testing.T) {
 	rec := httptest.NewRecorder()
 	dw := &deferredWriter{ctx: context.Background(), w: rec, escrow: "escrow-proxy"}
@@ -921,7 +1054,8 @@ func TestRecordWinnerTerminalFailureRecordsOnlyRecordedStall(t *testing.T) {
 	stats := perf.StatsForParticipant("host:0")
 	require.Equal(t, 2, stats.TotalSamples)
 	require.Equal(t, 2, stats.FailureSamples)
-	require.True(t, limiter.IsBlocked("host:0"))
+	require.False(t, limiter.IsBlocked("host:0"))
+	require.True(t, limiter.IsShadowQuarantined("host:0"))
 }
 
 func TestRunInference_WinnerStallsAfterContentTimesOut(t *testing.T) {
@@ -1040,7 +1174,8 @@ func TestStalledWinnerQuarantineRequiresParticipantFailureThreshold(t *testing.T
 	}
 	markStalled(second)
 	env.proxy.redundancy.recordStalledWinnerFailureOnce(second, defaultParams())
-	require.True(t, limiter.IsBlocked(participantKey))
+	require.False(t, limiter.IsBlocked(participantKey))
+	require.True(t, limiter.IsShadowQuarantined(participantKey))
 }
 
 func TestLongResponseAfterContentSkipsParticipantFailureAccounting(t *testing.T) {
@@ -1205,7 +1340,8 @@ func TestRunInference_IncompleteWinnerAfterContentQuarantinesParticipant(t *test
 	err = env.proxy.redundancy.RunInference(context.Background(), defaultParams(), &second, nil)
 	requireIncompleteWinnerError(t, err)
 	require.Contains(t, second.String(), `"content":"x"`)
-	require.True(t, limiter.IsBlocked(participantKey))
+	require.False(t, limiter.IsBlocked(participantKey))
+	require.True(t, limiter.IsShadowQuarantined(participantKey))
 }
 
 func requireIncompleteWinnerError(t *testing.T, err error) {
@@ -1246,6 +1382,7 @@ func TestRecoveredEmptyStreamsRecordPerfWithoutQuarantine(t *testing.T) {
 	require.Equal(t, emptyStreamQuarantineThreshold, stats.TotalSamples)
 	require.Zero(t, stats.ResponsiveRate)
 	require.False(t, limiter.IsBlocked(env.session.HostParticipantKey(0)))
+	require.True(t, limiter.IsShadowQuarantined(env.session.HostParticipantKey(0)))
 
 	unstarted := &inflight{hostIdx: 0, nonce: 99}
 	env.proxy.redundancy.recordStartedAttemptSamples([]*inflight{unstarted}, defaultParams(), true)
@@ -1272,6 +1409,33 @@ func TestRecordStartedAttemptSamplesDoesNotCountEmptyStreamWhenRequestFailed(t *
 	require.Zero(t, stats.TotalSamples)
 	require.Zero(t, stats.FailureSamples)
 	require.False(t, limiter.IsBlocked(env.session.HostParticipantKey(0)))
+	require.True(t, limiter.IsShadowQuarantined(env.session.HostParticipantKey(0)))
+}
+
+func TestRecordStartedAttemptSamplesDoesNotCountEmptyStreamDuringRelaxedPoC(t *testing.T) {
+	setPoCModeForTest(t, pocRequestModeRelaxed)
+	setPoCPhaseState(true, "confirmation_poc")
+
+	env := setupTestProxyWithClients(t, []user.HostClient{streamContentThenStallClient{}})
+	limiter := NewParticipantRequestLimiter(10, 10)
+	env.proxy.redundancy.participantLimiter = limiter
+
+	for i := 0; i < emptyStreamQuarantineThreshold; i++ {
+		inf := &inflight{
+			hostIdx:     0,
+			nonce:       uint64(i + 1),
+			sendTime:    time.Now().Add(-time.Second),
+			receiptTime: time.Now().Add(-900 * time.Millisecond),
+		}
+		inf.outputChunks.Store(1)
+		env.proxy.redundancy.recordStartedAttemptSamples([]*inflight{inf}, defaultParams(), true)
+	}
+
+	participantKey := env.session.HostParticipantKey(0)
+	stats := env.proxy.redundancy.perf.Stats(0)
+	require.Zero(t, stats.TotalSamples)
+	require.False(t, limiter.IsBlocked(participantKey))
+	require.False(t, limiter.IsShadowQuarantined(participantKey))
 }
 
 func TestEmptyStreamWithoutWinnerSkipsTimeoutVoteOnlyWhenFinished(t *testing.T) {
@@ -1510,7 +1674,7 @@ func TestProxyHandleChatCompletionsRejectsWhenRegularPoCActive(t *testing.T) {
 	require.EqualValues(t, 0, env.proxy.session.Nonce())
 }
 
-func TestHandleState_IncludesSealedInferences(t *testing.T) {
+func TestHandleDebugInferences_IncludesSealedInferences(t *testing.T) {
 	hosts := []*signing.Secp256k1Signer{
 		testutil.MustGenerateKey(t),
 		testutil.MustGenerateKey(t),
@@ -1547,17 +1711,17 @@ func TestHandleState_IncludesSealedInferences(t *testing.T) {
 
 	proxy := &Proxy{sm: sm, escrowID: escrowID}
 
-	req := httptest.NewRequest(http.MethodGet, "/v1/state", nil)
+	req := httptest.NewRequest(http.MethodGet, "/v1/debug/inferences", nil)
 	rec := httptest.NewRecorder()
-	proxy.handleState(rec, req)
+	proxy.handleDebugInferences(rec, req)
 	require.Equal(t, http.StatusOK, rec.Code)
 
 	var stateResp map[string]any
 	require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &stateResp))
 	inferences, ok := stateResp["inferences"].(map[string]any)
-	require.True(t, ok, "/v1/state must expose inferences map")
+	require.True(t, ok, "/v1/debug/inferences must expose inferences map")
 	inf, ok := inferences["1"].(map[string]any)
-	require.True(t, ok, "sealed inference 1 must appear in /v1/state")
+	require.True(t, ok, "sealed inference 1 must appear in /v1/debug/inferences")
 	require.Equal(t, "finished", inf["status"])
 	require.Equal(t, "llama", inf["model"])
 }
@@ -1781,6 +1945,15 @@ func TestRunInference_ExportsPrometheusMetrics(t *testing.T) {
 	require.Contains(t, body, `reason="attempt_failed"`)
 	require.Contains(t, body, `devshard_id="escrow-proxy"`)
 	require.Contains(t, body, "devshard_host_total_time_seconds")
+	require.Contains(t, body, `devshard_gateway_requests_total{model="llama",outcome="success",reason="none"} 1`)
+	require.Contains(t, body, "devshard_gateway_slot_decisions_total")
+	require.Contains(t, body, `decision="real_send"`)
+	require.Contains(t, body, "devshard_gateway_attempts_started_total")
+	require.Contains(t, body, `role="primary"`)
+	require.Contains(t, body, `role="extra"`)
+	require.Contains(t, body, "devshard_gateway_attempts_terminal_total")
+	require.Contains(t, body, "devshard_gateway_attempt_failures_total")
+	require.Contains(t, body, "devshard_gateway_user_requests_with_hidden_failure_total")
 }
 
 func TestPerfTrackerIsUnresponsiveUsesThreshold(t *testing.T) {
diff --git a/devshard/cmd/devshardctl/redundancy.go b/devshard/cmd/devshardctl/redundancy.go
index f2669f896e..48fad8b7d2 100644
--- a/devshard/cmd/devshardctl/redundancy.go
+++ b/devshard/cmd/devshardctl/redundancy.go
@@ -69,6 +69,41 @@ func sseChunkHasContent(p []byte) bool {
 	return ok
 }
 
+var sseUsageKeyMarker = []byte(`"usage"`)
+
+// sseChunkUsageCompletionTokens reads usage.completion_tokens from an SSE
+// data event. Includes tokens vLLM stripped from `content` (e.g. </think>).
+// Fast-skips chunks that do not contain the `"usage"` key — vLLM emits the
+// usage object only in the final chunk of a stream, so 99%+ of chunks avoid
+// the json.Unmarshal cost entirely.
+func sseChunkUsageCompletionTokens(p []byte) (int64, bool) {
+	if len(p) == 0 || !bytes.Contains(p, sseUsageKeyMarker) {
+		return 0, false
+	}
+	for _, line := range bytes.Split(p, []byte("\n")) {
+		line = bytes.TrimRight(line, "\r")
+		if !bytes.HasPrefix(line, []byte("data:")) {
+			continue
+		}
+		payload := bytes.TrimSpace(line[len("data:"):])
+		if len(payload) == 0 || bytes.Equal(payload, []byte("[DONE]")) {
+			continue
+		}
+		var evt struct {
+			Usage *struct {
+				CompletionTokens int64 `json:"completion_tokens"`
+			} `json:"usage"`
+		}
+		if err := json.Unmarshal(payload, &evt); err != nil {
+			continue
+		}
+		if evt.Usage != nil && evt.Usage.CompletionTokens > 0 {
+			return evt.Usage.CompletionTokens, true
+		}
+	}
+	return 0, false
+}
+
 // sseChunkContentSource is the classifying variant of sseChunkHasContent: when
 // content is present it returns a short label identifying the field that
 // carried it. The second return value is false when no accepted content was
@@ -529,19 +564,22 @@ type Decision struct {
 // It sits between Proxy and Session: Proxy delegates request execution here,
 // and Redundancy decides whether to use just one nonce or several.
 type Redundancy struct {
-	session              *user.Session
-	perf                 *PerfTracker
-	groupSize            int
-	devshardID           string
-	model                string // escrow's registered model; used for ghost probes when no real request is around
-	metrics              *DevshardMetrics
-	onEscrowMissing      func() // called (at most once per request) when a host reports escrow not found
-	onBalanceExhausted   func() // called (once) when local state hits insufficient balance
-	balanceExhaustedOnce sync.Once
-	picker               *sessionPicker
-	participantLimiter   *ParticipantRequestLimiter
-	stateBlockMu         sync.RWMutex
-	stateBlockedHosts    map[string]string // escrow-local participant blocks for non-recoverable state divergence
+	session               *user.Session
+	perf                  *PerfTracker
+	groupSize             int
+	devshardID            string
+	model                 string // escrow's registered model; used for ghost probes when no real request is around
+	metrics               *DevshardMetrics
+	onEscrowMissing       func() // called (at most once per request) when a host reports escrow not found
+	onBalanceExhausted    func() // called (once) when local state hits insufficient balance
+	onRaceCleanupStart    func() // fires synchronously before a race cleanup goroutine spawns
+	onRaceCleanupDone     func() // fires when a race cleanup goroutine finishes
+	balanceExhaustedOnce  sync.Once
+	picker                *sessionPicker
+	participantLimiter    *ParticipantRequestLimiter
+	suspiciousParticipant func(participantKey string) bool
+	stateBlockMu          sync.RWMutex
+	stateBlockedHosts     map[string]string // escrow-local participant blocks for non-recoverable state divergence
 }
 
 // ErrAllHostsExcluded is returned by prepareInflight when the request
@@ -768,13 +806,36 @@ func (e *Redundancy) pairwiseParticipantAvailable(participantKey string) bool {
 		if e.perf != nil && e.perf.IsUnresponsiveParticipant(participantKey) {
 			return false
 		}
-		if e.participantLimiter != nil && (e.participantLimiter.IsBlocked(participantKey) || e.participantLimiter.IsRecentlyQuarantined(participantKey)) {
+		if e.participantLimiter != nil && (e.participantLimiter.IsBlockedForModel(participantKey, e.model) || e.participantLimiter.IsRecentlyQuarantinedForModel(participantKey, e.model)) {
 			return false
 		}
 	}
 	return true
 }
 
+func (e *Redundancy) isSuspiciousParticipant(participantKey string) bool {
+	return e != nil && e.suspiciousParticipant != nil && e.suspiciousParticipant(strings.TrimSpace(participantKey))
+}
+
+func (e *Redundancy) isNoWinnerParticipant(participantKey string) bool {
+	_, ok := e.noWinnerStatusForParticipant(participantKey)
+	return ok
+}
+
+func (e *Redundancy) noWinnerStatusForParticipant(participantKey string) (participantNoWinnerStatus, bool) {
+	participantKey = strings.TrimSpace(participantKey)
+	if participantKey == "" || e == nil {
+		return participantNoWinnerStatus{}, false
+	}
+	if e.isSuspiciousParticipant(participantKey) {
+		return participantNoWinnerStatus{reason: "manual_suspicious"}, true
+	}
+	if e.participantLimiter == nil {
+		return participantNoWinnerStatus{}, false
+	}
+	return e.participantLimiter.NoWinnerStatusForModel(participantKey, e.model)
+}
+
 // Deprecated fallback: retained while pairwise routing warms up. Remove after
 // pairwise speed policy has enough production coverage and legacy fallback has
 // been disabled for one release.
@@ -803,11 +864,17 @@ type inflight struct {
 	prepared                   *user.PreparedInference
 	hostIdx                    int
 	hostID                     string
+	role                       string
+	startReason                string
 	nonce                      uint64
 	escrowID                   string
 	sendTime                   time.Time
 	escalated                  bool
 	probe                      bool
+	suspicious                 bool
+	noWinnerReason             string
+	noWinnerQuarantineMode     string
+	noWinnerFailureStrikes     int
 	excludePairwise            bool
 	startedBeforePoCGeneration bool
 	phaseTransitionAborted     bool
@@ -816,23 +883,25 @@ type inflight struct {
 	receiptTime time.Time
 	receiptCh   chan struct{} // closed when receipt arrives
 
-	tokenOnce       sync.Once
-	firstToken      time.Time
-	firstTokenCh    chan struct{}
-	outputChunks    atomic.Int64
-	contentChunks   atomic.Int64
-	outputBytes     atomic.Int64
-	lastChunkAt     atomic.Int64
-	stallMu         sync.Mutex
-	stallActive     bool
-	stalls          []attemptStall
-	forwardedLog    sync.Once
-	suppressedLog   sync.Once
-	ctxCancelledLog sync.Once
-	hardTimeoutLog  sync.Once
-	sampleOnce      sync.Once
-	processOnce     sync.Once
-	processErr      error
+	tokenOnce                   sync.Once
+	firstToken                  time.Time
+	firstTokenCh                chan struct{}
+	outputChunks                atomic.Int64
+	contentChunks               atomic.Int64
+	outputBytes                 atomic.Int64
+	lastChunkAt                 atomic.Int64
+	usageComplTokens            atomic.Int64
+	stallMu                     sync.Mutex
+	stallActive                 bool
+	stalls                      []attemptStall
+	forwardedLog                sync.Once
+	suppressedLog               sync.Once
+	ctxCancelledLog             sync.Once
+	hardTimeoutLog              sync.Once
+	suspiciousWinnerDeferredLog sync.Once
+	sampleOnce                  sync.Once
+	processOnce                 sync.Once
+	processErr                  error
 
 	// pendingBuf holds bytes received before any content event was observed.
 	// Each attempt has at most one writer goroutine driving Write/Flush, so no
@@ -841,6 +910,14 @@ type inflight struct {
 	// different attempt wins or the attempt ends with no content.
 	pendingBuf []byte
 
+	// classifyPartial keeps the tail after the last '\n' from prior Writes;
+	// used to reassemble fragmented SSE events for the classifier.
+	classifyPartial []byte
+	classifyCapLog  sync.Once
+	// participantClassifyBytes is the shared per-participant byte counter this
+	// attempt contributes to; resolved at creation. Nil disables the cap.
+	participantClassifyBytes *atomic.Int64
+
 	// contentSource labels the field that produced the first content event
 	// ("delta.content", "delta.reasoning_content", "delta.tool_calls", or the
 	// streaming-only convertible shape "message.content"). Set exactly once
@@ -863,6 +940,12 @@ type inflight struct {
 	emptyResponseBodySample          string
 	emptyResponseBodySampleTruncated bool
 
+	// shortContentResponseBody optionally preserves raw streamed bytes so
+	// anomalously low-content attempts can be inspected offline. It is only
+	// populated when DEVSHARD_CAPTURE_SHORT_CONTENT_RESPONSES is enabled.
+	shortContentResponseBody          []byte
+	shortContentResponseBodyTruncated bool
+
 	resp *host.HostResponse
 	err  error
 	done chan struct{}
@@ -874,6 +957,27 @@ type inflight struct {
 	cancel context.CancelFunc
 }
 
+func (inf *inflight) captureShortContentResponseChunk(p []byte) {
+	if inf == nil || len(p) == 0 {
+		return
+	}
+	opts := currentRequestCaptureOptions()
+	if !opts.shortContentAttempts || !opts.shortContentResponses || opts.shortContentMaxResponse <= 0 || inf.shortContentResponseBodyTruncated {
+		return
+	}
+	remaining := int(opts.shortContentMaxResponse) - len(inf.shortContentResponseBody)
+	if remaining <= 0 {
+		inf.shortContentResponseBodyTruncated = true
+		return
+	}
+	if len(p) > remaining {
+		inf.shortContentResponseBody = append(inf.shortContentResponseBody, p[:remaining]...)
+		inf.shortContentResponseBodyTruncated = true
+		return
+	}
+	inf.shortContentResponseBody = append(inf.shortContentResponseBody, p...)
+}
+
 type attemptStall struct {
 	StartTime           time.Time
 	DetectedTime        time.Time
@@ -1044,6 +1148,34 @@ func (rg *raceGroup) setWinner(nonce uint64) {
 	}
 }
 
+func (rg *raceGroup) promoteFallbackWinner(inf *inflight) error {
+	if rg == nil || inf == nil {
+		return nil
+	}
+	rg.setWinner(inf.nonce)
+	rg.clientMu.Lock()
+	defer rg.clientMu.Unlock()
+	if rg.isClientDetached() || len(inf.pendingBuf) == 0 || rg.w == nil {
+		inf.pendingBuf = nil
+		return nil
+	}
+	if rg.writeCtx != nil {
+		if err := rg.writeCtx.Err(); err != nil {
+			inf.pendingBuf = nil
+			return err
+		}
+	}
+	if _, err := rg.w.Write(inf.pendingBuf); err != nil {
+		inf.pendingBuf = nil
+		return err
+	}
+	inf.pendingBuf = nil
+	if f, ok := rg.w.(http.Flusher); ok {
+		f.Flush()
+	}
+	return nil
+}
+
 func (rg *raceGroup) addWinnerHoldCandidate(inf *inflight) {
 	if rg == nil || inf == nil || PairwiseWinnerHold <= 0 {
 		return
@@ -1155,6 +1287,224 @@ type raceWriter struct {
 	inf   *inflight
 }
 
+const (
+	defaultMaxClassifyPartial            = 1 << 20   // 1 MiB per attempt
+	defaultMaxClassifyPartialParticipant = 10 << 20  // 10 MiB per participant
+	defaultMaxClassifyPartialGlobal      = 100 << 20 // 100 MiB process-wide
+)
+
+// Reassembly-buffer caps, tunable at startup via configureClassifyCapsFromEnv.
+// These are machine-scale memory knobs, not governance policy.
+var (
+	maxClassifyPartial                  = defaultMaxClassifyPartial
+	maxClassifyPartialParticipant int64 = defaultMaxClassifyPartialParticipant
+	maxClassifyPartialGlobal      int64 = defaultMaxClassifyPartialGlobal
+)
+
+// configureClassifyCapsFromEnv overrides the reassembly caps from the
+// environment; unset variables keep the conservative defaults.
+func configureClassifyCapsFromEnv() {
+	maxClassifyPartial = int(readInt64Env("GATEWAY_CLASSIFY_MAX_ATTEMPT_BYTES", int64(defaultMaxClassifyPartial)))
+	maxClassifyPartialParticipant = readInt64Env("GATEWAY_CLASSIFY_MAX_PARTICIPANT_BYTES", defaultMaxClassifyPartialParticipant)
+	maxClassifyPartialGlobal = readInt64Env("GATEWAY_CLASSIFY_MAX_GLOBAL_BYTES", defaultMaxClassifyPartialGlobal)
+}
+
+// classifyPartialBytes is the live total of every inflight's classifyPartial.
+var classifyPartialBytes atomic.Int64
+
+// participantClassify bounds live reassembly bytes per participant so one
+// hostile participant can't exhaust the shared global pool and starve others.
+var participantClassify = &participantClassifyTracker{counters: map[string]*atomic.Int64{}}
+
+type participantClassifyTracker struct {
+	mu       sync.Mutex
+	counters map[string]*atomic.Int64
+}
+
+// counterFor returns the participant's byte counter, creating it on first use.
+// Entries are never removed; the participant set is the bounded validator set.
+func (t *participantClassifyTracker) counterFor(participantKey string) *atomic.Int64 {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	counter := t.counters[participantKey]
+	if counter == nil {
+		counter = &atomic.Int64{}
+		t.counters[participantKey] = counter
+	}
+	return counter
+}
+
+// takeParseable returns the prefix of (classifyPartial + p) ending at the last
+// '\n'; the trailing fragment is stashed for the next call.
+func (rw *raceWriter) takeParseable(p []byte) []byte {
+	lastNL := bytes.LastIndexByte(p, '\n')
+	if lastNL == -1 {
+		if rw.growClassify(p) {
+			return nil
+		}
+		// Cap hit: classify the raw chunk best-effort (incomplete fragments won't parse).
+		rw.dropClassify()
+		return p
+	}
+
+	var parseable []byte
+	if len(rw.inf.classifyPartial) == 0 {
+		parseable = p[:lastNL+1]
+	} else {
+		buf := make([]byte, 0, len(rw.inf.classifyPartial)+lastNL+1)
+		buf = append(buf, rw.inf.classifyPartial...)
+		buf = append(buf, p[:lastNL+1]...)
+		parseable = buf
+	}
+	if !rw.replaceClassify(p[lastNL+1:]) {
+		rw.dropClassify()
+	}
+	return parseable
+}
+
+// classifyParseable records the first content/non-retriable-error signal for
+// this attempt, returning whether the buffer carried either.
+func (rw *raceWriter) classifyParseable(parseable []byte) (hasContent, hasError bool) {
+	if len(parseable) == 0 {
+		return false, false
+	}
+	if src, ok := sseChunkContentSource(parseable); ok {
+		hasContent = true
+		if rw.inf.contentSource == "" {
+			rw.inf.contentSource = src
+		}
+	} else if details, ok := sseChunkErrorDetails(parseable); ok {
+		src := "error"
+		if details.Type != "" {
+			src = "error." + details.Type
+		}
+		hasError = !isRetriableCapabilityErrorMessage(details.Message)
+		if rw.inf.errorSource == "" {
+			rw.inf.errorSource = src
+			rw.inf.errorCode = details.Code
+			rw.inf.errorType = details.Type
+			rw.inf.errorMessage = details.Message
+			rw.inf.errorBodySample = append(rw.inf.errorBodySample, parseable...)
+		}
+	}
+	return hasContent, hasError
+}
+
+// flushClassify classifies a newline-less final SSE event left in classifyPartial
+// once the stream ends, so a truncated tail isn't misread as empty_stream.
+func (rw *raceWriter) flushClassify() {
+	if rw.inf.probe || len(rw.inf.classifyPartial) == 0 {
+		return
+	}
+	// Extract usage from the final newline-less event too, mirroring Write, so a
+	// truncated usage chunk still feeds isModelBurnEmpty.
+	if tokens, ok := sseChunkUsageCompletionTokens(rw.inf.classifyPartial); ok {
+		rw.inf.usageComplTokens.Store(tokens)
+	}
+	hasContent, hasError := rw.classifyParseable(rw.inf.classifyPartial)
+	rw.dropClassify()
+	if hasContent || hasError {
+		rw.inf.contentChunks.Add(1)
+	}
+}
+
+// flushClassifyAndCheckEmpty flushes a buffered newline-less final event before deciding empty, so a truncated final content/error event isn't misread as empty_stream. Call on the send goroutine after SendOnly returns.
+func (rw *raceWriter) flushClassifyAndCheckEmpty() bool {
+	rw.flushClassify()
+	return isEmptyStreamAttempt(rw.inf)
+}
+
+// logClassifyDrop reports the first reassembly-buffer drop for this attempt.
+// Capped at once per attempt so a persistently newline-less or oversized
+// transport can't spam the log.
+func (rw *raceWriter) logClassifyDrop(reason string) {
+	rw.inf.classifyCapLog.Do(func() {
+		ctx := context.Background()
+		if rw.group != nil {
+			ctx = rw.group.logCtx
+		}
+		logInferenceStage(ctx, rw.inf.escrowID, rw.nonce, "classify_buffer_dropped",
+			"host", rw.inf.hostID,
+			"reason", reason,
+			"buffered", len(rw.inf.classifyPartial),
+			"global_bytes", classifyPartialBytes.Load(),
+		)
+	})
+}
+
+// growClassify appends tail to classifyPartial if all caps still fit.
+func (rw *raceWriter) growClassify(tail []byte) bool {
+	if len(rw.inf.classifyPartial)+len(tail) > maxClassifyPartial {
+		rw.logClassifyDrop("per_attempt_cap")
+		return false
+	}
+	if reason := rw.inf.reserveClassifyBytes(int64(len(tail))); reason != "" {
+		rw.logClassifyDrop(reason)
+		return false
+	}
+	rw.inf.classifyPartial = append(rw.inf.classifyPartial, tail...)
+	return true
+}
+
+// replaceClassify swaps classifyPartial for buf, adjusting byte accounting.
+func (rw *raceWriter) replaceClassify(buf []byte) bool {
+	if len(buf) > maxClassifyPartial {
+		rw.logClassifyDrop("per_attempt_cap")
+		return false
+	}
+	delta := int64(len(buf) - len(rw.inf.classifyPartial))
+	if delta > 0 {
+		if reason := rw.inf.reserveClassifyBytes(delta); reason != "" {
+			rw.logClassifyDrop(reason)
+			return false
+		}
+	} else if delta < 0 {
+		rw.inf.adjustClassifyBytes(delta)
+	}
+	rw.inf.classifyPartial = append(rw.inf.classifyPartial[:0], buf...)
+	return true
+}
+
+// dropClassify releases the per-attempt buffer and its accounted bytes.
+func (rw *raceWriter) dropClassify() {
+	rw.inf.releaseClassifyPartial()
+}
+
+// reserveClassifyBytes charges n bytes against the participant then global cap,
+// rolling back on the first cap hit. Returns the drop reason, "" on success.
+func (inf *inflight) reserveClassifyBytes(n int64) string {
+	participant := inf.participantClassifyBytes
+	if participant != nil && participant.Add(n) > maxClassifyPartialParticipant {
+		participant.Add(-n)
+		return "participant_cap"
+	}
+	if classifyPartialBytes.Add(n) > maxClassifyPartialGlobal {
+		classifyPartialBytes.Add(-n)
+		if participant != nil {
+			participant.Add(-n)
+		}
+		return "global_cap"
+	}
+	return ""
+}
+
+// adjustClassifyBytes adds delta to the global and per-participant counters.
+func (inf *inflight) adjustClassifyBytes(delta int64) {
+	classifyPartialBytes.Add(delta)
+	if inf.participantClassifyBytes != nil {
+		inf.participantClassifyBytes.Add(delta)
+	}
+}
+
+// releaseClassifyPartial frees the reassembly buffer's backing array and
+// decrements the counters. Nils the slice so cap doesn't outlive the gauge.
+func (inf *inflight) releaseClassifyPartial() {
+	if n := len(inf.classifyPartial); n > 0 {
+		inf.adjustClassifyBytes(-int64(n))
+	}
+	inf.classifyPartial = nil
+}
+
 func (rw *raceWriter) ctxErr() error {
 	if rw.group == nil || rw.group.writeCtx == nil {
 		return nil
@@ -1174,6 +1524,7 @@ func (rw *raceWriter) Write(p []byte) (int, error) {
 	rw.inf.outputChunks.Add(1)
 	rw.inf.outputBytes.Add(int64(len(p)))
 	rw.inf.lastChunkAt.Store(now.UnixNano())
+	rw.inf.captureShortContentResponseChunk(p)
 
 	// Detect whether this Write contains the first content-bearing event for
 	// this attempt. Only content events promote a nonce to winner; role-only
@@ -1182,32 +1533,27 @@ func (rw *raceWriter) Write(p []byte) (int, error) {
 	var chunkHasContent bool
 	var chunkHasError bool
 	if !rw.inf.probe {
-		if src, ok := sseChunkContentSource(p); ok {
-			chunkHasContent = true
-			if rw.inf.contentSource == "" {
-				rw.inf.contentSource = src
-			}
-		} else if details, ok := sseChunkErrorDetails(p); ok {
-			src := "error"
-			if details.Type != "" {
-				src = "error." + details.Type
-			}
-			chunkHasError = !isRetriableCapabilityErrorMessage(details.Message)
-			if rw.inf.errorSource == "" {
-				rw.inf.errorSource = src
-				rw.inf.errorCode = details.Code
-				rw.inf.errorType = details.Type
-				rw.inf.errorMessage = details.Message
-				rw.inf.errorBodySample = append(rw.inf.errorBodySample, p...)
-			}
+		parseable := rw.takeParseable(p)
+		chunkHasContent, chunkHasError = rw.classifyParseable(parseable)
+		// Track completion_tokens so isModelBurnEmpty can tell stripped-
+		// content empties from no-tokens-generated empties.
+		if tokens, ok := sseChunkUsageCompletionTokens(parseable); ok {
+			rw.inf.usageComplTokens.Store(tokens)
+		} else if tokens, ok := sseChunkUsageCompletionTokens(rw.inf.classifyPartial); ok {
+			// Handle a newline-less final event buffered into classifyPartial.
+			rw.inf.usageComplTokens.Store(tokens)
 		}
 	}
 	if chunkHasContent || chunkHasError {
 		rw.inf.contentChunks.Add(1)
 		rw.group.maybeHoldWinnerCandidate(rw.inf)
 	}
-	if chunkHasContent {
+	if chunkHasContent && !rw.inf.suspicious {
 		rw.group.setWinner(rw.nonce)
+	} else if chunkHasContent && rw.inf.suspicious {
+		rw.inf.suspiciousWinnerDeferredLog.Do(func() {
+			logInferenceStage(rw.group.logCtx, rw.inf.escrowID, rw.nonce, "suspicious_winner_deferred", "host", rw.inf.hostID)
+		})
 	}
 
 	rw.group.mu.Lock()
@@ -1359,20 +1705,38 @@ func (e *Redundancy) RunInference(ctx context.Context, params user.InferencePara
 		}
 		return err
 	}
+	primary.role = "primary"
+	primary.startReason = "primary"
 	triedParticipants[e.session.HostParticipantKey(primary.hostIdx)] = true
 
 	decision := e.Decide(primary.hostIdx, params.InputLength)
 	maxAttempts := e.maxAttempts()
+	if primary.suspicious && maxAttempts > 1 && (!decision.RunSecondary || decision.Delay > 0) {
+		decision = Decision{RunSecondary: true, Delay: 0, Reason: "primary_suspicious", ImmediateAttempts: 1}
+	}
 	if e.metrics != nil {
 		e.metrics.RecordSpeculativeDecision(decision.Reason)
 	}
-	logInferenceStage(ctx, primary.escrowID, primary.nonce, "decision_made",
+	decisionFields := []any{
 		"host", primary.hostID,
 		"decision", decision.Reason,
 		"delay_ms", decision.Delay.Milliseconds(),
 		"max_attempts", maxAttempts,
 		"group_size", e.groupSize,
-	)
+	}
+	if primary.suspicious {
+		decisionFields = append(decisionFields,
+			"primary_no_winner", true,
+			"primary_no_winner_reason", primary.noWinnerReason,
+		)
+		if primary.noWinnerQuarantineMode != "" {
+			decisionFields = append(decisionFields, "primary_quarantine_mode", primary.noWinnerQuarantineMode)
+		}
+		if primary.noWinnerFailureStrikes > 0 {
+			decisionFields = append(decisionFields, "primary_failure_strikes", primary.noWinnerFailureStrikes)
+		}
+	}
+	logInferenceStage(ctx, primary.escrowID, primary.nonce, "decision_made", decisionFields...)
 	race := newRaceGroup(settleCtx, ctx, e.devshardID, w)
 	attempts := []*inflight{primary}
 
@@ -1460,16 +1824,23 @@ func (e *Redundancy) prepareInflight(ctx context.Context, params user.InferenceP
 			}
 			return nil, fmt.Errorf("prepare: %w", res.err)
 		}
+		participantKey := e.session.HostParticipantKey(res.prepared.HostIdx())
+		noWinner, noWinnerOK := e.noWinnerStatusForParticipant(participantKey)
 		inf := &inflight{
-			prepared:     res.prepared,
-			hostIdx:      res.prepared.HostIdx(),
-			hostID:       e.session.HostLabel(res.prepared.HostIdx()),
-			nonce:        res.prepared.Nonce(),
-			escrowID:     e.devshardID,
-			probe:        res.isProbe,
-			done:         make(chan struct{}),
-			receiptCh:    make(chan struct{}),
-			firstTokenCh: make(chan struct{}),
+			prepared:                 res.prepared,
+			hostIdx:                  res.prepared.HostIdx(),
+			hostID:                   e.session.HostLabel(res.prepared.HostIdx()),
+			nonce:                    res.prepared.Nonce(),
+			escrowID:                 e.devshardID,
+			probe:                    res.isProbe,
+			suspicious:               noWinnerOK,
+			noWinnerReason:           noWinner.reason,
+			noWinnerQuarantineMode:   noWinner.quarantineMode,
+			noWinnerFailureStrikes:   noWinner.failureStrikes,
+			done:                     make(chan struct{}),
+			receiptCh:                make(chan struct{}),
+			firstTokenCh:             make(chan struct{}),
+			participantClassifyBytes: participantClassify.counterFor(participantKey),
 		}
 		e.recordAccountingAttempt(ctx, inf)
 		return inf, nil
@@ -1493,7 +1864,22 @@ func (e *Redundancy) startInflight(ctx context.Context, inf *inflight, race *rac
 			close(inf.receiptCh)
 		})
 	}
-	logInferenceStage(ctx, inf.escrowID, inf.nonce, "prepared", "host", inf.hostID)
+	preparedFields := []any{"host", inf.hostID}
+	if inf.suspicious {
+		preparedFields = append(preparedFields,
+			"participant_key", e.participantKeyForHost(inf.hostIdx),
+			"model_id", e.model,
+			"no_winner", true,
+			"no_winner_reason", inf.noWinnerReason,
+		)
+		if inf.noWinnerQuarantineMode != "" {
+			preparedFields = append(preparedFields, "quarantine_mode", inf.noWinnerQuarantineMode)
+		}
+		if inf.noWinnerFailureStrikes > 0 {
+			preparedFields = append(preparedFields, "failure_strikes", inf.noWinnerFailureStrikes)
+		}
+	}
+	logInferenceStage(ctx, inf.escrowID, inf.nonce, "prepared", preparedFields...)
 	if inf.probe {
 		logInferenceStage(ctx, inf.escrowID, inf.nonce, "poc_probe_prepared", "host", inf.hostID, "max_tokens", pocProbeMaxTokens, "poc_reason", currentPoCPhaseReason())
 	}
@@ -1511,11 +1897,14 @@ func (e *Redundancy) startInflight(ctx context.Context, inf *inflight, race *rac
 	// before awaitRace can observe the attempt.
 	inf.sendTime = time.Now()
 	inf.startedBeforePoCGeneration = !currentPoCGenerationActive()
+	e.recordGatewayAttemptStarted(inf, params)
 	go e.monitorInflight(ctx, inf, race)
 
 	go func() {
 		defer close(inf.done)
 		defer cancel()
+		// Sole owner of classifyPartial: release on every exit path (incl. the early error return); content is classified synchronously via flushClassifyAndCheckEmpty below.
+		defer inf.releaseClassifyPartial()
 		logInferenceStage(ctx, inf.escrowID, inf.nonce, "started", "host", inf.hostID)
 		inf.resp, inf.err = e.session.SendOnly(attemptCtx, inf.prepared, rw, receiptHandler)
 		streamBytes := int64(0)
@@ -1547,7 +1936,7 @@ func (e *Redundancy) startInflight(ctx context.Context, inf *inflight, race *rac
 		// stream_bytes_read > 0 but output_chunks == 0 because only devshard
 		// receipt/meta events were parsed and no inference data was forwarded to
 		// the race writer.
-		if isEmptyStreamAttempt(inf) {
+		if rw.flushClassifyAndCheckEmpty() {
 			responseBodySample, responseSampleTruncated := bodySampleForLog(inf.pendingBuf, emptyStreamBodySampleLimit)
 			inf.emptyResponseBodySample = responseBodySample
 			inf.emptyResponseBodySampleTruncated = responseSampleTruncated
@@ -1627,6 +2016,8 @@ func (e *Redundancy) startAdditionalInflight(streamCtx, settleCtx context.Contex
 		return nil
 	}
 	triedParticipants[e.session.HostParticipantKey(next.hostIdx)] = true
+	next.role = "extra"
+	next.startReason = reason
 	if e.metrics != nil {
 		e.metrics.RecordSpeculativeAttemptStart(reason)
 	}
@@ -1912,7 +2303,9 @@ func (e *Redundancy) awaitRace(streamCtx, settleCtx context.Context, attempts []
 						"max_wait_ms", SecondaryWaitAfterWinner.Milliseconds(),
 						"decision", decision.Reason,
 					)
-					go e.finishRaceWhenPendingDone(settleCtx, attempts, params, decision, winner, raceFinishOptions{recordFailureSamples: true})
+					e.goTrackedRaceCleanup(func() {
+						e.finishRaceWhenPendingDone(settleCtx, attempts, params, decision, winner, raceFinishOptions{recordFailureSamples: true})
+					})
 					return nil
 				}
 			}
@@ -2009,6 +2402,14 @@ func (e *Redundancy) awaitRace(streamCtx, settleCtx context.Context, attempts []
 				if nonStreamingTimeoutTimer != nil {
 					stopTimer(nonStreamingTimeoutTimer)
 				}
+				if winner == 0 {
+					if fallback := fallbackSuspiciousWinner(attempts); fallback != nil {
+						if err := race.promoteFallbackWinner(fallback); err != nil {
+							return err
+						}
+						winner = fallback.nonce
+					}
+				}
 				return e.finishRaceOutcome(settleCtx, attempts, params, decision, winner, raceFinishOptions{recordFailureSamples: true})
 			}
 		}
@@ -2029,9 +2430,11 @@ func (e *Redundancy) awaitRace(streamCtx, settleCtx context.Context, attempts []
 					}
 					e.markPhaseTransitionAbort(inf)
 					e.recordWinnerTerminalFailureOnce(inf, params, w)
-					go e.finishRaceWhenPendingDone(settleCtx, attempts, params, decision, w, raceFinishOptions{
-						forceTreatAsFailure:  true,
-						recordFailureSamples: true,
+					e.goTrackedRaceCleanup(func() {
+						e.finishRaceWhenPendingDone(settleCtx, attempts, params, decision, w, raceFinishOptions{
+							forceTreatAsFailure:  true,
+							recordFailureSamples: true,
+						})
 					})
 					logRequestStage(settleCtx, "winner_failed_after_content", "escrow", e.devshardID, "winner_nonce", w, "error", err)
 					return err
@@ -2095,7 +2498,7 @@ func (e *Redundancy) awaitRace(streamCtx, settleCtx context.Context, attempts []
 				recordFailureSamples:            true,
 				nonStreamingReducedTokenTimeout: true,
 			}
-			go func() {
+			e.goTrackedRaceCleanup(func() {
 				if err := e.finishRaceOutcome(settleCtx, attempts, params, decision, 0, opts); err != nil {
 					var timeoutErr *nonStreamingReducedMaxTokensTimeoutError
 					if errors.As(err, &timeoutErr) {
@@ -2103,7 +2506,7 @@ func (e *Redundancy) awaitRace(streamCtx, settleCtx context.Context, attempts []
 					}
 					logRequestStage(settleCtx, "background_finish_failed", "escrow", e.devshardID, "error", err)
 				}
-			}()
+			})
 			return &nonStreamingReducedMaxTokensTimeoutError{}
 		case <-stallC:
 			now := time.Now()
@@ -2172,7 +2575,9 @@ func (e *Redundancy) awaitRace(streamCtx, settleCtx context.Context, attempts []
 			}
 			pending := pendingInflights(attempts)
 			logRequestStage(settleCtx, "request_stream_canceled", "escrow", e.devshardID, "winner_nonce", winner, "pending", len(pending), "decision", decision.Reason, "error", streamCtx.Err())
-			go e.finishRaceWhenPendingDone(settleCtx, attempts, params, decision, winner, raceFinishOptions{})
+			e.goTrackedRaceCleanup(func() {
+				e.finishRaceWhenPendingDone(settleCtx, attempts, params, decision, winner, raceFinishOptions{})
+			})
 			return streamCtx.Err()
 		}
 
@@ -2223,6 +2628,14 @@ func (e *Redundancy) escalationForInflight(inf *inflight, params user.InferenceP
 	if inf == nil || inf.escalated {
 		return escalationTrigger{}, false
 	}
+	if inf.suspicious {
+		return escalationTrigger{
+			inf:      inf,
+			deadline: time.Now(),
+			stage:    "suspicious_host_immediate_escalation",
+			reason:   "suspicious_host",
+		}, true
+	}
 	if inf.probe {
 		return escalationTrigger{
 			inf:      inf,
@@ -2335,6 +2748,19 @@ type raceFinishOptions struct {
 	nonStreamingReducedTokenTimeout bool
 }
 
+// goTrackedRaceCleanup runs a background race cleanup detached while keeping the drain barrier aware of it; onRaceCleanupStart fires synchronously so the winning handler can never see the runtime as quiet mid-cleanup.
+func (e *Redundancy) goTrackedRaceCleanup(fn func()) {
+	if e.onRaceCleanupStart != nil {
+		e.onRaceCleanupStart()
+	}
+	go func() {
+		if e.onRaceCleanupDone != nil {
+			defer e.onRaceCleanupDone()
+		}
+		fn()
+	}()
+}
+
 func (e *Redundancy) finishRaceWhenPendingDone(ctx context.Context, attempts []*inflight, params user.InferenceParams, decision Decision, winnerNonce uint64, opts raceFinishOptions) {
 	bgCtx, _ := ensureRequestLogContext(context.Background())
 	bgCtx = logging.PropagateRequestID(bgCtx, ctx)
@@ -2751,6 +3177,18 @@ func isEmptyStreamAttempt(inf *inflight) bool {
 	return inf.contentChunks.Load() == 0
 }
 
+// isModelBurnEmpty: empty stream where the model generated tokens that vLLM
+// stripped (e.g. </think> at small max_tokens). Documented reasoning outcome,
+// not a host fault — must not penalize. Scoped to the reasoning route: the
+// completion_tokens signal is host-reported, so honoring it on non-reasoning
+// models would let any host dodge empty-stream quarantine by faking usage.
+func isModelBurnEmpty(inf *inflight, model string) bool {
+	if model != kimiK26ModelID || !isEmptyStreamAttempt(inf) {
+		return false
+	}
+	return inf.usageComplTokens.Load() > 0
+}
+
 func inflightByNonce(attempts []*inflight, nonce uint64) *inflight {
 	for _, inf := range attempts {
 		if inf.nonce == nonce {
@@ -2967,6 +3405,7 @@ func (e *Redundancy) recordPostContentWinnerFailureOnce(inf *inflight, params us
 		sample := RequestSample{
 			HostIdx:        inf.hostIdx,
 			ParticipantKey: participantKey,
+			Model:          gatewayMetricModel(params, e.model),
 			Responsive:     false,
 			SendTime:       inf.sendTime,
 			ReceiptTime:    inf.receiptTime,
@@ -2978,7 +3417,7 @@ func (e *Redundancy) recordPostContentWinnerFailureOnce(inf *inflight, params us
 		}
 		e.perf.Record(sample)
 		if e.participantLimiter != nil && e.perf.ParticipantFailureThresholdExceeded(participantKey) {
-			e.participantLimiter.ObserveStalledWinner(participantKey)
+			e.participantLimiter.ObserveStalledWinnerForModel(participantKey, e.model)
 		}
 		if e.metrics != nil {
 			e.metrics.ObserveRequestSample(e.devshardID, sample)
@@ -3084,15 +3523,18 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 			"content_source", inf.contentSource,
 			"error_source", inf.errorSource,
 			"probe", inf.probe,
+			"suspicious", inf.suspicious,
 		}
 		fields = append(fields, inf.stallLogFields(finishedAt)...)
 		logInferenceStage(ctx, inf.escrowID, inf.nonce, "race_completed", fields...)
+		e.recordGatewayAttemptTerminal(inf, params, winnerNonce, ok)
 		if !ok {
 			e.recordWinnerTerminalFailureOnce(inf, params, winnerNonce)
 			failed = append(failed, inf)
 		}
 	}
 	captureEmptyStreamAttemptRequest(ctx, e.devshardID, params, attempts, winnerNonce)
+	captureShortContentAttemptRequest(ctx, e.devshardID, params, attempts, winnerNonce)
 	effectiveSuccess := anySucceeded && !opts.forceTreatAsFailure
 	if !effectiveSuccess {
 		if opts.recordFailureSamples {
@@ -3106,16 +3548,19 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 			if inf.phaseTransitionAborted {
 				logInferenceStage(ctx, inf.escrowID, inf.nonce, "timeout_skipped",
 					"host", inf.hostID, "reason", "phase_transition_aborted")
+				e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", "phase_transition_aborted")
 				continue
 			}
 			if reason, skip := emptyStreamWithoutWinnerTimeoutSkipReason(inf, e.session); skip {
 				logInferenceStage(ctx, inf.escrowID, inf.nonce, "timeout_skipped",
 					"host", inf.hostID, "reason", reason)
+				e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", reason)
 				continue
 			}
 			if !shouldRunHandleTimeout(inf, e.session) {
 				logInferenceStage(ctx, inf.escrowID, inf.nonce, "timeout_skipped",
 					"host", inf.hostID, "reason", "nonce_already_finished")
+				e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", "nonce_already_finished")
 				continue
 			}
 			if e.longResponseFailureExempt(inf) {
@@ -3126,6 +3571,7 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 					"content_chunks", inf.contentChunks.Load(),
 					"output_bytes", inf.outputBytes.Load(),
 				)
+				e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", "long_response_after_content")
 				continue
 			}
 			payload := &host.InferencePayload{
@@ -3135,17 +3581,22 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 				MaxTokens:   params.MaxTokens,
 				StartedAt:   params.StartedAt,
 			}
+			e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "started", "none")
 			result, err := e.session.HandleTimeout(ctx, inf.nonce, inf.sendTime, payload)
 			if result.Reason != "" && e.metrics != nil {
 				e.metrics.RecordInferenceTimeout(result.Reason)
 			}
 			if err != nil {
+				e.recordGatewayTimeoutAction(inf, params, timeoutResultKind(result, inf), "failed", "timeout_collection_error")
 				logInferenceStage(ctx, inf.escrowID, inf.nonce, "timeout_failed", "host", inf.hostID, "error", err)
+			} else {
+				e.recordGatewayTimeoutAction(inf, params, timeoutResultKind(result, inf), "completed", "none")
 			}
 		}
 		if hostErr := hostApplicationErrorFromAttempts(attempts, winnerNonce); hostErr != nil {
 			captureAllAttemptsFailedRequest(ctx, e.devshardID, params, hostErr)
 			logRequestStage(ctx, "request_failed", "escrow", e.devshardID, "error", hostErr)
+			e.recordGatewayRequestOutcome(params.Model, "failed", gatewayRequestFailureReason(failed))
 			e.completeAccountingRequest(ctx, 0, decision, "failed")
 			e.logRequestSettled(ctx, 0, decision, "failed")
 			e.checkEscrowMissing(ctx, attempts)
@@ -3160,6 +3611,7 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 		}
 		captureAllAttemptsFailedRequest(ctx, e.devshardID, params, fmt.Errorf("%s", errMsg))
 		logRequestStage(ctx, "request_failed", "escrow", e.devshardID, "error", errMsg)
+		e.recordGatewayRequestOutcome(params.Model, "failed", gatewayRequestFailureReason(failed))
 		e.completeAccountingRequest(ctx, 0, decision, "failed")
 		e.logRequestSettled(ctx, 0, decision, "failed")
 		e.checkEscrowMissing(ctx, attempts)
@@ -3198,7 +3650,7 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 			StartedAt:   params.StartedAt,
 		}
 		if anySucceeded {
-			go func() {
+			e.goTrackedRaceCleanup(func() {
 				bgCtx, _ := ensureRequestLogContext(context.Background())
 				bgCtx = logging.PropagateRequestID(bgCtx, ctx)
 				for _, inf := range failed {
@@ -3209,16 +3661,19 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 					if inf.phaseTransitionAborted {
 						logInferenceStage(bgCtx, inf.escrowID, inf.nonce, "timeout_skipped",
 							"host", inf.hostID, "reason", "phase_transition_aborted")
+						e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", "phase_transition_aborted")
 						continue
 					}
 					if reason, blocked := e.escrowStateBlockReason(e.participantKeyForHost(inf.hostIdx)); blocked {
 						logInferenceStage(bgCtx, inf.escrowID, inf.nonce, "timeout_skipped",
 							"host", inf.hostID, "reason", reason)
+						e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", reason)
 						continue
 					}
 					if !shouldRunHandleTimeout(inf, e.session) {
 						logInferenceStage(bgCtx, inf.escrowID, inf.nonce, "timeout_skipped",
 							"host", inf.hostID, "reason", "nonce_already_finished")
+						e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", "nonce_already_finished")
 						continue
 					}
 					if e.longResponseFailureExempt(inf) {
@@ -3229,22 +3684,30 @@ func (e *Redundancy) finishRaceOutcome(ctx context.Context, attempts []*inflight
 							"content_chunks", inf.contentChunks.Load(),
 							"output_bytes", inf.outputBytes.Load(),
 						)
+						e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "skipped", "long_response_after_content")
 						continue
 					}
+					e.recordGatewayTimeoutAction(inf, params, timeoutKindForInflight(inf), "started", "none")
 					result, err := e.session.HandleTimeout(bgCtx, inf.nonce, inf.sendTime, payload)
 					if result.Reason != "" && e.metrics != nil {
 						e.metrics.RecordInferenceTimeout(result.Reason)
 					}
 					if err != nil {
+						e.recordGatewayTimeoutAction(inf, params, timeoutResultKind(result, inf), "failed", "timeout_collection_error")
 						logInferenceStage(bgCtx, inf.escrowID, inf.nonce, "background_timeout_failed", "host", inf.hostID, "error", err)
+					} else {
+						e.recordGatewayTimeoutAction(inf, params, timeoutResultKind(result, inf), "completed", "none")
 					}
 				}
 				e.logRequestSettled(bgCtx, winnerNonce, decision, "success")
-			}()
+			})
 		}
 	}
 
 	e.completeAccountingRequest(ctx, winnerNonce, decision, "success")
+	e.recordGatewayRequestOutcome(params.Model, "success", "none")
+	e.recordGatewayUserVisibleWin(attempts, params, winnerNonce)
+	e.recordGatewayHiddenFailure(params.Model, failed)
 	logRequestStage(ctx, "request_succeeded", "escrow", e.devshardID, "winner_nonce", winnerNonce, "decision", decision.Reason)
 	if len(failed) == 0 {
 		e.logRequestSettled(ctx, winnerNonce, decision, "success")
@@ -3271,7 +3734,15 @@ func (e *Redundancy) resolvedWinnerNonce(attempts []*inflight, winnerNonce uint6
 		return winnerNonce
 	}
 	for _, inf := range attempts {
-		if inf.probe {
+		if inf.probe || inf.suspicious {
+			continue
+		}
+		if e.session.IsNonceFinished(inf.nonce) && !isFailedStreamAttempt(inf) {
+			return inf.nonce
+		}
+	}
+	for _, inf := range attempts {
+		if inf.probe || !inf.suspicious {
 			continue
 		}
 		if e.session.IsNonceFinished(inf.nonce) && !isFailedStreamAttempt(inf) {
@@ -3281,6 +3752,18 @@ func (e *Redundancy) resolvedWinnerNonce(attempts []*inflight, winnerNonce uint6
 	return 0
 }
 
+func fallbackSuspiciousWinner(attempts []*inflight) *inflight {
+	for _, inf := range attempts {
+		if inf == nil || inf.probe || !inf.suspicious {
+			continue
+		}
+		if inf.contentChunks.Load() > 0 && !isFailedStreamAttempt(inf) {
+			return inf
+		}
+	}
+	return nil
+}
+
 func stopTimer(t *time.Timer) {
 	if t == nil {
 		return
@@ -3334,6 +3817,175 @@ func (e *Redundancy) completeAccountingRequest(ctx context.Context, winnerNonce
 	e.perf.CompleteAccountingRequest(requestID, e.devshardID, winnerNonce, decision.Reason, outcome, time.Now())
 }
 
+func (e *Redundancy) recordGatewayRequestOutcome(model, outcome, reason string) {
+	if e == nil || e.metrics == nil {
+		return
+	}
+	e.metrics.RecordGatewayRequest(model, outcome, reason)
+	if outcome == "failed" {
+		e.metrics.RecordCriticalUserFailure(model, reason)
+	}
+}
+
+func (e *Redundancy) recordGatewayAttemptStarted(inf *inflight, params user.InferenceParams) {
+	if e == nil || e.metrics == nil || inf == nil || inf.probe {
+		return
+	}
+	participantKey := e.participantKeyForHost(inf.hostIdx)
+	model := gatewayMetricModel(params, e.model)
+	role := gatewayAttemptRole(inf)
+	reason := gatewayAttemptStartReason(inf)
+	quarantineMode := e.quarantineModeForParticipant(participantKey)
+	e.metrics.RecordGatewaySlotDecision(GatewaySlotDecisionMetric{
+		ParticipantKey: participantKey,
+		Model:          model,
+		EscrowID:       inf.escrowID,
+		Decision:       "real_send",
+		Reason:         reason,
+		QuarantineMode: quarantineMode,
+	})
+	e.metrics.RecordGatewayAttemptStarted(GatewayAttemptStartMetric{
+		ParticipantKey: participantKey,
+		Model:          model,
+		Role:           role,
+		Reason:         reason,
+		QuarantineMode: quarantineMode,
+	})
+	if inf.suspicious {
+		e.metrics.RecordGatewayNoWinnerAttempt(participantKey, model, inf.noWinnerReason, inf.noWinnerQuarantineMode)
+	}
+}
+
+func (e *Redundancy) recordGatewayAttemptTerminal(inf *inflight, params user.InferenceParams, winnerNonce uint64, ok bool) {
+	if e == nil || e.metrics == nil || inf == nil || inf.probe {
+		return
+	}
+	outcome := "success"
+	if !ok {
+		outcome = "failed"
+	}
+	participantKey := e.participantKeyForHost(inf.hostIdx)
+	model := gatewayMetricModel(params, e.model)
+	visibility := gatewayAttemptVisibility(inf, winnerNonce, ok)
+	role := gatewayAttemptRole(inf)
+	e.metrics.RecordGatewayAttemptTerminal(GatewayAttemptTerminalMetric{
+		ParticipantKey: participantKey,
+		Model:          model,
+		Role:           role,
+		Outcome:        outcome,
+		Visibility:     visibility,
+	})
+	if !ok {
+		e.metrics.RecordGatewayAttemptFailure(GatewayAttemptFailureMetric{
+			ParticipantKey: participantKey,
+			Model:          model,
+			Role:           role,
+			Reason:         gatewayAttemptFailureReason(inf, e.session),
+			Visibility:     visibility,
+		})
+	}
+}
+
+func (e *Redundancy) recordGatewayUserVisibleWin(attempts []*inflight, params user.InferenceParams, winnerNonce uint64) {
+	if e == nil || e.metrics == nil || winnerNonce == 0 {
+		return
+	}
+	if winner := inflightByNonce(attempts, winnerNonce); winner != nil && !winner.probe {
+		e.metrics.RecordGatewayUserVisibleWin(e.participantKeyForHost(winner.hostIdx), gatewayMetricModel(params, e.model))
+	}
+}
+
+func (e *Redundancy) recordGatewayHiddenFailure(model string, failed []*inflight) {
+	if e == nil || e.metrics == nil || len(failed) == 0 {
+		return
+	}
+	for _, inf := range failed {
+		if inf == nil || inf.probe {
+			continue
+		}
+		e.metrics.RecordGatewayHiddenFailure(model, "protected", gatewayAttemptFailureReason(inf, e.session))
+		return
+	}
+}
+
+func (e *Redundancy) recordGatewayTimeoutAction(inf *inflight, params user.InferenceParams, kind, action, reason string) {
+	if e == nil || e.metrics == nil || inf == nil || inf.probe {
+		return
+	}
+	e.metrics.RecordGatewayTimeoutAction(GatewayTimeoutActionMetric{
+		ParticipantKey: e.participantKeyForHost(inf.hostIdx),
+		Model:          gatewayMetricModel(params, e.model),
+		Kind:           kind,
+		Action:         action,
+		Reason:         reason,
+	})
+}
+
+func (e *Redundancy) quarantineModeForParticipant(participantKey string) string {
+	if e == nil || participantKey == "" {
+		return "none"
+	}
+	if status, ok := e.noWinnerStatusForParticipant(participantKey); ok {
+		if status.quarantineMode != "" {
+			return status.quarantineMode
+		}
+		return "probation"
+	}
+	if e.participantLimiter != nil && e.participantLimiter.IsBlockedForModel(participantKey, e.model) {
+		return participantQuarantineProbe.String()
+	}
+	return "none"
+}
+
+func gatewayMetricModel(params user.InferenceParams, fallback string) string {
+	if params.Model != "" {
+		return params.Model
+	}
+	return fallback
+}
+
+func gatewayAttemptRole(inf *inflight) string {
+	if inf == nil || strings.TrimSpace(inf.role) == "" {
+		return "primary"
+	}
+	return inf.role
+}
+
+func gatewayAttemptStartReason(inf *inflight) string {
+	if inf == nil || strings.TrimSpace(inf.startReason) == "" {
+		return "primary"
+	}
+	return inf.startReason
+}
+
+func gatewayRequestFailureReason(failed []*inflight) string {
+	for _, inf := range failed {
+		if inf != nil && !inf.probe {
+			return gatewayAttemptFailureReason(inf, nil)
+		}
+	}
+	return "unknown"
+}
+
+func timeoutKindForInflight(inf *inflight) string {
+	if inf == nil {
+		return "unknown"
+	}
+	if inf.receiptTime.IsZero() {
+		return "refused"
+	}
+	return "execution"
+}
+
+func timeoutResultKind(result user.TimeoutResult, inf *inflight) string {
+	switch result.Reason {
+	case "refused", "execution":
+		return result.Reason
+	default:
+		return timeoutKindForInflight(inf)
+	}
+}
+
 func (e *Redundancy) buildInvolvement(inf *inflight, winnerNonce uint64, params user.InferenceParams) HostInvolvement {
 	successfulForPerf := attemptCountsAsSuccessfulForPerf(inf, params, e.session)
 	hi := HostInvolvement{
@@ -3365,18 +4017,32 @@ func (e *Redundancy) recordSample(inf *inflight, params user.InferenceParams, re
 	if inf.phaseTransitionAborted {
 		return
 	}
-	if !requestSucceeded && isEmptyStreamAttempt(inf) {
-		return
-	}
 	// Long non-stream responses that end empty around the client timeout are
 	// still useful timing samples, but should not be treated like fast empty
 	// stream faults for participant quarantine.
 	longNonStreamEmptyExempt := longNonStreamEmptyFailureExempt(inf, params)
-	responsive := attemptCountsAsSuccessfulForPerf(inf, params, e.session)
+	emptyStream := isEmptyStreamAttempt(inf)
+	if emptyStream && emptyStreamAccountingSuppressedByPoC() {
+		return
+	}
 	participantKey := e.participantKeyForHost(inf.hostIdx)
+	if emptyStream && !longNonStreamEmptyExempt && e.participantLimiter != nil {
+		if isModelBurnEmpty(inf, e.model) {
+			// Reasoning-burn outcome: the model emitted completion tokens but
+			// no content. Telemetry-only — not a host fault, no quarantine.
+			e.participantLimiter.ObserveModelBurnEmpty(participantKey, e.model)
+		} else {
+			e.participantLimiter.ObserveEmptyStreamForModel(participantKey, e.model)
+		}
+	}
+	if !requestSucceeded && emptyStream {
+		return
+	}
+	responsive := attemptCountsAsSuccessfulForPerf(inf, params, e.session)
 	sample := RequestSample{
 		HostIdx:        inf.hostIdx,
 		ParticipantKey: participantKey,
+		Model:          gatewayMetricModel(params, e.model),
 		Responsive:     responsive,
 		SendTime:       inf.sendTime,
 		ReceiptTime:    inf.receiptTime,
@@ -3389,8 +4055,8 @@ func (e *Redundancy) recordSample(inf *inflight, params user.InferenceParams, re
 	e.perf.Record(sample)
 	if e.participantLimiter != nil {
 		switch {
-		case e.session.IsNonceFinished(inf.nonce) && !longNonStreamEmptyExempt:
-			e.participantLimiter.ObserveSuccessfulInference(participantKey)
+		case responsive && !longNonStreamEmptyExempt:
+			e.participantLimiter.ObserveSuccessfulInferenceForModel(participantKey, e.model)
 		}
 	}
 	if e.metrics != nil {
@@ -3398,6 +4064,10 @@ func (e *Redundancy) recordSample(inf *inflight, params user.InferenceParams, re
 	}
 }
 
+func emptyStreamAccountingSuppressedByPoC() bool {
+	return relaxedPoCBypassActive()
+}
+
 func probeParams(params user.InferenceParams) user.InferenceParams {
 	params.Prompt = pocProbePromptBody
 	params.InputLength = uint64(len(pocProbePromptBody))
@@ -3465,6 +4135,17 @@ func (e *Redundancy) runGhostProbe(prepared *user.PreparedInference, kind ghostK
 	if prepared == nil || e.session == nil {
 		return
 	}
+	participantKey := e.participantKeyForHost(prepared.HostIdx())
+	if e.metrics != nil {
+		e.metrics.RecordGatewaySlotDecision(GatewaySlotDecisionMetric{
+			ParticipantKey: participantKey,
+			Model:          e.model,
+			EscrowID:       e.devshardID,
+			Decision:       "ghost_no_send",
+			Reason:         reason,
+			QuarantineMode: e.quarantineModeForParticipant(participantKey),
+		})
+	}
 	ctx, _ := ensureRequestLogContext(context.Background())
 	logInferenceStage(ctx, e.devshardID, prepared.Nonce(), "ghost_probe_skipped",
 		"host", e.session.HostLabel(prepared.HostIdx()),
diff --git a/devshard/cmd/devshardctl/redundancy_empty_stream_test.go b/devshard/cmd/devshardctl/redundancy_empty_stream_test.go
index a601be33fd..70f527bc48 100644
--- a/devshard/cmd/devshardctl/redundancy_empty_stream_test.go
+++ b/devshard/cmd/devshardctl/redundancy_empty_stream_test.go
@@ -589,6 +589,135 @@ func TestIsEmptyStreamAttempt(t *testing.T) {
 	})
 }
 
+func TestSseChunkUsageCompletionTokens(t *testing.T) {
+	cases := []struct {
+		name    string
+		body    string
+		wantTok int64
+		wantOK  bool
+	}{
+		{
+			name:    "usage_with_completion_tokens",
+			body:    `data: {"choices":[],"usage":{"prompt_tokens":12,"completion_tokens":100,"total_tokens":112}}` + "\n\n",
+			wantTok: 100,
+			wantOK:  true,
+		},
+		{
+			name:    "usage_zero_completion_tokens",
+			body:    `data: {"usage":{"prompt_tokens":12,"completion_tokens":0,"total_tokens":12}}` + "\n\n",
+			wantTok: 0,
+			wantOK:  false,
+		},
+		{
+			name:    "usage_absent",
+			body:    `data: {"choices":[{"delta":{"content":"hi"}}]}` + "\n\n",
+			wantTok: 0,
+			wantOK:  false,
+		},
+		{
+			name:    "done_marker_only",
+			body:    "data: [DONE]\n\n",
+			wantTok: 0,
+			wantOK:  false,
+		},
+		{
+			name:    "empty_input",
+			body:    "",
+			wantTok: 0,
+			wantOK:  false,
+		},
+		{
+			name:    "malformed_json_skipped",
+			body:    "data: {not json}\n\ndata: {\"usage\":{\"completion_tokens\":42}}\n\n",
+			wantTok: 42,
+			wantOK:  true,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			tok, ok := sseChunkUsageCompletionTokens([]byte(tc.body))
+			require.Equal(t, tc.wantOK, ok)
+			require.Equal(t, tc.wantTok, tok)
+		})
+	}
+}
+
+// usage chunk without content must still bump usageComplTokens.
+func TestRaceWriter_CapturesUsageCompletionTokens(t *testing.T) {
+	ctx := context.Background()
+	var sink bytes.Buffer
+	rg := newRaceGroup(ctx, ctx, "escrow-x", &sink)
+
+	inf := &inflight{
+		hostID:       "host-A",
+		escrowID:     "escrow-x",
+		nonce:        1,
+		done:         make(chan struct{}),
+		receiptCh:    make(chan struct{}),
+		firstTokenCh: make(chan struct{}),
+		receiptTime:  time.Now(),
+	}
+	rw := &raceWriter{group: rg, nonce: 1, inf: inf}
+
+	usageChunk := []byte(`data: {"choices":[{"delta":{},"finish_reason":"length"}],"usage":{"prompt_tokens":12,"completion_tokens":100,"total_tokens":112}}` + "\n\n")
+	_, err := rw.Write(usageChunk)
+	require.NoError(t, err)
+
+	require.Equal(t, int64(100), inf.usageComplTokens.Load())
+	require.Equal(t, int64(0), inf.contentChunks.Load())
+
+	// And the classifier should now route this attempt to model-burn.
+	require.True(t, isEmptyStreamAttempt(inf))
+	require.True(t, isModelBurnEmpty(inf, kimiK26ModelID))
+}
+
+func TestIsModelBurnEmpty(t *testing.T) {
+	t.Run("not_empty_attempt", func(t *testing.T) {
+		inf := &inflight{receiptTime: time.Now()}
+		inf.outputChunks.Store(3)
+		inf.contentChunks.Store(1)
+		require.False(t, isModelBurnEmpty(inf, kimiK26ModelID), "non-empty attempt is never burn-empty")
+	})
+	t.Run("empty_with_zero_completion_tokens_is_host_fault", func(t *testing.T) {
+		inf := &inflight{receiptTime: time.Now()}
+		inf.outputChunks.Store(2)
+		require.True(t, isEmptyStreamAttempt(inf))
+		require.False(t, isModelBurnEmpty(inf, kimiK26ModelID))
+	})
+	t.Run("empty_with_positive_completion_tokens_is_model_burn", func(t *testing.T) {
+		inf := &inflight{receiptTime: time.Now()}
+		inf.outputChunks.Store(5)
+		inf.usageComplTokens.Store(100)
+		require.True(t, isEmptyStreamAttempt(inf))
+		require.True(t, isModelBurnEmpty(inf, kimiK26ModelID))
+	})
+	t.Run("probe_is_never_burn", func(t *testing.T) {
+		inf := &inflight{probe: true, receiptTime: time.Now()}
+		inf.usageComplTokens.Store(100)
+		require.False(t, isModelBurnEmpty(inf, kimiK26ModelID))
+	})
+	t.Run("no_receipt_is_never_burn", func(t *testing.T) {
+		inf := &inflight{}
+		inf.usageComplTokens.Store(100)
+		require.False(t, isModelBurnEmpty(inf, kimiK26ModelID))
+	})
+	t.Run("error_stream_not_burn", func(t *testing.T) {
+		inf := &inflight{receiptTime: time.Now(), errorSource: "error.BadRequestError"}
+		inf.outputChunks.Store(2)
+		inf.usageComplTokens.Store(100)
+		require.False(t, isModelBurnEmpty(inf, kimiK26ModelID))
+	})
+	t.Run("non_reasoning_model_is_never_burn", func(t *testing.T) {
+		// The completion_tokens signal is host-reported; only the reasoning route
+		// honors it, so a burn-shaped empty on any other model stays a host fault.
+		inf := &inflight{receiptTime: time.Now()}
+		inf.outputChunks.Store(5)
+		inf.usageComplTokens.Store(100)
+		require.True(t, isEmptyStreamAttempt(inf))
+		require.False(t, isModelBurnEmpty(inf, "Qwen/Qwen3-235B-A22B-Instruct-2507"))
+	})
+}
+
 // TestRaceWriter_BuffersRoleUntilContent verifies that a single attempt
 // streaming role-chunk -> content-chunk -> [DONE] produces correctly ordered
 // output to the race group writer with no winner declared until content
diff --git a/devshard/cmd/devshardctl/request_capture.go b/devshard/cmd/devshardctl/request_capture.go
index 0de2c67f11..cd3807ab31 100644
--- a/devshard/cmd/devshardctl/request_capture.go
+++ b/devshard/cmd/devshardctl/request_capture.go
@@ -17,10 +17,24 @@ import (
 
 const requestCaptureDirName = "captured-requests"
 
+const (
+	defaultShortContentMinOutputChunks  = int64(1000)
+	defaultShortContentMaxContentRatio  = 0.75
+	defaultShortContentResponseMaxBytes = int64(16 * 1024 * 1024)
+)
+
 type requestCaptureStore struct {
 	dir string
 }
 
+type requestCaptureOptions struct {
+	shortContentAttempts    bool
+	shortContentResponses   bool
+	shortContentMinOutput   int64
+	shortContentMaxRatio    float64
+	shortContentMaxResponse int64
+}
+
 type capturedChatRequest struct {
 	RequestID    string                `json:"request_id,omitempty"`
 	CapturedAt   string                `json:"captured_at"`
@@ -62,11 +76,15 @@ type capturedChatAttempt struct {
 	ErrorMessage                string `json:"error_message,omitempty"`
 	ResponseBodySample          string `json:"response_body_sample,omitempty"`
 	ResponseBodySampleTruncated bool   `json:"response_body_sample_truncated,omitempty"`
+	ResponseBodyBase64          string `json:"response_body_base64,omitempty"`
+	ResponseBodyTruncated       bool   `json:"response_body_truncated,omitempty"`
+	ResponseBodyBytes           int    `json:"response_body_bytes,omitempty"`
 }
 
 var (
 	requestCaptureMu     sync.RWMutex
 	activeRequestCapture *requestCaptureStore
+	activeCaptureOptions requestCaptureOptions
 )
 
 func configureRequestCaptureStore(baseStorageDir string) {
@@ -79,6 +97,7 @@ func configureRequestCaptureStore(baseStorageDir string) {
 	if dir == "" {
 		dir = filepath.Join(baseStorageDir, requestCaptureDirName)
 	}
+	configureRequestCaptureOptionsFromEnv()
 	setRequestCaptureStore(&requestCaptureStore{dir: dir})
 }
 
@@ -94,6 +113,38 @@ func currentRequestCaptureStore() *requestCaptureStore {
 	return activeRequestCapture
 }
 
+func configureRequestCaptureOptionsFromEnv() {
+	opts := requestCaptureOptions{
+		shortContentAttempts:    readBoolEnv("DEVSHARD_CAPTURE_SHORT_CONTENT_ATTEMPTS", false),
+		shortContentResponses:   readBoolEnv("DEVSHARD_CAPTURE_SHORT_CONTENT_RESPONSES", false),
+		shortContentMinOutput:   readInt64Env("DEVSHARD_CAPTURE_SHORT_CONTENT_MIN_OUTPUT_CHUNKS", defaultShortContentMinOutputChunks),
+		shortContentMaxRatio:    readFloat64Env("DEVSHARD_CAPTURE_SHORT_CONTENT_MAX_CONTENT_RATIO", defaultShortContentMaxContentRatio),
+		shortContentMaxResponse: readInt64Env("DEVSHARD_CAPTURE_SHORT_CONTENT_RESPONSE_MAX_BYTES", defaultShortContentResponseMaxBytes),
+	}
+	setRequestCaptureOptions(opts)
+}
+
+func setRequestCaptureOptions(opts requestCaptureOptions) {
+	if opts.shortContentMinOutput < 1 {
+		opts.shortContentMinOutput = defaultShortContentMinOutputChunks
+	}
+	if opts.shortContentMaxRatio <= 0 || opts.shortContentMaxRatio >= 1 {
+		opts.shortContentMaxRatio = defaultShortContentMaxContentRatio
+	}
+	if opts.shortContentMaxResponse < 0 {
+		opts.shortContentMaxResponse = 0
+	}
+	requestCaptureMu.Lock()
+	defer requestCaptureMu.Unlock()
+	activeCaptureOptions = opts
+}
+
+func currentRequestCaptureOptions() requestCaptureOptions {
+	requestCaptureMu.RLock()
+	defer requestCaptureMu.RUnlock()
+	return activeCaptureOptions
+}
+
 func captureFilterRejectedRequest(r *http.Request, body []byte, err error, model, escrow string) {
 	if r == nil || err == nil || len(body) == 0 {
 		return
@@ -166,6 +217,35 @@ func captureEmptyStreamAttemptRequest(ctx context.Context, escrow string, params
 	_ = store.write(record)
 }
 
+func captureShortContentAttemptRequest(ctx context.Context, escrow string, params user.InferenceParams, attempts []*inflight, winnerNonce uint64) {
+	opts := currentRequestCaptureOptions()
+	if len(params.Prompt) == 0 || !opts.shortContentAttempts || !hasShortContentAttempt(attempts, opts) {
+		return
+	}
+	store := currentRequestCaptureStore()
+	if store == nil {
+		return
+	}
+	record := capturedChatRequest{
+		RequestID:    requestIDOrEmpty(ctx),
+		CapturedAt:   time.Now().UTC().Format(time.RFC3339Nano),
+		Kind:         "short_content_attempt",
+		Error:        shortContentCaptureReason(opts),
+		Path:         "/v1/chat/completions",
+		Model:        params.Model,
+		Escrow:       escrow,
+		Stream:       params.Stream,
+		RequestFlags: requestFlagsForLog(params),
+		Attempts:     capturedAttempts(attempts, winnerNonce),
+	}
+	setCapturedRequestBody(&record, params.Prompt)
+	_ = store.write(record)
+}
+
+func shortContentCaptureReason(opts requestCaptureOptions) string {
+	return fmt.Sprintf("content_chunks/output_chunks below %.4g with output_chunks >= %d", opts.shortContentMaxRatio, opts.shortContentMinOutput)
+}
+
 func hasEmptyStreamAttempt(attempts []*inflight) bool {
 	for _, inf := range attempts {
 		if inf != nil && !inf.probe && isEmptyStreamAttempt(inf) {
@@ -175,7 +255,29 @@ func hasEmptyStreamAttempt(attempts []*inflight) bool {
 	return false
 }
 
+func hasShortContentAttempt(attempts []*inflight, opts requestCaptureOptions) bool {
+	for _, inf := range attempts {
+		if isShortContentAttempt(inf, opts) {
+			return true
+		}
+	}
+	return false
+}
+
+func isShortContentAttempt(inf *inflight, opts requestCaptureOptions) bool {
+	if inf == nil || inf.probe {
+		return false
+	}
+	outputChunks := inf.outputChunks.Load()
+	if outputChunks < opts.shortContentMinOutput {
+		return false
+	}
+	contentChunks := inf.contentChunks.Load()
+	return float64(contentChunks)/float64(outputChunks) < opts.shortContentMaxRatio
+}
+
 func capturedAttempts(attempts []*inflight, winnerNonce uint64) []capturedChatAttempt {
+	opts := currentRequestCaptureOptions()
 	captured := make([]capturedChatAttempt, 0, len(attempts))
 	for _, inf := range attempts {
 		if inf == nil {
@@ -195,7 +297,7 @@ func capturedAttempts(attempts []*inflight, winnerNonce uint64) []capturedChatAt
 		if inf.err != nil {
 			errText = inf.err.Error()
 		}
-		captured = append(captured, capturedChatAttempt{
+		attempt := capturedChatAttempt{
 			Escrow:                      inf.escrowID,
 			Nonce:                       inf.nonce,
 			Host:                        inf.hostID,
@@ -220,7 +322,13 @@ func capturedAttempts(attempts []*inflight, winnerNonce uint64) []capturedChatAt
 			ErrorMessage:                inf.errorMessage,
 			ResponseBodySample:          inf.emptyResponseBodySample,
 			ResponseBodySampleTruncated: inf.emptyResponseBodySampleTruncated,
-		})
+		}
+		if opts.shortContentResponses && isShortContentAttempt(inf, opts) && len(inf.shortContentResponseBody) > 0 {
+			attempt.ResponseBodyBase64 = base64.StdEncoding.EncodeToString(inf.shortContentResponseBody)
+			attempt.ResponseBodyTruncated = inf.shortContentResponseBodyTruncated
+			attempt.ResponseBodyBytes = len(inf.shortContentResponseBody)
+		}
+		captured = append(captured, attempt)
 	}
 	return captured
 }
diff --git a/devshard/cmd/devshardctl/request_capture_test.go b/devshard/cmd/devshardctl/request_capture_test.go
index d2855bbf55..3fcbf8a0fb 100644
--- a/devshard/cmd/devshardctl/request_capture_test.go
+++ b/devshard/cmd/devshardctl/request_capture_test.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
@@ -123,14 +124,68 @@ func TestCaptureEmptyStreamAttemptRequestWritesSeparateFileWithAttempts(t *testi
 	require.False(t, record.Attempts[1].EmptyStream)
 }
 
-func TestConfigureRequestCaptureStoreDisabledByDefault(t *testing.T) {
-	t.Setenv("DEVSHARD_REQUEST_CAPTURE_DIR", "")
-	t.Setenv("DEVSHARD_REQUEST_CAPTURE_ENABLED", "")
-	t.Cleanup(func() { setRequestCaptureStore(nil) })
+func TestCaptureShortContentAttemptRequestWritesResponseBodyForShortAttempt(t *testing.T) {
+	captureDir := t.TempDir()
+	setRequestCaptureStore(&requestCaptureStore{dir: captureDir})
+	setRequestCaptureOptions(requestCaptureOptions{
+		shortContentAttempts:    true,
+		shortContentResponses:   true,
+		shortContentMinOutput:   10,
+		shortContentMaxRatio:    0.5,
+		shortContentMaxResponse: 1024,
+	})
+	t.Cleanup(func() {
+		setRequestCaptureStore(nil)
+		setRequestCaptureOptions(requestCaptureOptions{})
+	})
 
-	configureRequestCaptureStore(t.TempDir())
+	ctx, requestID := ensureRequestLogContext(t.Context())
+	rawResponse := []byte("data: {\"choices\":[{\"delta\":{\"role\":\"assistant\"}}]}\n\ndata: [DONE]\n\n")
+	attempts := []*inflight{
+		{
+			hostIdx:                  2,
+			hostID:                   "host-short",
+			escrowID:                 "escrow-7",
+			nonce:                    11,
+			resp:                     &host.HostResponse{ConfirmedAt: 123, Receipt: []byte("receipt"), StreamBytesRead: int64(len(rawResponse))},
+			shortContentResponseBody: rawResponse,
+		},
+		{
+			hostIdx:  3,
+			hostID:   "host-normal",
+			escrowID: "escrow-7",
+			nonce:    12,
+			resp:     &host.HostResponse{ConfirmedAt: 124, Receipt: []byte("receipt"), StreamBytesRead: 640},
+		},
+	}
+	attempts[0].outputChunks.Store(20)
+	attempts[0].contentChunks.Store(2)
+	attempts[0].outputBytes.Store(int64(len(rawResponse)))
+	attempts[1].outputChunks.Store(20)
+	attempts[1].contentChunks.Store(20)
+	attempts[1].outputBytes.Store(640)
+
+	captureShortContentAttemptRequest(ctx, "escrow-7", user.InferenceParams{
+		Model:  "Qwen/Test",
+		Prompt: []byte(`{"model":"Qwen/Test","stream":true,"messages":[{"role":"user","content":"hello"}]}`),
+		Stream: true,
+	}, attempts, 12)
 
-	require.Nil(t, currentRequestCaptureStore())
+	record := requireSingleCapturedRequest(t, captureDir, "short_content_attempt")
+	require.Equal(t, requestID, record.RequestID)
+	require.Equal(t, "short_content_attempt", record.Kind)
+	require.Equal(t, "Qwen/Test", record.Model)
+	require.Equal(t, "escrow-7", record.Escrow)
+	require.Contains(t, record.Error, "content_chunks/output_chunks")
+	require.Len(t, record.Attempts, 2)
+	require.Equal(t, "host-short", record.Attempts[0].Host)
+	require.Equal(t, int64(20), record.Attempts[0].OutputChunks)
+	require.Equal(t, int64(2), record.Attempts[0].ContentChunks)
+	require.Equal(t, len(rawResponse), record.Attempts[0].ResponseBodyBytes)
+	decoded, err := base64.StdEncoding.DecodeString(record.Attempts[0].ResponseBodyBase64)
+	require.NoError(t, err)
+	require.Equal(t, rawResponse, decoded)
+	require.Empty(t, record.Attempts[1].ResponseBodyBase64)
 }
 
 func TestConfigureRequestCaptureStoreDefaultsUnderGatewayDBDirectory(t *testing.T) {
@@ -146,19 +201,6 @@ func TestConfigureRequestCaptureStoreDefaultsUnderGatewayDBDirectory(t *testing.
 	require.Equal(t, filepath.Join(baseStorageDir, requestCaptureDirName), store.dir)
 }
 
-func TestConfigureRequestCaptureStoreUsesExplicitDir(t *testing.T) {
-	captureDir := t.TempDir()
-	t.Setenv("DEVSHARD_REQUEST_CAPTURE_ENABLED", "true")
-	t.Setenv("DEVSHARD_REQUEST_CAPTURE_DIR", captureDir)
-	t.Cleanup(func() { setRequestCaptureStore(nil) })
-
-	configureRequestCaptureStore(t.TempDir())
-
-	store := currentRequestCaptureStore()
-	require.NotNil(t, store)
-	require.Equal(t, captureDir, store.dir)
-}
-
 func requireSingleCapturedRequest(t *testing.T, captureDir, kind string) capturedChatRequest {
 	t.Helper()
 	entries, err := os.ReadDir(filepath.Join(captureDir, kind))
diff --git a/devshard/cmd/devshardctl/request_filters.go b/devshard/cmd/devshardctl/request_filters.go
index cfac4a0dcc..98084e2677 100644
--- a/devshard/cmd/devshardctl/request_filters.go
+++ b/devshard/cmd/devshardctl/request_filters.go
@@ -90,10 +90,10 @@ func (p ChatRequestPipeline) Normalize(body []byte, adminAuthenticated bool, lim
 	if err := p.parameters.Apply(RequestFilterStagePreValidation, ctx); err != nil {
 		return nil, chatRequest{}, err
 	}
-	if err := p.messages.NormalizeDocument(&ctx.Document); err != nil {
+	if err := p.messages.NormalizeDocument(&ctx.Document, ctx.RoutedModel); err != nil {
 		return nil, chatRequest{}, err
 	}
-	if err := p.messages.ValidateDocument(&ctx.Document); err != nil {
+	if err := p.messages.ValidateDocument(&ctx.Document, ctx.RoutedModel); err != nil {
 		return nil, chatRequest{}, err
 	}
 	if err := ctx.DecodeRequest(); err != nil {
@@ -139,6 +139,7 @@ func (p ChatRequestPipeline) applyOutputTokenLimits(ctx *RequestFilterContext) {
 	case hasMaxCompletionTokens:
 		maxCompletionTokens := capOutputTokens(ctx.Request.MaxCompletionTokens, true, ctx.AdminAuthenticated, limits)
 		ctx.Document.Set("max_completion_tokens", maxCompletionTokens)
+		ctx.Document.Set("max_tokens", maxCompletionTokens)
 		ctx.Request.MaxCompletionTokens = maxCompletionTokens
 		ctx.Request.MaxTokens = maxCompletionTokens
 	default:
diff --git a/devshard/cmd/devshardctl/request_filters_config.go b/devshard/cmd/devshardctl/request_filters_config.go
index f0d5b03048..1e92401c93 100644
--- a/devshard/cmd/devshardctl/request_filters_config.go
+++ b/devshard/cmd/devshardctl/request_filters_config.go
@@ -5,7 +5,11 @@ const (
 	MaxChatRequestBodySize       = 10 * 1024 * 1024
 	MaxLoggedResponseFormatBytes = 2048 * 1024
 	MaxChatRequestChoices        = 5
+	MinTemperature               = 0.0
 	MaxTemperature               = 2.0
+	MinPMin                      = 0.0
+	MinPMax                      = 1.0
+	TopPMax                      = 1.0
 	MaxRepetitionPenalty         = 2.0
 )
 
@@ -20,7 +24,7 @@ const (
 // wrappers (~9-10 levels) plus a small allowance for client-side structuring.
 const MaxRequestNestingDepth = 32
 
-// Per-parameter bounds wired into the catalog. Values match supported-params.md.
+// Per-parameter bounds wired into the catalog. Values match docs/chat-api/README.md.
 const (
 	MessagesMaxEntries = 2048
 
@@ -65,7 +69,7 @@ const (
 
 	UserMaxLen             = 512
 	SafetyIdentifierMaxLen = 512
-	
+
 	StructuredOutputsMaxDepth            = 16
 	StructuredOutputsMaxSize             = 16 * 1024
 	StructuredOutputsMaxNodes            = 128
@@ -81,12 +85,28 @@ const (
 	kimiThinkingTokenBudgetDefaultDivisor uint64 = 2
 	kimiThinkingTokenBudgetMax            uint64 = 96_000
 
-	// Below this floor Kimi-K2.6 emits only </think> (special token vLLM drops from content).
+	// Below this floor Kimi-K2.6 emits only </think> (vLLM strips it).
 	kimiMaxTokensMin uint64 = 16
+	// Below this max_tokens, force thinking_token_budget=0 — any thinking
+	// phase starves visible content at this budget.
+	kimiSmallMaxTokensForceNoThinking uint64 = 256
+	// Tokens reserved for visible content after </think>. ttb is clamped
+	// to (max_tokens - this).
+	kimiContentHeadroomMin uint64 = 64
+
+	MinimaxToolMessageMaxEntries = 16
+	MinimaxToolMessageNameMaxLen = 64
+	// 64 KiB per-entry defensive cap; no vendor recommendation (MiniMax-4 fixes shape,
+	// not size). Sized to fit common agent tool-results (file reads, build logs).
+	MinimaxToolMessageTextMaxSize = 64 * 1024
 )
 
-// Routed model identifiers. The catalog wires per-model behavior keyed on these strings.
-const kimiK26ModelID = "moonshotai/Kimi-K2.6"
+// Routed model identifiers. The parameter catalog and the message processor
+// both dispatch on these strings.
+const (
+	kimiK26ModelID    = "moonshotai/Kimi-K2.6"
+	miniMaxM27ModelID = "MiniMaxAI/MiniMax-M2.7"
+)
 
 // Sentinel content used by message normalization when an upstream tool result is empty.
 const emptyToolResultContent = "<empty tool result>"
diff --git a/devshard/cmd/devshardctl/request_filters_messages.go b/devshard/cmd/devshardctl/request_filters_messages.go
index b8749b4326..ff4eba8787 100644
--- a/devshard/cmd/devshardctl/request_filters_messages.go
+++ b/devshard/cmd/devshardctl/request_filters_messages.go
@@ -1,8 +1,7 @@
 package main
 
 import (
-	"fmt"
-	"strings"
+	"devshard/cmd/devshardctl/messagevalidators"
 )
 
 type MessageRole string
@@ -23,21 +22,88 @@ const (
 	MessageContentOptionalWithCalls
 )
 
+// MessageRolePolicy bundles validate-side rules for a (route, role) pair.
+// Per-model overrides plug into ChatMessageProcessor.modelRoles and replace
+// the default entry verbatim for that role on that route.
 type MessageRolePolicy struct {
 	Role              MessageRole
 	DisallowedFields  []string
 	RequireName       bool
 	RequireToolCallID bool
 	ContentRule       MessageContentRule
+	// ContentValidator, when non-nil, replaces the default role-specific
+	// content shape check. Used by MiniMax-M2.7 tool messages whose content
+	// is a {name,type,text}[] array instead of a string.
+	ContentValidator messagevalidators.ContentValidator
 }
 
+// MessageNormalizer rewrites the messages array before ValidateDocument runs.
+// Returns the (possibly filtered/rewritten) messages, whether anything
+// changed, and an unrecoverable error (which the caller wraps as HTTP 400).
+type MessageNormalizer interface {
+	Apply(messages []any) ([]any, bool, error)
+}
+
+// ChatMessageProcessor coordinates per-model normalization and validation.
+// Mirrors defaultVLLMParameterCatalog's per-model dispatch pattern for the
+// message side of the pipeline.
 type ChatMessageProcessor struct {
-	roles map[string]MessageRolePolicy
+	defaultRoles       map[string]MessageRolePolicy
+	modelRoles         map[string]map[string]MessageRolePolicy
+	defaultNormalizers []MessageNormalizer
+	modelNormalizers   map[string][]MessageNormalizer
 }
 
 var defaultMessageProcessor = defaultChatMessageProcessor()
 
 func defaultChatMessageProcessor() ChatMessageProcessor {
+	return ChatMessageProcessor{
+		defaultRoles: openAIRolePolicies(),
+		// Per-model role-policy overrides. Adding a model = add one row.
+		modelRoles: map[string]map[string]MessageRolePolicy{
+			// MiniMax-M2.7 tool messages omit tool_call_id and carry results as a
+			// {name,type,text}[] array — see docs/chat-api/minimax-m2.7.md.
+			miniMaxM27ModelID: {
+				string(MessageRoleTool): {
+					Role:              MessageRoleTool,
+					DisallowedFields:  []string{"tool_calls", "function_call"},
+					RequireToolCallID: false,
+					ContentRule:       MessageContentRequired,
+					ContentValidator: messagevalidators.MinimaxToolMessage{
+						MaxEntries:  MinimaxToolMessageMaxEntries,
+						NameMaxLen:  MinimaxToolMessageNameMaxLen,
+						TextMaxSize: MinimaxToolMessageTextMaxSize,
+					},
+				},
+			},
+		},
+		defaultNormalizers: []MessageNormalizer{
+			messagevalidators.OrphanToolMessageDropper{},
+			messagevalidators.EmptyAssistantTurnDropper{},
+			messagevalidators.EmptyContentNormalizer{ToolSentinel: emptyToolResultContent},
+			messagevalidators.LegacyToolNameStripper{},
+			messagevalidators.TextPartsFlattener{},
+		},
+		// Per-model normalizer chain overrides. Adding a model = add one row.
+		modelNormalizers: map[string][]MessageNormalizer{
+			miniMaxM27ModelID: {
+				messagevalidators.MinimaxOrphanToolMessageDropper{},
+				messagevalidators.EmptyAssistantTurnDropper{},
+				messagevalidators.EmptyContentNormalizer{
+					ToolSentinel: emptyToolResultContent,
+					SkipRoles:    []string{string(MessageRoleTool)},
+				},
+				messagevalidators.LegacyToolNameStripper{},
+				messagevalidators.MinimaxToolCallIDStripper{},
+				messagevalidators.TextPartsFlattener{
+					SkipRoles: []string{string(MessageRoleTool)},
+				},
+			},
+		},
+	}
+}
+
+func openAIRolePolicies() map[string]MessageRolePolicy {
 	policies := []MessageRolePolicy{
 		{Role: MessageRoleDeveloper, DisallowedFields: []string{"tool_calls", "tool_call_id", "function_call"}, ContentRule: MessageContentRequired},
 		{Role: MessageRoleSystem, DisallowedFields: []string{"tool_calls", "tool_call_id", "function_call"}, ContentRule: MessageContentRequired},
@@ -50,53 +116,47 @@ func defaultChatMessageProcessor() ChatMessageProcessor {
 	for _, policy := range policies {
 		byRole[string(policy.Role)] = policy
 	}
-	return ChatMessageProcessor{roles: byRole}
+	return byRole
 }
 
-// NormalizeDocument only fixes shapes we intentionally accept, for example empty tool content or text-part arrays.
-func (p ChatMessageProcessor) NormalizeDocument(document *ChatRequestDocument) error {
+func (p ChatMessageProcessor) resolveRoles(routedModel string) map[string]MessageRolePolicy {
+	overrides := p.modelRoles[routedModel]
+	if len(overrides) == 0 {
+		return p.defaultRoles
+	}
+	merged := make(map[string]MessageRolePolicy, len(p.defaultRoles))
+	for k, v := range p.defaultRoles {
+		merged[k] = v
+	}
+	for k, v := range overrides {
+		merged[k] = v
+	}
+	return merged
+}
+
+func (p ChatMessageProcessor) resolveNormalizers(routedModel string) []MessageNormalizer {
+	if list, ok := p.modelNormalizers[routedModel]; ok {
+		return list
+	}
+	return p.defaultNormalizers
+}
+
+// NormalizeDocument fixes message shapes the gateway intentionally accepts
+// (orphan tool drops, empty tool content sentinels, content-array flattening).
+// The per-route normalizer chain decides what runs.
+func (p ChatMessageProcessor) NormalizeDocument(document *ChatRequestDocument, routedModel string) error {
 	messages, ok := document.Array("messages")
 	if !ok {
 		return nil
 	}
 	changed := false
-	if filtered, dropped := p.dropOrphanToolMessages(messages); dropped {
-		messages = filtered
-		changed = true
-	}
-	if filtered, dropped := p.dropEmptyAssistantTurns(messages); dropped {
-		messages = filtered
-		changed = true
-	}
-	for index, rawMessage := range messages {
-		message, ok := rawMessage.(map[string]any)
-		if !ok {
-			continue
-		}
-		role, _ := message["role"].(string)
-		if p.normalizeMissingContent(message, role) {
-			changed = true
-		}
-		if p.normalizeEmptyContent(message, role) {
-			changed = true
-		}
-		if p.normalizeStripLegacyToolName(message, role) {
-			changed = true
-		}
-		content, exists := message["content"]
-		if !exists || content == nil {
-			continue
-		}
-		parts, ok := content.([]any)
-		if !ok {
-			continue
-		}
-		combined, err := combineTextContentParts(parts, index)
+	for _, n := range p.resolveNormalizers(routedModel) {
+		rewritten, ch, err := n.Apply(messages)
 		if err != nil {
-			return err
+			return wrapBadChatRequest(err)
 		}
-		if combined != "" {
-			message["content"] = combined
+		if ch {
+			messages = rewritten
 			changed = true
 		}
 	}
@@ -106,154 +166,10 @@ func (p ChatMessageProcessor) NormalizeDocument(document *ChatRequestDocument) e
 	return nil
 }
 
-// Drops role:"tool" entries whose tool_call_id has no matching prior assistant.tool_call.
-// Mirrors ValidateDocument's pending-set accounting so survivors pass the strict check.
-func (p ChatMessageProcessor) dropOrphanToolMessages(messages []any) ([]any, bool) {
-	pending := map[string]struct{}{}
-	filtered := make([]any, 0, len(messages))
-	dropped := false
-	for _, raw := range messages {
-		msg, ok := raw.(map[string]any)
-		if !ok {
-			filtered = append(filtered, raw)
-			continue
-		}
-		role, _ := msg["role"].(string)
-		switch role {
-		case string(MessageRoleAssistant):
-			if calls, ok := msg["tool_calls"].([]any); ok {
-				for _, rawCall := range calls {
-					call, ok := rawCall.(map[string]any)
-					if !ok {
-						continue
-					}
-					if id, ok := call["id"].(string); ok && id != "" {
-						pending[id] = struct{}{}
-					}
-				}
-			}
-		case string(MessageRoleTool):
-			if id, ok := msg["tool_call_id"].(string); ok && id != "" {
-				if _, matched := pending[id]; !matched {
-					dropped = true
-					continue
-				}
-				delete(pending, id)
-			}
-		}
-		filtered = append(filtered, raw)
-	}
-	return filtered, dropped
-}
-
-// Drops role:"assistant" messages with no content and no tool_calls/function_call —
-// informationless placeholders left by session-resume serializers.
-func (p ChatMessageProcessor) dropEmptyAssistantTurns(messages []any) ([]any, bool) {
-	filtered := make([]any, 0, len(messages))
-	dropped := false
-	for _, raw := range messages {
-		msg, ok := raw.(map[string]any)
-		if !ok {
-			filtered = append(filtered, raw)
-			continue
-		}
-		if role, _ := msg["role"].(string); role == string(MessageRoleAssistant) && isAssistantTurnEmpty(msg) {
-			dropped = true
-			continue
-		}
-		filtered = append(filtered, raw)
-	}
-	return filtered, dropped
-}
-
-func isAssistantTurnEmpty(msg map[string]any) bool {
-	if raw, exists := msg["tool_calls"]; exists && raw != nil {
-		if calls, ok := raw.([]any); ok && len(calls) > 0 {
-			return false
-		}
-	}
-	if raw, exists := msg["function_call"]; exists && raw != nil {
-		if fc, ok := raw.(map[string]any); ok && len(fc) > 0 {
-			return false
-		}
-	}
-	content, exists := msg["content"]
-	if !exists || content == nil {
-		return true
-	}
-	return isEmptyContent(content)
-}
-
-// Strips legacy `name` from role:"tool" messages (artifact of the old role:"function" API).
-func (p ChatMessageProcessor) normalizeStripLegacyToolName(message map[string]any, role string) bool {
-	if role != string(MessageRoleTool) {
-		return false
-	}
-	if _, exists := message["name"]; !exists {
-		return false
-	}
-	delete(message, "name")
-	return true
-}
-
-func (p ChatMessageProcessor) normalizeMissingContent(message map[string]any, role string) bool {
-	if _, exists := message["content"]; exists {
-		return false
-	}
-	if role == string(MessageRoleTool) {
-		message["content"] = emptyToolResultContent
-		return true
-	}
-	return false
-}
-
-// Empty assistant content (string/array/null) is allowed only when a call payload is present;
-// empty tool content is normalized to a sentinel string.
-func (p ChatMessageProcessor) normalizeEmptyContent(message map[string]any, role string) bool {
-	content, exists := message["content"]
-	if !exists {
-		return false
-	}
-	if content == nil {
-		if role == string(MessageRoleTool) {
-			message["content"] = emptyToolResultContent
-			return true
-		}
-		return false
-	}
-	if !isEmptyContent(content) {
-		return false
-	}
-	switch role {
-	case string(MessageRoleAssistant):
-		if _, hasToolCalls := message["tool_calls"]; hasToolCalls {
-			message["content"] = nil
-			return true
-		}
-		if _, hasFunctionCall := message["function_call"]; hasFunctionCall {
-			message["content"] = nil
-			return true
-		}
-	case string(MessageRoleTool):
-		message["content"] = emptyToolResultContent
-		return true
-	}
-	return false
-}
-
-func isEmptyContent(content any) bool {
-	switch v := content.(type) {
-	case string:
-		return strings.TrimSpace(v) == ""
-	case []any:
-		return len(v) == 0
-	default:
-		return false
-	}
-}
-
-// ValidateDocument enforces the OpenAI-compatible message contract and makes sure tool responses match earlier assistant tool_calls.
-func (p ChatMessageProcessor) ValidateDocument(document *ChatRequestDocument) error {
+// ValidateDocument enforces the per-role policies resolved against the routed
+// model. RequireToolCallID and ContentValidator are honored as policy fields
+// so per-model overrides reuse the same validation skeleton.
+func (p ChatMessageProcessor) ValidateDocument(document *ChatRequestDocument, routedModel string) error {
 	rawMessages, exists := document.Array("messages")
 	if !exists {
 		return badChatRequest("messages is required")
@@ -261,6 +177,7 @@ func (p ChatMessageProcessor) ValidateDocument(document *ChatRequestDocument) er
 	if len(rawMessages) == 0 {
 		return badChatRequest("messages must not be empty")
 	}
+	roles := p.resolveRoles(routedModel)
 
 	pendingToolCalls := map[string]struct{}{}
 	for i, rawMessage := range rawMessages {
@@ -268,257 +185,82 @@ func (p ChatMessageProcessor) ValidateDocument(document *ChatRequestDocument) er
 		if !ok {
 			return badChatRequest("messages[%d] must be an object", i)
 		}
-		role, err := requiredNonEmptyString(message, "role")
+		role, err := messagevalidators.RequiredNonEmptyString(message, "role")
 		if err != nil {
 			return badChatRequest("messages[%d].role: %v", i, err)
 		}
-		policy, ok := p.roles[role]
+		policy, ok := roles[role]
 		if !ok {
 			return badChatRequest("messages[%d].role has unsupported value %q", i, role)
 		}
-		if err := ensureFieldsAbsent(message, policy.DisallowedFields...); err != nil {
+		if err := messagevalidators.EnsureFieldsAbsent(message, policy.DisallowedFields...); err != nil {
 			return badChatRequest("messages[%d]: %v", i, err)
 		}
-
-		switch policy.Role {
-		case MessageRoleDeveloper, MessageRoleSystem, MessageRoleUser:
-			if err := validateRequiredContent(message); err != nil {
-				return badChatRequest("messages[%d].content: %v", i, err)
-			}
-		case MessageRoleAssistant:
-			toolCallIDs, hasToolCalls, err := validateToolCallsField(message, i)
-			if err != nil {
-				return err
-			}
-			hasFunctionCall, err := validateFunctionCallField(message, i)
-			if err != nil {
-				return err
-			}
-			if err := validateAssistantContent(message, hasToolCalls || hasFunctionCall); err != nil {
-				return badChatRequest("messages[%d].content: %v", i, err)
-			}
-			for _, id := range toolCallIDs {
-				pendingToolCalls[id] = struct{}{}
-			}
-		case MessageRoleTool:
-			toolCallID, err := requiredNonEmptyString(message, "tool_call_id")
-			if err != nil {
-				return badChatRequest("messages[%d].tool_call_id: %v", i, err)
-			}
-			if _, ok := pendingToolCalls[toolCallID]; !ok {
-				return badChatRequest("messages[%d].tool_call_id does not match any previous assistant tool_calls", i)
-			}
-			delete(pendingToolCalls, toolCallID)
-			if err := validateRequiredContent(message); err != nil {
-				return badChatRequest("messages[%d].content: %v", i, err)
-			}
-		case MessageRoleFunction:
-			if _, err := requiredNonEmptyString(message, "name"); err != nil {
-				return badChatRequest("messages[%d].name: %v", i, err)
-			}
-			if err := validateRequiredContent(message); err != nil {
-				return badChatRequest("messages[%d].content: %v", i, err)
-			}
+		if err := p.validateRoleSpecific(message, i, policy, pendingToolCalls); err != nil {
+			return err
 		}
 	}
 	return nil
 }
 
-func validateOpenAICompatChatMessages(request map[string]any) error {
-	return defaultMessageProcessor.ValidateDocument(&ChatRequestDocument{raw: request})
-}
-
-func validateToolCallsField(message map[string]any, messageIndex int) ([]string, bool, error) {
-	rawToolCalls, exists := message["tool_calls"]
-	if !exists {
-		return nil, false, nil
-	}
-	// Treat explicit null as absent (some SDKs serialize empty slots that way).
-	if rawToolCalls == nil {
-		delete(message, "tool_calls")
-		return nil, false, nil
-	}
-	toolCalls, ok := rawToolCalls.([]any)
-	if !ok {
-		return nil, true, badChatRequest("messages[%d].tool_calls must be an array", messageIndex)
-	}
-	if len(toolCalls) == 0 {
-		return nil, true, badChatRequest("messages[%d].tool_calls must not be empty", messageIndex)
-	}
-	seen := map[string]struct{}{}
-	ids := make([]string, 0, len(toolCalls))
-	for callIndex, rawCall := range toolCalls {
-		call, ok := rawCall.(map[string]any)
-		if !ok {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d] must be an object", messageIndex, callIndex)
-		}
-		id, err := requiredNonEmptyString(call, "id")
+// validateRoleSpecific keeps ValidateDocument's iteration loop legible: each
+// case reads as a single responsibility.
+func (p ChatMessageProcessor) validateRoleSpecific(message map[string]any, i int, policy MessageRolePolicy, pendingToolCalls map[string]struct{}) error {
+	switch policy.Role {
+	case MessageRoleDeveloper, MessageRoleSystem, MessageRoleUser:
+		if err := messagevalidators.ValidateRequiredContentField(message); err != nil {
+			return badChatRequest("messages[%d].content: %v", i, err)
+		}
+	case MessageRoleAssistant:
+		toolCallIDs, hasToolCalls, err := messagevalidators.ValidateToolCallsField(message)
 		if err != nil {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].id: %v", messageIndex, callIndex, err)
-		}
-		if _, exists := seen[id]; exists {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].id is duplicated", messageIndex, callIndex)
+			return badChatRequest("messages[%d].%v", i, err)
 		}
-		seen[id] = struct{}{}
-		callType, err := requiredNonEmptyString(call, "type")
+		hasFunctionCall, err := messagevalidators.ValidateFunctionCallField(message)
 		if err != nil {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].type: %v", messageIndex, callIndex, err)
+			return badChatRequest("messages[%d].%v", i, err)
 		}
-		if callType != "function" {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].type must be \"function\"", messageIndex, callIndex)
+		if err := messagevalidators.ValidateAssistantContentField(message, hasToolCalls || hasFunctionCall); err != nil {
+			return badChatRequest("messages[%d].content: %v", i, err)
 		}
-		function, ok := call["function"].(map[string]any)
-		if !ok {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].function must be an object", messageIndex, callIndex)
-		}
-		if _, err := requiredNonEmptyString(function, "name"); err != nil {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].function.name: %v", messageIndex, callIndex, err)
-		}
-		if err := optionalStringField(function, "arguments"); err != nil {
-			return nil, true, badChatRequest("messages[%d].tool_calls[%d].function.arguments: %v", messageIndex, callIndex, err)
-		}
-		ids = append(ids, id)
-	}
-	return ids, true, nil
-}
-
-func validateFunctionCallField(message map[string]any, messageIndex int) (bool, error) {
-	rawFunctionCall, exists := message["function_call"]
-	if !exists {
-		return false, nil
-	}
-	if rawFunctionCall == nil {
-		delete(message, "function_call")
-		return false, nil
-	}
-	functionCall, ok := rawFunctionCall.(map[string]any)
-	if !ok {
-		return true, badChatRequest("messages[%d].function_call must be an object", messageIndex)
-	}
-	if _, err := requiredNonEmptyString(functionCall, "name"); err != nil {
-		return true, badChatRequest("messages[%d].function_call.name: %v", messageIndex, err)
-	}
-	if err := optionalStringField(functionCall, "arguments"); err != nil {
-		return true, badChatRequest("messages[%d].function_call.arguments: %v", messageIndex, err)
-	}
-	return true, nil
-}
-
-func validateAssistantContent(message map[string]any, canBeEmpty bool) error {
-	content, exists := message["content"]
-	if !exists || content == nil {
-		if canBeEmpty {
-			return nil
+		for _, id := range toolCallIDs {
+			pendingToolCalls[id] = struct{}{}
 		}
-		return fmt.Errorf("is required unless tool_calls or function_call is provided")
-	}
-	return validateNonEmptyContent(content)
-}
-
-func validateRequiredContent(message map[string]any) error {
-	content, exists := message["content"]
-	if !exists || content == nil {
-		return fmt.Errorf("is required")
-	}
-	return validateNonEmptyContent(content)
-}
-
-func validateNonEmptyContent(content any) error {
-	switch value := content.(type) {
-	case string:
-		if strings.TrimSpace(value) == "" {
-			return fmt.Errorf("must not be empty")
-		}
-		return nil
-	case []any:
-		if len(value) == 0 {
-			return fmt.Errorf("must not be empty")
-		}
-		for i, rawPart := range value {
-			part, ok := rawPart.(map[string]any)
-			if !ok {
-				return fmt.Errorf("[%d] must be an object", i)
-			}
-			text, err := requiredTextContentPart(part, i)
+	case MessageRoleTool:
+		if policy.RequireToolCallID {
+			toolCallID, err := messagevalidators.RequiredNonEmptyString(message, "tool_call_id")
 			if err != nil {
-				return err
+				return badChatRequest("messages[%d].tool_call_id: %v", i, err)
 			}
-			if strings.TrimSpace(text) == "" {
-				return fmt.Errorf("[%d].text must not be empty", i)
+			if _, ok := pendingToolCalls[toolCallID]; !ok {
+				return badChatRequest("messages[%d].tool_call_id does not match any previous assistant tool_calls", i)
 			}
+			delete(pendingToolCalls, toolCallID)
 		}
-		return nil
-	default:
-		return fmt.Errorf("must be a string or an array of typed content parts")
-	}
-}
-
-// We only accept text parts here because the gateway normalizes typed text content into a plain string before forwarding.
-func requiredTextContentPart(part map[string]any, partIndex int) (string, error) {
-	partType, err := requiredNonEmptyString(part, "type")
-	if err != nil {
-		return "", fmt.Errorf("[%d].type: %w", partIndex, err)
-	}
-	if partType != "text" {
-		return "", fmt.Errorf("[%d].type has unsupported value %q", partIndex, partType)
-	}
-	text, err := requiredNonEmptyString(part, "text")
-	if err != nil {
-		return "", fmt.Errorf("[%d].text: %w", partIndex, err)
-	}
-	return text, nil
-}
-
-func combineTextContentParts(parts []any, messageIndex int) (string, error) {
-	texts := make([]string, 0, len(parts))
-	for partIndex, rawPart := range parts {
-		part, ok := rawPart.(map[string]any)
-		if !ok {
-			return "", badChatRequest("messages[%d].content[%d] must be an object", messageIndex, partIndex)
+		if policy.ContentValidator != nil {
+			content, exists := message["content"]
+			if !exists {
+				return badChatRequest("messages[%d].content: is required", i)
+			}
+			if err := policy.ContentValidator.Validate(content); err != nil {
+				return badChatRequest("messages[%d].%v", i, err)
+			}
+		} else if err := messagevalidators.ValidateRequiredContentField(message); err != nil {
+			return badChatRequest("messages[%d].content: %v", i, err)
 		}
-		text, err := requiredTextContentPart(part, partIndex)
-		if err != nil {
-			return "", badChatRequest("messages[%d].content%v", messageIndex, err)
+	case MessageRoleFunction:
+		if policy.RequireName {
+			if _, err := messagevalidators.RequiredNonEmptyString(message, "name"); err != nil {
+				return badChatRequest("messages[%d].name: %v", i, err)
+			}
 		}
-		texts = append(texts, text)
-	}
-	if len(texts) == 0 {
-		return "", nil
-	}
-	return strings.Join(texts, "\n"), nil
-}
-
-func ensureFieldsAbsent(values map[string]any, fields ...string) error {
-	for _, field := range fields {
-		if _, exists := values[field]; exists {
-			return fmt.Errorf("%s is not allowed for this role", field)
+		if err := messagevalidators.ValidateRequiredContentField(message); err != nil {
+			return badChatRequest("messages[%d].content: %v", i, err)
 		}
 	}
 	return nil
 }
 
-func requiredNonEmptyString(values map[string]any, field string) (string, error) {
-	rawValue, exists := values[field]
-	if !exists || rawValue == nil {
-		return "", fmt.Errorf("is required")
-	}
-	value, ok := rawValue.(string)
-	if !ok {
-		return "", fmt.Errorf("must be a string")
-	}
-	if strings.TrimSpace(value) == "" {
-		return "", fmt.Errorf("must not be empty")
-	}
-	return value, nil
-}
-
-func optionalStringField(values map[string]any, field string) error {
-	rawValue, exists := values[field]
-	if !exists || rawValue == nil {
-		return nil
-	}
-	if _, ok := rawValue.(string); !ok {
-		return fmt.Errorf("must be a string")
-	}
-	return nil
+func validateOpenAICompatChatMessages(request map[string]any) error {
+	return defaultMessageProcessor.ValidateDocument(&ChatRequestDocument{raw: request}, "")
 }
diff --git a/devshard/cmd/devshardctl/request_filters_parameters.go b/devshard/cmd/devshardctl/request_filters_parameters.go
index 88df1f26d1..49390c33e9 100644
--- a/devshard/cmd/devshardctl/request_filters_parameters.go
+++ b/devshard/cmd/devshardctl/request_filters_parameters.go
@@ -3,13 +3,12 @@ package main
 import (
 	"bytes"
 	"encoding/json"
-	"math"
 	"slices"
-	"strconv"
 	"strings"
 	"sync"
 
 	"devshard"
+	"devshard/cmd/devshardctl/filtercore"
 	"devshard/cmd/devshardctl/paramvalidators"
 )
 
@@ -41,137 +40,28 @@ type ParameterHandler interface {
 	Apply(*RequestFilterContext, VLLMParameter) error
 }
 
-type StripParameterHandler struct{}
-
-func (StripParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	ctx.Document.Delete(parameter.Name)
-	return nil
-}
-
-type ConditionalStripParameterHandler struct {
-	Predicate func(*RequestFilterContext) bool
-}
-
-func (h ConditionalStripParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	if h.Predicate != nil && h.Predicate(ctx) {
-		ctx.Document.Delete(parameter.Name)
-	}
-	return nil
-}
-
-type SanitizeStringListParameterHandler struct {
-	Keep             func(string) bool
-	DropFieldIfEmpty bool
+// ParameterHandlerAdapter wraps a paramvalidators.ParameterHandler (which operates on a
+// raw map[string]any) so the catalog can drive it through the standard ParameterHandler
+// contract. Mirrors DocumentValidatorHandler's role for DocumentValidator.
+type ParameterHandlerAdapter struct {
+	Handler paramvalidators.ParameterHandler
 }
 
-func (h SanitizeStringListParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	raw, ok := ctx.Document.Array(parameter.Name)
-	if !ok {
-		return nil
-	}
-	cleaned := raw[:0]
-	for _, item := range raw {
-		value, ok := item.(string)
-		if !ok {
-			cleaned = append(cleaned, item)
-			continue
-		}
-		if h.Keep == nil || h.Keep(value) {
-			cleaned = append(cleaned, value)
-		}
-	}
-	if len(cleaned) == 0 && h.DropFieldIfEmpty {
-		ctx.Document.Delete(parameter.Name)
+func (h ParameterHandlerAdapter) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
+	if h.Handler == nil {
 		return nil
 	}
-	ctx.Document.Set(parameter.Name, cleaned)
-	return nil
-}
-
-// SanitizeFloatParameterHandler normalizes numeric knobs from either JSON numbers or string-encoded numbers.
-type SanitizeFloatParameterHandler struct {
-	StripNonFinite bool
-	Min            *float64
-	Max            *float64
-}
-
-func (h SanitizeFloatParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	value, ok := ctx.Document.Get(parameter.Name)
-	if !ok {
-		return nil
-	}
-	number, ok := numericJSONValueAsFloat64(value)
-	if !ok {
-		ctx.Document.Delete(parameter.Name)
-		return nil
-	}
-	if h.StripNonFinite && (math.IsNaN(number) || math.IsInf(number, 0)) {
-		ctx.Document.Delete(parameter.Name)
-		return nil
-	}
-	if h.Min != nil && number < *h.Min {
-		number = *h.Min
-	}
-	if h.Max != nil && number > *h.Max {
-		number = *h.Max
-	}
-	ctx.Document.Set(parameter.Name, number)
-	return nil
-}
-
-type SanitizeFloatMapParameterHandler struct {
-	StripNonFinite   bool
-	Min              *float64
-	Max              *float64
-	DropFieldIfEmpty bool
-	MaxEntries       int
-}
-
-func (h SanitizeFloatMapParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	raw, ok := ctx.Document.Object(parameter.Name)
-	if !ok {
-		return nil
-	}
-	if h.MaxEntries > 0 && len(raw) > h.MaxEntries {
-		return badChatRequest("%s: map size %d exceeds limit %d", parameter.Name, len(raw), h.MaxEntries)
-	}
-	for key, value := range raw {
-		number, ok := numericJSONValueAsFloat64(value)
-		if !ok {
-			continue
-		}
-		if h.StripNonFinite && (math.IsNaN(number) || math.IsInf(number, 0)) {
-			delete(raw, key)
-			continue
-		}
-		if h.Min != nil && number < *h.Min {
-			delete(raw, key)
-			continue
-		}
-		if h.Max != nil && number > *h.Max {
-			delete(raw, key)
-		}
-	}
-	if len(raw) == 0 && h.DropFieldIfEmpty {
-		ctx.Document.Delete(parameter.Name)
-		return nil
-	}
-	ctx.Document.Set(parameter.Name, raw)
-	return nil
-}
-
-type ForceLiteralParameterHandler struct {
-	Value any
-	OverwriteOnly bool
-}
-
-func (h ForceLiteralParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	if h.OverwriteOnly {
-		if _, exists := ctx.Document.Get(parameter.Name); !exists {
-			return nil
-		}
+	var handlerErr error
+	ctx.Document.LockedScope(func(raw map[string]any) {
+		handlerErr = h.Handler.HandleParameter(paramvalidators.ParameterContext{
+			Document:    raw,
+			Parameter:   parameter.Name,
+			RoutedModel: ctx.RoutedModel,
+		})
+	})
+	if handlerErr != nil {
+		return wrapBadChatRequest(handlerErr)
 	}
-	ctx.Document.Set(parameter.Name, h.Value)
 	return nil
 }
 
@@ -185,13 +75,11 @@ type ModelScopedParameterHandler struct {
 }
 
 func (h ModelScopedParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	for _, m := range h.Models {
-		if m == ctx.RoutedModel {
-			if h.Handler == nil {
-				return nil
-			}
-			return h.Handler.Apply(ctx, parameter)
+	if filtercore.MatchesModel(ctx.RoutedModel, h.Models) {
+		if h.Handler == nil {
+			return nil
 		}
+		return h.Handler.Apply(ctx, parameter)
 	}
 	if h.UnmatchedHandler == nil {
 		return nil
@@ -199,107 +87,6 @@ func (h ModelScopedParameterHandler) Apply(ctx *RequestFilterContext, parameter
 	return h.UnmatchedHandler.Apply(ctx, parameter)
 }
 
-type CapUintParameterHandler struct {
-	Max uint64
-}
-
-func (h CapUintParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	value, ok := numericJSONValueAsUint64FromDocument(&ctx.Document, parameter.Name)
-	if !ok {
-		return nil
-	}
-	if value > h.Max {
-		ctx.Document.Set(parameter.Name, h.Max)
-	}
-	return nil
-}
-
-type ClampUintToFieldParameterHandler struct {
-	MaxField string
-}
-
-func (h ClampUintToFieldParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	value, ok := numericJSONValueAsUint64FromDocument(&ctx.Document, parameter.Name)
-	if !ok {
-		return nil
-	}
-	maxValue, ok := numericJSONValueAsUint64FromDocument(&ctx.Document, h.MaxField)
-	if !ok || maxValue == 0 {
-		return nil
-	}
-	if value > maxValue {
-		ctx.Document.Set(parameter.Name, maxValue)
-	}
-	return nil
-}
-
-// MinUintParameterHandler clamps a uint parameter UP to Min when the value is present
-// and below the floor. Pass-through when the field is absent or already >= Min.
-type MinUintParameterHandler struct {
-	Min uint64
-}
-
-func (h MinUintParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	value, ok := numericJSONValueAsUint64FromDocument(&ctx.Document, parameter.Name)
-	if !ok {
-		return nil
-	}
-	if value < h.Min {
-		ctx.Document.Set(parameter.Name, h.Min)
-	}
-	return nil
-}
-
-// ValidateUintParameterHandler rejects the request if the field is present but its value
-// cannot be parsed as a non-negative integer that fits in uint64. Pass-through when the
-// field is absent. Used for fields like `seed` where vLLM expects a uint64 and we want to
-// catch garbage types at the gateway boundary rather than relying on the upstream's error
-// path.
-type ValidateUintParameterHandler struct{}
-
-func (h ValidateUintParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	raw, exists := ctx.Document.Get(parameter.Name)
-	if !exists || raw == nil {
-		return nil
-	}
-	if _, ok := devshard.JSONNumericUint64(raw); !ok {
-		return badChatRequest("%s: must be a non-negative integer", parameter.Name)
-	}
-	return nil
-}
-
-// LengthCapListParameterHandler bounds the number of entries in a JSON array, and
-// optionally the byte length of each string entry. Used for fields like `stop`,
-// `stop_token_ids`, and `bad_words` -- vLLM scans every entry against every generated
-// token, so unbounded arrays linearly slow inference. MaxEntries=0 disables the array cap,
-// MaxEntryLen=0 disables the per-string cap (use 0 for int-only arrays).
-type LengthCapListParameterHandler struct {
-	MaxEntries  int
-	MaxEntryLen int
-}
-
-func (h LengthCapListParameterHandler) Apply(ctx *RequestFilterContext, parameter VLLMParameter) error {
-	raw, ok := ctx.Document.Array(parameter.Name)
-	if !ok {
-		return nil
-	}
-	if h.MaxEntries > 0 && len(raw) > h.MaxEntries {
-		return badChatRequest("%s: array length %d exceeds limit %d", parameter.Name, len(raw), h.MaxEntries)
-	}
-	if h.MaxEntryLen > 0 {
-		for i, item := range raw {
-			s, ok := item.(string)
-			if !ok {
-				continue
-			}
-			if len(s) > h.MaxEntryLen {
-				return badChatRequest("%s[%d]: string length %d exceeds limit %d", parameter.Name, i, len(s), h.MaxEntryLen)
-			}
-		}
-	}
-	return nil
-}
-
 // DocumentValidator: validators in paramvalidators expose this contract. May mutate
 // vctx.Document for per-model rewrites alongside shape checks.
 type DocumentValidator interface {
@@ -532,21 +319,14 @@ func (ctx *RequestFilterContext) DecodeRequest() error {
 	return nil
 }
 
-// SyncRequestView refreshes ctx.Request after PostLimits rules ran. Why we explicitly
-// preserve the token fields instead of re-reading them from the document:
-//
-//   - When the client sends only `max_completion_tokens` (no `max_tokens`),
-//     `applyOutputTokenLimits` sets `ctx.Request.MaxTokens` from the resolved
-//     `max_completion_tokens` (see request_filters.go:139) but does NOT write a
-//     corresponding `max_tokens` key into the document. Re-reading the document would
-//     therefore reset `req.MaxTokens` to 0.
-//   - In the other three branches of `applyOutputTokenLimits`, the document DOES carry
-//     the same value, so preserving from `ctx.Request` is a no-op. Net effect: this
-//     branch only matters for the max-completion-only path, locked in by
-//     TestNormalizeChatRequestDefaultsAndCapsOutputTokens.
+// SyncRequestView refreshes ctx.Request after PostLimits rules ran. The token fields
+// are preserved from ctx.Request rather than re-read because applyOutputTokenLimits is
+// their source of truth; all four of its branches now write the same max_tokens /
+// max_completion_tokens into the document (the max-completion-only branch mirrors into
+// max_tokens too), so this preservation is a harmless no-op safety net.
 //
 // Other fields are re-read so caps applied by PostLimits rules (for example `n` via
-// CapUintParameterHandler) propagate into the projection.
+// paramvalidators.CapUintParameter through the adapter) propagate into the projection.
 func (ctx *RequestFilterContext) SyncRequestView() error {
 	var req chatRequest
 	if err := readChatRequestFields(&ctx.Document, &req); err != nil {
@@ -605,29 +385,52 @@ type VLLMParameterCatalog struct {
 
 var defaultParameterCatalog = defaultVLLMParameterCatalog()
 
+// Shared stateless parameter handlers reused across catalog entries. The rejectNumber gates
+// enforce exclusive-lower-bound ranges (clamping to the bound would itself be an illegal
+// value, so reject instead); the mustBe*/elementsMustBe* validators reject wrong-typed
+// scalars and array elements at the gateway boundary rather than forwarding them for an
+// opaque upstream 400.
+var (
+	rejectNonPositiveNumber = ParameterHandlerAdapter{Handler: paramvalidators.RejectNumberParameter{
+		Allow:   func(value float64) bool { return value > 0 },
+		Message: "must be greater than 0",
+	}}
+	rejectInvalidTopK = ParameterHandlerAdapter{Handler: paramvalidators.RejectNumberParameter{
+		Allow:   func(value float64) bool { return value == -1 || value >= 1 },
+		Message: "must be -1 or a positive integer",
+	}}
+	mustBeBool           = ParameterHandlerAdapter{Handler: paramvalidators.ValidateScalarParameter{Valid: paramvalidators.IsJSONBool, Message: "must be a boolean"}}
+	mustBeUint           = ParameterHandlerAdapter{Handler: paramvalidators.ValidateUintParameter{}}
+	elementsMustBeUint   = ParameterHandlerAdapter{Handler: paramvalidators.ValidateListElementsParameter{Valid: paramvalidators.IsJSONUint, Message: "must be an integer token id"}}
+	elementsMustBeString = ParameterHandlerAdapter{Handler: paramvalidators.ValidateListElementsParameter{Valid: paramvalidators.IsJSONString, Message: "must be a string"}}
+)
+
 // The catalog is the single source of truth for how each supported OpenAI/vLLM field is treated.
 func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 	parameters := slices.Concat(
 		[]VLLMParameter{
 			newParameter("messages").
-				withRule(RequestFilterStagePreValidation, LengthCapListParameterHandler{MaxEntries: MessagesMaxEntries}),
+				withRule(RequestFilterStagePreValidation, ParameterHandlerAdapter{Handler: paramvalidators.LengthCapListParameter{MaxEntries: MessagesMaxEntries}}),
 			newParameter("seed").
-				withRule(RequestFilterStagePreValidation, ValidateUintParameterHandler{}),
+				withRule(RequestFilterStagePreValidation, mustBeUint),
 			newParameter("n").
-				withRule(RequestFilterStagePostLimits, CapUintParameterHandler{Max: MaxChatRequestChoices}).
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.CapUintParameter{Min: 1, Max: MaxChatRequestChoices}}).
 				withRule(RequestFilterStagePostLimits, DocumentValidatorHandler{
 					Validator: paramvalidators.GreedySamplingValidator{},
 				}),
 			newParameter("temperature").
-				withRule(RequestFilterStagePostLimits, SanitizeFloatParameterHandler{StripNonFinite: true, Max: floatPointer(MaxTemperature)}),
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatParameter{StripNonFinite: true, Min: floatPointer(MinTemperature), Max: floatPointer(MaxTemperature)}}),
 			newParameter("repetition_penalty").
-				withRule(RequestFilterStagePostLimits, SanitizeFloatParameterHandler{StripNonFinite: true, Max: floatPointer(MaxRepetitionPenalty)}),
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatParameter{StripNonFinite: true, Max: floatPointer(MaxRepetitionPenalty)}}).
+				withRule(RequestFilterStagePostLimits, rejectNonPositiveNumber),
 			newParameter("logit_bias").
-				withRule(RequestFilterStagePostLimits, SanitizeFloatMapParameterHandler{StripNonFinite: true, Min: floatPointer(LogitBiasMinValue), Max: floatPointer(LogitBiasMaxValue), DropFieldIfEmpty: true, MaxEntries: LogitBiasMaxEntries}),
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatMapParameter{StripNonFinite: true, Min: floatPointer(LogitBiasMinValue), Max: floatPointer(LogitBiasMaxValue), DropFieldIfEmpty: true, MaxEntries: LogitBiasMaxEntries}}),
 			newParameter("stop").
-				withRule(RequestFilterStagePreValidation, LengthCapListParameterHandler{MaxEntries: StopMaxEntries, MaxEntryLen: StopMaxEntryLen}),
+				withRule(RequestFilterStagePreValidation, elementsMustBeString).
+				withRule(RequestFilterStagePreValidation, ParameterHandlerAdapter{Handler: paramvalidators.LengthCapListParameter{MaxEntries: StopMaxEntries, MaxEntryLen: StopMaxEntryLen}}),
 			newParameter("stop_token_ids").
-				withRule(RequestFilterStagePreValidation, LengthCapListParameterHandler{MaxEntries: StopTokenIdsMaxEntries}),
+				withRule(RequestFilterStagePreValidation, ParameterHandlerAdapter{Handler: paramvalidators.LengthCapListParameter{MaxEntries: StopTokenIdsMaxEntries}}).
+				withRule(RequestFilterStagePreValidation, elementsMustBeUint),
 			newParameter("reasoning").
 				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
 					Validator: paramvalidators.ReasoningValidator{},
@@ -641,13 +444,26 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 				}).
 				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
 					Models:           nil,
-					UnmatchedHandler: StripParameterHandler{},
+					UnmatchedHandler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}},
 				}),
+			// MiniMax-M2.7 has no chat_template knob for enable_thinking (vLLM #36778);
+			// strip on this route before EnableThinkingValidator runs.
 			newParameter("enable_thinking").
+				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
+					Models:  []string{miniMaxM27ModelID},
+					Handler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}},
+				}).
 				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
 					Validator: paramvalidators.EnableThinkingValidator{},
 				}),
+			// thinking: Kimi mirrors to chat_template_kwargs.thinking; MiniMax-M2.7 has no
+			// equivalent knob (interleaved thinking is structural to the chat template) so
+			// strip the field before ThinkingValidator runs. Other routes normalize+keep.
 			newParameter("thinking").
+				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
+					Models:  []string{miniMaxM27ModelID},
+					Handler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}},
+				}).
 				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
 					Validator: paramvalidators.ThinkingValidator{
 						MirrorToTemplateKwargsForModels: []string{kimiK26ModelID},
@@ -664,18 +480,17 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 			newParameter("thinking_token_budget").
 				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
 					Models:           []string{kimiK26ModelID},
-					UnmatchedHandler: StripParameterHandler{},
+					UnmatchedHandler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}},
 				}).
-				withRule(RequestFilterStagePostLimits, ModelScopedParameterHandler{
-					Models: []string{kimiK26ModelID},
-					Handler: DocumentValidatorHandler{
-						Validator: paramvalidators.ThinkingTokenBudgetDefaultsValidator{
-							DefaultDivisor: kimiThinkingTokenBudgetDefaultDivisor,
-						},
+				withRule(RequestFilterStagePostLimits, DocumentValidatorHandler{
+					Validator: paramvalidators.KimiThinkingTokenBudgetValidator{
+						Model:                   kimiK26ModelID,
+						DefaultDivisor:          kimiThinkingTokenBudgetDefaultDivisor,
+						AbsoluteMax:             kimiThinkingTokenBudgetMax,
+						ContentHeadroom:         kimiContentHeadroomMin,
+						ForceZeroBelowMaxTokens: kimiSmallMaxTokensForceNoThinking,
 					},
-				}).
-				withRule(RequestFilterStagePostLimits, CapUintParameterHandler{Max: kimiThinkingTokenBudgetMax}).
-				withRule(RequestFilterStagePostLimits, ClampUintToFieldParameterHandler{MaxField: "max_tokens"}),
+				}),
 			newParameter("tools").
 				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
 					Validator: paramvalidators.ToolsValidator{
@@ -693,20 +508,23 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 					Validator: paramvalidators.ToolChoiceValidator{MaxNameLen: ToolChoiceMaxNameLen},
 				}),
 			newParameter("min_tokens").
-				withRule(RequestFilterStagePreValidation, ConditionalStripParameterHandler{
-					Predicate: func(ctx *RequestFilterContext) bool {
-						return ctx.Document.Has("stop_token_ids")
+				withRule(RequestFilterStagePreValidation, mustBeUint).
+				withRule(RequestFilterStagePreValidation, ParameterHandlerAdapter{Handler: paramvalidators.ConditionalStripParameter{
+					Predicate: func(ctx paramvalidators.ParameterContext) bool {
+						_, ok := ctx.Document["stop_token_ids"]
+						return ok
 					},
-				}).
-				withRule(RequestFilterStagePostLimits, ClampUintToFieldParameterHandler{MaxField: "max_tokens"}),
+				}}).
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.ClampUintToFieldParameter{MaxField: "max_tokens"}}),
 			newParameter("bad_words").
-				withRule(RequestFilterStagePreValidation, SanitizeStringListParameterHandler{
+				withRule(RequestFilterStagePreValidation, elementsMustBeString).
+				withRule(RequestFilterStagePreValidation, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeStringListParameter{
 					Keep: func(value string) bool {
 						return strings.TrimSpace(value) != ""
 					},
 					DropFieldIfEmpty: true,
-				}).
-				withRule(RequestFilterStagePreValidation, LengthCapListParameterHandler{MaxEntries: BadWordsMaxEntries, MaxEntryLen: BadWordsMaxEntryLen}),
+				}}).
+				withRule(RequestFilterStagePreValidation, ParameterHandlerAdapter{Handler: paramvalidators.LengthCapListParameter{MaxEntries: BadWordsMaxEntries, MaxEntryLen: BadWordsMaxEntryLen}}),
 			// OpenAI Chat Completions standard observability fields. No inference-side
 			// semantics on the vLLM upstream; clients send them for end-user tracking,
 			// distributed tracing, agent control, and streaming token accounting.
@@ -736,11 +554,11 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 					Validator: paramvalidators.StreamOptionsValidator{},
 				}),
 			newParameter("return_token_ids").
-				withRule(RequestFilterStagePostLimits, ForceLiteralParameterHandler{Value: true}),
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.ForceLiteralParameter{Value: true}}),
 			newParameter("logprobs").
-				withRule(RequestFilterStagePostLimits, ForceLiteralParameterHandler{Value: true}),
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.ForceLiteralParameter{Value: true}}),
 			newParameter("top_logprobs").
-				withRule(RequestFilterStagePostLimits, ForceLiteralParameterHandler{Value: TopLogprobsForcedValue}),
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.ForceLiteralParameter{Value: TopLogprobsForcedValue}}),
 			newParameter("response_format").
 				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
 					Validator: paramvalidators.ResponseFormatValidator{
@@ -756,18 +574,18 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 			newParameter("structured_outputs").
 				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
 					Validator: paramvalidators.StructuredOutputsValidator{
-						RejectedModels:       []string{kimiK26ModelID},
-						MaxDepth:             StructuredOutputsMaxDepth,
-						MaxSize:              StructuredOutputsMaxSize,
-						MaxNodes:             StructuredOutputsMaxNodes,
-						MaxBranch:            StructuredOutputsMaxBranch,
-						MaxEnum:              StructuredOutputsMaxEnum,
-						MaxPatternLen:        StructuredOutputsMaxPatternLen,
-						MaxChoiceEntries:     StructuredOutputsMaxChoiceEntries,
-						MaxChoiceEntryLen:    StructuredOutputsMaxChoiceEntryLen,
-						MaxGrammarLen:        StructuredOutputsMaxGrammarLen,
-						MaxGrammarNesting:    StructuredOutputsMaxGrammarNesting,
-						MaxStructuralTagLen:  StructuredOutputsMaxStructuralTagLen,
+						RejectedModels:      []string{kimiK26ModelID},
+						MaxDepth:            StructuredOutputsMaxDepth,
+						MaxSize:             StructuredOutputsMaxSize,
+						MaxNodes:            StructuredOutputsMaxNodes,
+						MaxBranch:           StructuredOutputsMaxBranch,
+						MaxEnum:             StructuredOutputsMaxEnum,
+						MaxPatternLen:       StructuredOutputsMaxPatternLen,
+						MaxChoiceEntries:    StructuredOutputsMaxChoiceEntries,
+						MaxChoiceEntryLen:   StructuredOutputsMaxChoiceEntryLen,
+						MaxGrammarLen:       StructuredOutputsMaxGrammarLen,
+						MaxGrammarNesting:   StructuredOutputsMaxGrammarNesting,
+						MaxStructuralTagLen: StructuredOutputsMaxStructuralTagLen,
 					},
 				}),
 			newParameter("safety_identifier").
@@ -779,38 +597,60 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 							DefaultMaxLen: SafetyIdentifierMaxLen,
 						},
 					},
-					UnmatchedHandler: StripParameterHandler{},
+					UnmatchedHandler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}},
 				}),
-		},
-		[]VLLMParameter{
-			// PreValidation so the floor lands before applyOutputTokenLimits (caps down) and the
-			// thinking_token_budget defaulter (derives ttb from max_tokens).
+			// MiniMax-M2.7 native extension lifted from extra_body. On the MiniMax
+			// route the field passes through to vLLM verbatim (controls whether
+			// reasoning is emitted as inline <think>...</think> in content or as a
+			// separate reasoning_details[] array). Stripped on other routes since
+			// Kimi/Qwen vLLM serves don't know the field. See docs/chat-api/minimax-m2.7.md.
+			newParameter("reasoning_split").
+				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
+					Models:           []string{miniMaxM27ModelID},
+					UnmatchedHandler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}},
+				}),
+			// PreValidation so the floor lands before applyOutputTokenLimits caps down.
+			// One validator covers both max_tokens and max_completion_tokens.
 			newParameter("max_tokens").
+				withRule(RequestFilterStagePreValidation, DocumentValidatorHandler{
+					Validator: paramvalidators.KimiMaxTokensFloorValidator{
+						Model: kimiK26ModelID,
+						Min:   kimiMaxTokensMin,
+					},
+				}).
 				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
-					Models:  []string{kimiK26ModelID},
-					Handler: MinUintParameterHandler{Min: kimiMaxTokensMin},
+					Models:           []string{kimiK26ModelID},
+					UnmatchedHandler: rejectNonPositiveNumber,
 				}),
 			newParameter("max_completion_tokens").
 				withRule(RequestFilterStagePreValidation, ModelScopedParameterHandler{
-					Models:  []string{kimiK26ModelID},
-					Handler: MinUintParameterHandler{Min: kimiMaxTokensMin},
+					Models:           []string{kimiK26ModelID},
+					UnmatchedHandler: rejectNonPositiveNumber,
 				}),
+			// Sampling knobs with per-field ranges: min_p clamps into [0, 1]; top_p clamps
+			// down to 1 but rejects a non-positive value (exclusive lower bound); top_k
+			// accepts -1 (disabled) or any integer >= 1.
+			newParameter("min_p").
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatParameter{StripNonFinite: true, Min: floatPointer(MinPMin), Max: floatPointer(MinPMax)}}),
+			newParameter("top_p").
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatParameter{StripNonFinite: true, Max: floatPointer(TopPMax)}}).
+				withRule(RequestFilterStagePostLimits, rejectNonPositiveNumber),
+			newParameter("top_k").
+				withRule(RequestFilterStagePostLimits, ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatParameter{StripNonFinite: true}}).
+				withRule(RequestFilterStagePostLimits, rejectInvalidTopK),
 		},
+		// model and stream are type-checked during the typed parse (string / bool); register
+		// them as known so the whitelist keeps them.
 		newParameters([]string{
 			"model",
 			"stream",
-			"skip_special_tokens",
-			"detokenize",
-			"parallel_tool_calls",
 		}),
-		newParameters([]string{"top_p", "top_k", "min_p"},
-			ParameterRule{
-				Stage:   RequestFilterStagePostLimits,
-				Handler: SanitizeFloatParameterHandler{StripNonFinite: true},
-			},
+		// The remaining boolean flags are pass-through fields, so validate their type here.
+		newParameters([]string{"skip_special_tokens", "detokenize", "parallel_tool_calls"},
+			ParameterRule{Stage: RequestFilterStagePreValidation, Handler: mustBeBool},
 		),
 		newParameters([]string{"service_tier", "store", "provider", "plugins", "prompt_cache_key", "cache_key", "extra_headers", "thinking_config", "think"},
-			ParameterRule{Stage: RequestFilterStagePreValidation, Handler: StripParameterHandler{}},
+			ParameterRule{Stage: RequestFilterStagePreValidation, Handler: ParameterHandlerAdapter{Handler: paramvalidators.StripParameter{}}},
 		),
 		// frequency_penalty / presence_penalty share identical rules: catalog clamp
 		// [-2, 2] for all models + per-Kimi force-rewrite to 0.0 (Moonshot's K2.6 wire
@@ -818,13 +658,13 @@ func defaultVLLMParameterCatalog() VLLMParameterCatalog {
 		newParameters([]string{"frequency_penalty", "presence_penalty"},
 			ParameterRule{
 				Stage:   RequestFilterStagePostLimits,
-				Handler: SanitizeFloatParameterHandler{StripNonFinite: true, Min: floatPointer(PenaltyMin), Max: floatPointer(PenaltyMax)},
+				Handler: ParameterHandlerAdapter{Handler: paramvalidators.SanitizeFloatParameter{StripNonFinite: true, Min: floatPointer(PenaltyMin), Max: floatPointer(PenaltyMax)}},
 			},
 			ParameterRule{
 				Stage: RequestFilterStagePostLimits,
 				Handler: ModelScopedParameterHandler{
 					Models:  []string{kimiK26ModelID},
-					Handler: ForceLiteralParameterHandler{Value: KimiK2PenaltyForcedValue, OverwriteOnly: true},
+					Handler: ParameterHandlerAdapter{Handler: paramvalidators.ForceLiteralParameter{Value: KimiK2PenaltyForcedValue, OverwriteOnly: true}},
 				},
 			},
 		),
@@ -930,32 +770,3 @@ func newParameters(names []string, rules ...ParameterRule) []VLLMParameter {
 func floatPointer(value float64) *float64 {
 	return &value
 }
-
-func numericJSONValueAsFloat64(value any) (float64, bool) {
-	switch v := value.(type) {
-	case float64:
-		return v, true
-	case int:
-		return float64(v), true
-	case int64:
-		return float64(v), true
-	case uint64:
-		return float64(v), true
-	case json.Number:
-		number, err := v.Float64()
-		return number, err == nil
-	case string:
-		number, err := strconv.ParseFloat(strings.TrimSpace(v), 64)
-		return number, err == nil
-	default:
-		return 0, false
-	}
-}
-
-func numericJSONValueAsUint64FromDocument(document *ChatRequestDocument, field string) (uint64, bool) {
-	value, ok := document.Get(field)
-	if !ok {
-		return 0, false
-	}
-	return devshard.JSONNumericUint64(value)
-}
diff --git a/devshard/cmd/devshardctl/request_filters_test.go b/devshard/cmd/devshardctl/request_filters_test.go
index 6c0cbb1d46..96e3a4c7d8 100644
--- a/devshard/cmd/devshardctl/request_filters_test.go
+++ b/devshard/cmd/devshardctl/request_filters_test.go
@@ -46,7 +46,7 @@ func TestNormalizeChatRequestDefaultsAndCapsOutputTokens(t *testing.T) {
 	require.NoError(t, err)
 	require.EqualValues(t, 64, req.MaxTokens)
 	require.EqualValues(t, 64, req.MaxCompletionTokens)
-	require.NotContains(t, string(body), `"max_tokens"`)
+	require.Contains(t, string(body), `"max_tokens":64`)
 	require.Contains(t, string(body), `"max_completion_tokens":64`)
 
 	body, req, err = normalizeChatRequest([]byte(`{"max_tokens":10001,"max_completion_tokens":20000,"messages":[{"role":"user","content":"hello"}]}`))
@@ -126,7 +126,7 @@ func TestPrepareChatRequestBodyAdminAuthKeepsMaxCompletionTokensAboveDefault(t *
 	require.NoError(t, err)
 	require.EqualValues(t, 30_000, chatReq.MaxTokens)
 	require.EqualValues(t, 30_000, chatReq.MaxCompletionTokens)
-	require.NotContains(t, string(body), `"max_tokens"`)
+	require.Contains(t, string(body), `"max_tokens":30000`)
 	require.Contains(t, string(body), `"max_completion_tokens":30000`)
 }
 
@@ -203,6 +203,13 @@ func TestNormalizeChatRequestCapsChoices(t *testing.T) {
 	require.NotContains(t, string(body), `"n"`)
 }
 
+func TestNormalizeChatRequestClampsZeroChoicesToOne(t *testing.T) {
+	body, req, err := normalizeChatRequest([]byte(`{"n":0,"messages":[{"role":"user","content":"hi"}]}`))
+	require.NoError(t, err)
+	require.EqualValues(t, 1, req.N)
+	require.Contains(t, string(body), `"n":1`)
+}
+
 func TestNormalizeChatRequestClampsMinTokensAboveEffectiveMax(t *testing.T) {
 	oldDefault := DefaultRequestMaxTokens
 	oldCap := RequestMaxTokensCap
@@ -275,6 +282,141 @@ func TestNormalizeChatRequestKeepsTemperatureWithinMax(t *testing.T) {
 	require.EqualValues(t, 1.5, raw["temperature"])
 }
 
+func TestNormalizeChatRequestClampsTemperatureBelowMin(t *testing.T) {
+	body, _, err := normalizeChatRequest([]byte(`{
+		"messages": [{"role": "user", "content": "hi"}],
+		"temperature": -1
+	}`))
+	require.NoError(t, err)
+
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, 0.0, raw["temperature"])
+}
+
+func TestNormalizeChatRequestClampsMinPIntoRange(t *testing.T) {
+	body, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"min_p":-0.5}`))
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, 0.0, raw["min_p"])
+
+	body, _, err = normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"min_p":2}`))
+	require.NoError(t, err)
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, 1.0, raw["min_p"])
+}
+
+func TestNormalizeChatRequestTopPClampsHighRejectsNonPositive(t *testing.T) {
+	body, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"top_p":1.5}`))
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, 1.0, raw["top_p"])
+
+	for _, bad := range []string{"0", "-0.2"} {
+		_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"top_p":` + bad + `}`))
+		require.Error(t, err, "top_p=%s", bad)
+		require.Contains(t, err.Error(), "top_p")
+	}
+}
+
+func TestNormalizeChatRequestRejectsNonPositiveRepetitionPenalty(t *testing.T) {
+	_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"repetition_penalty":0}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "repetition_penalty")
+
+	body, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"repetition_penalty":5}`))
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, 2.0, raw["repetition_penalty"])
+}
+
+func TestNormalizeChatRequestRejectsInvalidTopK(t *testing.T) {
+	for _, bad := range []string{"0", "-2"} {
+		_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"top_k":` + bad + `}`))
+		require.Error(t, err, "top_k=%s", bad)
+		require.Contains(t, err.Error(), "top_k")
+	}
+	for _, good := range []string{"-1", "1", "50"} {
+		_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"top_k":` + good + `}`))
+		require.NoError(t, err, "top_k=%s", good)
+	}
+}
+
+func TestNormalizeChatRequestRejectsZeroMaxTokens(t *testing.T) {
+	_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"max_tokens":0}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "max_tokens")
+
+	_, _, err = normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"max_completion_tokens":0}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "max_completion_tokens")
+}
+
+func TestNormalizeChatRequestKimiClampsZeroMaxTokensInsteadOfRejecting(t *testing.T) {
+	body, _, err := normalizeChatRequestForModel([]byte(`{"messages":[{"role":"user","content":"hi"}],"max_tokens":0}`), kimiK26ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, kimiMaxTokensMin, raw["max_tokens"])
+}
+
+// Regression (found via e2e against the live Kimi route): a Kimi request that
+// sends only max_completion_tokens must floor it AND mirror into max_tokens, so
+// the thinking_token_budget defaulter (which derives from max_tokens) bounds
+// reasoning. Without the mirror the whole budget is spent thinking → empty content.
+func TestNormalizeChatRequestKimiMaxCompletionTokensZeroMirrorsToMaxTokens(t *testing.T) {
+	body, req, err := normalizeChatRequestForModel(
+		[]byte(`{"messages":[{"role":"user","content":"hi"}],"max_completion_tokens":0}`), kimiK26ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(body, &raw))
+	require.EqualValues(t, kimiMaxTokensMin, raw["max_tokens"], "max_tokens mirrored + floored")
+	require.EqualValues(t, kimiMaxTokensMin, raw["max_completion_tokens"], "max_completion_tokens floored")
+	require.EqualValues(t, kimiMaxTokensMin, req.MaxTokens)
+	require.Contains(t, raw, "thinking_token_budget", "thinking budget derives from the mirrored max_tokens")
+}
+
+func TestNormalizeChatRequestRejectsNonBoolFlags(t *testing.T) {
+	for _, field := range []string{"skip_special_tokens", "detokenize", "parallel_tool_calls"} {
+		_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"` + field + `":"yes"}`))
+		require.Error(t, err, field)
+		require.Contains(t, err.Error(), field)
+	}
+	_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"skip_special_tokens":true,"parallel_tool_calls":false}`))
+	require.NoError(t, err)
+}
+
+func TestNormalizeChatRequestRejectsNonIntStopTokenIds(t *testing.T) {
+	_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"stop_token_ids":[1,"two",3]}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "stop_token_ids")
+
+	_, _, err = normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"stop_token_ids":[1,2,3]}`))
+	require.NoError(t, err)
+}
+
+func TestNormalizeChatRequestRejectsNonStringStopAndBadWords(t *testing.T) {
+	_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"stop":["ok",5]}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "stop")
+
+	_, _, err = normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"bad_words":["ok",5]}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "bad_words")
+}
+
+func TestNormalizeChatRequestRejectsNonIntMinTokens(t *testing.T) {
+	_, _, err := normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"min_tokens":3.5}`))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "min_tokens")
+
+	_, _, err = normalizeChatRequest([]byte(`{"messages":[{"role":"user","content":"hi"}],"min_tokens":5,"max_tokens":100}`))
+	require.NoError(t, err)
+}
+
 func TestNormalizeChatRequestClampsFrequencyAndPresencePenalty(t *testing.T) {
 	// OpenAI/vLLM accept [-2.0, 2.0] for both. Catalog clamps; out-of-range is rewritten,
 	// not rejected. Per-Kimi force-zero is exercised separately under ApplyKimiRequestOverrides.
@@ -2055,13 +2197,18 @@ func TestNormalizeChatRequestKimiThinkingTokenBudgetRespectsClientValue(t *testi
 	require.Contains(t, string(body), `"thinking_token_budget":500`)
 }
 
-func TestNormalizeChatRequestKimiThinkingTokenBudgetClampsAboveMaxTokens(t *testing.T) {
+// When the client requests a ttb above max_tokens, ttb is clamped DOWN to
+// (max_tokens - kimiContentHeadroomMin) so that visible content always has
+// room to emit after </think>. Before content-headroom enforcement the value
+// was just clamped to max_tokens itself, which caused empty-content streams
+// when the model burned the entire budget on thinking.
+func TestNormalizeChatRequestKimiThinkingTokenBudgetClampsBelowMaxTokensByContentHeadroom(t *testing.T) {
 	body, _, err := normalizeChatRequestForModel(
 		[]byte(`{"messages":[{"role":"user","content":"x"}],"max_tokens":4096,"thinking_token_budget":10000}`),
 		kimiK26ModelID,
 	)
 	require.NoError(t, err)
-	require.Contains(t, string(body), `"thinking_token_budget":4096`)
+	require.Contains(t, string(body), `"thinking_token_budget":4032`)
 }
 
 func TestNormalizeChatRequestKimiThinkingTokenBudgetClampsAboveAbsoluteMax(t *testing.T) {
@@ -2077,13 +2224,17 @@ func TestNormalizeChatRequestKimiThinkingTokenBudgetClampsAboveAbsoluteMax(t *te
 	require.Contains(t, string(body), `"thinking_token_budget":96000`)
 }
 
-func TestNormalizeChatRequestKimiThinkingTokenBudgetSmallMaxTokensSplitsInHalf(t *testing.T) {
+// At max_tokens below kimiSmallMaxTokensForceNoThinking the defaulter's
+// half-split (max_tokens/2) is overridden to 0 because any thinking phase
+// starves visible content emission at that budget. Bypassing thinking is
+// the only way to guarantee non-empty content
+func TestNormalizeChatRequestKimiThinkingTokenBudgetForcedToZeroAtSmallMaxTokens(t *testing.T) {
 	body, _, err := normalizeChatRequestForModel(
 		[]byte(`{"messages":[{"role":"user","content":"x"}],"max_tokens":200}`),
 		kimiK26ModelID,
 	)
 	require.NoError(t, err)
-	require.Contains(t, string(body), `"thinking_token_budget":100`)
+	require.Contains(t, string(body), `"thinking_token_budget":0`)
 }
 
 func TestNormalizeChatRequestKimiThinkingTokenBudgetHalfSplitMidRange(t *testing.T) {
@@ -2104,6 +2255,73 @@ func TestNormalizeChatRequestKimiThinkingTokenBudgetEnforcedEvenWhenDisabled(t *
 	require.Contains(t, string(body), `"thinking_token_budget":2048`)
 }
 
+// Boundary check: max_tokens=256 is the inclusive lower bound where
+// thinking_token_budget is NOT force-zeroed. Just above the cutoff, the
+// half-split defaulter wins (max_tokens/2 = 128) and survives the content-
+// headroom clamp (256-64=192 >= 128).
+func TestNormalizeChatRequestKimiThinkingTokenBudgetForceZeroBoundaryAt256(t *testing.T) {
+	body, _, err := normalizeChatRequestForModel(
+		[]byte(`{"messages":[{"role":"user","content":"x"}],"max_tokens":256}`),
+		kimiK26ModelID,
+	)
+	require.NoError(t, err)
+	require.Contains(t, string(body), `"thinking_token_budget":128`)
+}
+
+// Force-zero is intentionally strong: it overrides client-provided ttb when
+// max_tokens is below the threshold. Without this, probe traffic with explicit
+// thinking_token_budget=50 at max_tokens=100 keeps burning content budget.
+func TestNormalizeChatRequestKimiThinkingTokenBudgetForceZeroOverridesClientValue(t *testing.T) {
+	body, _, err := normalizeChatRequestForModel(
+		[]byte(`{"messages":[{"role":"user","content":"x"}],"max_tokens":100,"min_tokens":100,"thinking_token_budget":50}`),
+		kimiK26ModelID,
+	)
+	require.NoError(t, err)
+	require.Contains(t, string(body), `"thinking_token_budget":0`)
+}
+
+// Content-headroom clamp narrows client-set ttb down toward
+// (max_tokens - kimiContentHeadroomMin) when above max_tokens, but leaves
+// already-conservative values untouched. Threshold case: max_tokens=512 sits
+// well above the force-zero cutoff, so the clamp behavior is testable in
+// isolation.
+func TestNormalizeChatRequestKimiThinkingTokenBudgetContentHeadroomClamp(t *testing.T) {
+	cases := []struct {
+		name      string
+		maxTokens uint64
+		ttbIn     uint64
+		ttbWant   uint64
+	}{
+		{name: "ttb_below_headroom_kept", maxTokens: 512, ttbIn: 100, ttbWant: 100},
+		{name: "ttb_at_headroom_kept", maxTokens: 512, ttbIn: 448, ttbWant: 448},
+		{name: "ttb_above_headroom_clamped", maxTokens: 512, ttbIn: 500, ttbWant: 448},
+		{name: "ttb_far_above_clamped_to_headroom", maxTokens: 512, ttbIn: 99999, ttbWant: 448},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			body := fmt.Sprintf(`{"messages":[{"role":"user","content":"x"}],"max_tokens":%d,"thinking_token_budget":%d}`, c.maxTokens, c.ttbIn)
+			out, _, err := normalizeChatRequestForModel([]byte(body), kimiK26ModelID)
+			require.NoError(t, err)
+			require.Contains(t, string(out), fmt.Sprintf(`"thinking_token_budget":%d`, c.ttbWant))
+		})
+	}
+}
+
+// The probe burn-pattern reproducer: max_tokens=100, min_tokens=100,
+// thinking_token_budget=50 was 82% of the empty_stream_attempt captures on
+// 2026-05-22. After the fix the ttb is forced to 0 (below the 256 threshold),
+// giving the model the full 100 tokens for visible content. This single test
+// locks the regression closed.
+func TestNormalizeChatRequestKimiThinkingTokenBudgetClosesProbeBurnPattern(t *testing.T) {
+	body, _, err := normalizeChatRequestForModel(
+		[]byte(`{"messages":[{"role":"user","content":"Reply with exactly: ok"}],"max_tokens":100,"min_tokens":100,"thinking_token_budget":50,"temperature":0,"logprobs":true,"top_logprobs":5,"stream":true}`),
+		kimiK26ModelID,
+	)
+	require.NoError(t, err)
+	require.Contains(t, string(body), `"thinking_token_budget":0`)
+	require.Contains(t, string(body), `"max_tokens":100`)
+}
+
 func TestNormalizeChatRequestKimiThinkingTokenBudgetNotInjectedForOtherModels(t *testing.T) {
 	body, _, err := normalizeChatRequestForModel(
 		[]byte(`{"messages":[{"role":"user","content":"x"}],"max_tokens":4096}`),
@@ -2384,9 +2602,9 @@ func TestNormalizeChatRequestReasoningInvalidEffortRejected(t *testing.T) {
 
 func TestNormalizeChatRequestTranslatesEnableThinkingToChatTemplateKwargs(t *testing.T) {
 	cases := []struct {
-		name  string
-		body  string
-		want  bool
+		name string
+		body string
+		want bool
 	}{
 		{name: "true", body: `{"messages":[{"role":"user","content":"hi"}],"enable_thinking":true}`, want: true},
 		{name: "false", body: `{"messages":[{"role":"user","content":"hi"}],"enable_thinking":false}`, want: false},
@@ -2583,3 +2801,332 @@ func TestStructuredOutputsCatalogEntryRunsInPreValidationStage(t *testing.T) {
 	}
 	require.True(t, found, "structured_outputs catalog entry missing")
 }
+
+// ====================================================================
+// MiniMax-M2.7 route — see docs/chat-api/minimax-m2.7.md
+// ====================================================================
+
+func TestNormalizeForMinimaxStripsThinking(t *testing.T) {
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"thinking":{"type":"enabled"}}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.NotContains(t, raw, "thinking")
+	require.NotContains(t, raw, "chat_template_kwargs")
+}
+
+func TestNormalizeForMinimaxStripsEnableThinking(t *testing.T) {
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"enable_thinking":true}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.NotContains(t, raw, "enable_thinking")
+	require.NotContains(t, raw, "chat_template_kwargs")
+}
+
+func TestNormalizeForMinimaxStripsThinkingTokenBudget(t *testing.T) {
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"max_tokens":4096,"thinking_token_budget":1024}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.NotContains(t, raw, "thinking_token_budget")
+}
+
+func TestNormalizeForMinimaxDoesNotForceZeroPenalties(t *testing.T) {
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"frequency_penalty":0.5,"presence_penalty":-0.5}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.EqualValues(t, 0.5, raw["frequency_penalty"])
+	require.EqualValues(t, -0.5, raw["presence_penalty"])
+}
+
+func TestNormalizeForMinimaxStripsSafetyIdentifier(t *testing.T) {
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"safety_identifier":"abuse-track-hash"}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.NotContains(t, raw, "safety_identifier")
+}
+
+func TestNormalizeForMinimaxAcceptsToolMessageArrayShape(t *testing.T) {
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"weather in Paris?"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{}"}}]},
+			{"role":"tool","content":[{"name":"get_weather","type":"text","text":"{\"temp\":\"18\"}"}]}
+		]
+	}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	msgs, ok := raw["messages"].([]any)
+	require.True(t, ok)
+	require.Len(t, msgs, 3)
+	toolMsg := msgs[2].(map[string]any)
+	content, ok := toolMsg["content"].([]any)
+	require.True(t, ok, "M2.7 tool content must remain an array (no flatten)")
+	require.Len(t, content, 1)
+	entry := content[0].(map[string]any)
+	require.Equal(t, "get_weather", entry["name"])
+	require.Equal(t, "text", entry["type"])
+}
+
+func TestNormalizeForMinimaxStripsToolCallIDFromToolMessage(t *testing.T) {
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","tool_call_id":"call_1","content":[{"name":"fn","type":"text","text":"ok"}]}
+		]
+	}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	msgs := raw["messages"].([]any)
+	toolMsg := msgs[2].(map[string]any)
+	require.NotContains(t, toolMsg, "tool_call_id", "M2.7 strips tool_call_id silently for dual-emit compat")
+}
+
+func TestNormalizeForMinimaxDropsOrphanToolMessage(t *testing.T) {
+	// Orphan = no preceding assistant.tool_calls[] block.
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"tool","content":[{"name":"fn","type":"text","text":"strayed"}]},
+			{"role":"assistant","content":"hello"}
+		]
+	}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	msgs := raw["messages"].([]any)
+	require.Len(t, msgs, 2, "orphan tool message must be dropped")
+	require.Equal(t, "user", msgs[0].(map[string]any)["role"])
+	require.Equal(t, "assistant", msgs[1].(map[string]any)["role"])
+}
+
+func TestNormalizeForMinimaxPreservesThinkBlocksInAssistantContent(t *testing.T) {
+	// MiniMax-M2.7 interleaved-thinking constraint: <think>...</think> in
+	// assistant content history must round-trip byte-identical.
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"first question"},
+			{"role":"assistant","content":"<think>let me reason about this</think> here is the answer"},
+			{"role":"user","content":"follow up"}
+		]
+	}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	msgs := raw["messages"].([]any)
+	asst := msgs[1].(map[string]any)
+	require.Equal(t, "<think>let me reason about this</think> here is the answer", asst["content"])
+}
+
+func TestValidateForMinimaxRejectsBareStringToolContent(t *testing.T) {
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":"bare string instead of array"}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "content")
+	require.Equal(t, http.StatusBadRequest, chatRequestErrorStatus(err, http.StatusInternalServerError))
+}
+
+func TestValidateForMinimaxRejectsToolEntryMissingName(t *testing.T) {
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[{"type":"text","text":"missing name"}]}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "name")
+}
+
+func TestValidateForMinimaxRejectsToolEntryWrongType(t *testing.T) {
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[{"name":"fn","type":"image_url","text":"x"}]}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "type")
+}
+
+func TestValidateForMinimaxRejectsExtraKeysInToolEntry(t *testing.T) {
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[{"name":"fn","type":"text","text":"ok","unexpected":true}]}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "unsupported key")
+}
+
+func TestNormalizeForOpenAIRouteStillRequiresToolCallID(t *testing.T) {
+	// Sanity: the catalog default policy keeps OpenAI-compat behavior on non-M2.7 routes.
+	body := `{
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[{"name":"fn","type":"text","text":"ok"}]}
+		]
+	}`
+	_, _, err := normalizeChatRequest([]byte(body))
+	require.Error(t, err, "OpenAI route requires tool_call_id; array-content tool message should fail validation")
+}
+
+func TestNormalizeForMinimaxPassesReasoningSplitFromExtraBody(t *testing.T) {
+	// extra_body.reasoning_split is a MiniMax native extension; gateway lifts it
+	// to top-level (universal extra_body unwrap) and forwards to vLLM verbatim.
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"extra_body":{"reasoning_split":true}}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.NotContains(t, raw, "extra_body")
+	require.Equal(t, true, raw["reasoning_split"], "reasoning_split must survive the closed-allowlist check on MiniMax")
+}
+
+func TestNormalizeForMinimaxPassesReasoningSplitTopLevel(t *testing.T) {
+	body := `{"model":"MiniMaxAI/MiniMax-M2.7","messages":[{"role":"user","content":"hi"}],"reasoning_split":false}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	require.Equal(t, false, raw["reasoning_split"])
+}
+
+func TestNormalizeStripsReasoningSplitOnDefaultRoute(t *testing.T) {
+	// Kimi/Qwen vLLM servers do not know reasoning_split; the gateway strips it so
+	// stray clients don't trip an upstream parser error. Assert it is actually gone
+	// on both the empty default route and an explicit non-MiniMax (Kimi) route.
+	for _, routedModel := range []string{"", kimiK26ModelID} {
+		body := `{"messages":[{"role":"user","content":"hi"}],"reasoning_split":true}`
+		out, _, err := normalizeChatRequestForModel([]byte(body), routedModel)
+		require.NoError(t, err)
+		var raw map[string]any
+		require.NoError(t, json.Unmarshal(out, &raw))
+		require.NotContains(t, raw, "reasoning_split", "route=%q", routedModel)
+	}
+}
+
+func TestNormalizeForMinimaxPreservesReasoningDetailsOnAssistantTurn(t *testing.T) {
+	// MiniMax-M2.7 emits reasoning_details[] on the response when reasoning_split=true;
+	// clients round-trip it back into history. Gateway MUST NOT strip — stripping
+	// breaks interleaved-thinking continuity.
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"final answer","reasoning_details":[{"type":"text","text":"step 1"},{"type":"text","text":"step 2"}]}
+		]
+	}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	msgs := raw["messages"].([]any)
+	asst := msgs[1].(map[string]any)
+	details, ok := asst["reasoning_details"].([]any)
+	require.True(t, ok, "reasoning_details must round-trip on assistant turn")
+	require.Len(t, details, 2)
+}
+
+func TestValidateForMinimaxRejectsToolMessageExceedingMaxEntries(t *testing.T) {
+	entries := make([]string, 0, MinimaxToolMessageMaxEntries+1)
+	for i := 0; i < MinimaxToolMessageMaxEntries+1; i++ {
+		entries = append(entries, `{"name":"fn","type":"text","text":"r"}`)
+	}
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[` + strings.Join(entries, ",") + `]}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "exceeds limit")
+}
+
+func TestValidateForMinimaxRejectsToolMessageNameTooLong(t *testing.T) {
+	tooLongName := strings.Repeat("x", MinimaxToolMessageNameMaxLen+1)
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[{"name":"` + tooLongName + `","type":"text","text":"ok"}]}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "name length")
+}
+
+func TestValidateForMinimaxRejectsToolMessageTextTooLarge(t *testing.T) {
+	tooLongText := strings.Repeat("a", MinimaxToolMessageTextMaxSize+1)
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[
+			{"role":"user","content":"hi"},
+			{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"fn","arguments":"{}"}}]},
+			{"role":"tool","content":[{"name":"fn","type":"text","text":"` + tooLongText + `"}]}
+		]
+	}`
+	_, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "text size")
+}
+
+func TestNormalizeForMinimaxStripsToolsFunctionStrict(t *testing.T) {
+	// ToolsValidator silently strips function.strict on every route; confirm it
+	// holds on the MiniMax route (vLLM minimax_m2 parser ignores the field).
+	body := `{
+		"model":"MiniMaxAI/MiniMax-M2.7",
+		"messages":[{"role":"user","content":"hi"}],
+		"tools":[{"type":"function","function":{"name":"fn","strict":true,"parameters":{"type":"object","properties":{}}}}]
+	}`
+	out, _, err := normalizeChatRequestForModel([]byte(body), miniMaxM27ModelID)
+	require.NoError(t, err)
+	var raw map[string]any
+	require.NoError(t, json.Unmarshal(out, &raw))
+	tools, ok := raw["tools"].([]any)
+	require.True(t, ok)
+	require.Len(t, tools, 1)
+	fn := tools[0].(map[string]any)["function"].(map[string]any)
+	require.NotContains(t, fn, "strict")
+}
diff --git a/devshard/cmd/devshardctl/response_cache.go b/devshard/cmd/devshardctl/response_cache.go
index d915029229..33ccd98659 100644
--- a/devshard/cmd/devshardctl/response_cache.go
+++ b/devshard/cmd/devshardctl/response_cache.go
@@ -13,10 +13,29 @@ import (
 
 const chatResponseCacheTTL = time.Hour
 
+// chatCacheSweepInterval bounds how often Set pays for a full expiry sweep.
+// Expiry used to be enforced only lazily inside Get for the exact key being
+// looked up; since keys are hashes of full request bodies, unique requests
+// were never looked up again and their entries lived until process restart.
+const chatCacheSweepInterval = time.Minute
+
+// defaultChatCacheMaxBytes caps the total body bytes held by the cache
+// (overridable via DEVSHARD_CHAT_CACHE_MAX_BYTES). The cap is a safety net
+// against traffic bursts within the TTL window; the sweep handles steady
+// state.
+const defaultChatCacheMaxBytes = int64(256 << 20)
+
+// chatCacheEntryOverhead approximates the per-entry cost beyond the body:
+// map bucket, key string (64-hex sha256), and struct fields.
+const chatCacheEntryOverhead = 256
+
 type chatResponseCache struct {
-	mu      sync.Mutex
-	ttl     time.Duration
-	entries map[string]cachedChatResponse
+	mu         sync.Mutex
+	ttl        time.Duration
+	maxBytes   int64
+	entries    map[string]cachedChatResponse
+	totalBytes int64
+	lastSweep  time.Time
 }
 
 type cachedChatResponse struct {
@@ -29,13 +48,50 @@ type cachedChatResponse struct {
 	ExpiresAt       time.Time
 }
 
-func newChatResponseCache(ttl time.Duration) *chatResponseCache {
+func newChatResponseCache(ttl time.Duration, maxBytes int64) *chatResponseCache {
 	if ttl <= 0 {
 		ttl = chatResponseCacheTTL
 	}
+	if maxBytes <= 0 {
+		maxBytes = defaultChatCacheMaxBytes
+	}
 	return &chatResponseCache{
-		ttl:     ttl,
-		entries: make(map[string]cachedChatResponse),
+		ttl:      ttl,
+		maxBytes: maxBytes,
+		entries:  make(map[string]cachedChatResponse),
+	}
+}
+
+func chatCacheEntrySize(entry cachedChatResponse) int64 {
+	return int64(len(entry.Body)+len(entry.ContentType)+len(entry.EscrowID)+len(entry.SourceRequestID)) + chatCacheEntryOverhead
+}
+
+// deleteLocked removes key from the map and adjusts the byte total.
+// Caller must hold c.mu.
+func (c *chatResponseCache) deleteLocked(key string) {
+	entry, ok := c.entries[key]
+	if !ok {
+		return
+	}
+	delete(c.entries, key)
+	c.totalBytes -= chatCacheEntrySize(entry)
+	if c.totalBytes < 0 {
+		// Entries written directly in tests bypass accounting.
+		c.totalBytes = 0
+	}
+}
+
+// sweepExpiredLocked scans the whole map and drops entries whose TTL has
+// passed, at most once per chatCacheSweepInterval. Caller must hold c.mu.
+func (c *chatResponseCache) sweepExpiredLocked(now time.Time) {
+	if now.Sub(c.lastSweep) < chatCacheSweepInterval {
+		return
+	}
+	c.lastSweep = now
+	for key, entry := range c.entries {
+		if !entry.ExpiresAt.After(now) {
+			c.deleteLocked(key)
+		}
 	}
 }
 
@@ -58,11 +114,11 @@ func (c *chatResponseCache) Get(key string, now time.Time) (cachedChatResponse,
 		return cachedChatResponse{}, false
 	}
 	if !entry.ExpiresAt.After(now) {
-		delete(c.entries, key)
+		c.deleteLocked(key)
 		return cachedChatResponse{}, false
 	}
-	if responseBodyHasRetriableCapabilityError(entry.Body) {
-		delete(c.entries, key)
+	if responseBodyHasNonCacheableError(entry.Body) {
+		c.deleteLocked(key)
 		return cachedChatResponse{}, false
 	}
 	entry.Body = append([]byte(nil), entry.Body...)
@@ -73,7 +129,7 @@ func (c *chatResponseCache) Set(key string, entry cachedChatResponse, now time.T
 	if c == nil || key == "" || len(entry.Body) == 0 || strings.TrimSpace(entry.EscrowID) == "" {
 		return
 	}
-	if responseBodyHasRetriableCapabilityError(entry.Body) {
+	if !cacheableResponse(entry.StatusCode, entry.Body) {
 		return
 	}
 	if entry.ExpiresAt.IsZero() {
@@ -83,7 +139,38 @@ func (c *chatResponseCache) Set(key string, entry cachedChatResponse, now time.T
 
 	c.mu.Lock()
 	defer c.mu.Unlock()
+	c.sweepExpiredLocked(now)
+
+	c.deleteLocked(key) // drop any previous version's byte count
 	c.entries[key] = entry
+	c.totalBytes += chatCacheEntrySize(entry)
+
+	// Size cap: evict arbitrary entries (map iteration order) until under
+	// the limit. This is a dedup cache -- evicting a "wrong" entry only
+	// costs one cache miss, so eviction order isn't worth tracking.
+	if chatCacheEntrySize(entry) > c.maxBytes {
+		// Entry is too large to fit under the cap; don't cache it.
+		c.deleteLocked(key)
+		return
+	}
+	for other := range c.entries {
+		if c.totalBytes <= c.maxBytes {
+			break
+		}
+		if other != key {
+			c.deleteLocked(other)
+		}
+	}
+}
+
+// Stats reports the current entry count and approximate retained bytes.
+func (c *chatResponseCache) Stats() (entryCount int, totalBytes int64) {
+	if c == nil {
+		return 0, 0
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return len(c.entries), c.totalBytes
 }
 
 func serveCachedChatResponse(w http.ResponseWriter, r *http.Request, entry cachedChatResponse) {
@@ -151,15 +238,16 @@ func (w *gatewayChatCacheCapture) statusCode() int {
 	return w.status
 }
 
-func (w *gatewayChatCacheCapture) cacheEntry(escrowID string, stream bool, sourceRequestID string) (cachedChatResponse, bool) {
+func (w *gatewayChatCacheCapture) cacheEntry(escrowID string, stream bool, sourceRequestID string, requestErr error) (cachedChatResponse, bool) {
 	if w == nil || w.writeErr != nil || w.body.Len() == 0 {
 		return cachedChatResponse{}, false
 	}
-	statusCode := w.statusCode()
-	if statusCode < 200 {
+	if requestErr != nil {
 		return cachedChatResponse{}, false
 	}
-	if responseBodyHasRetriableCapabilityError(w.body.Bytes()) {
+	statusCode := w.statusCode()
+	body := w.body.Bytes()
+	if !cacheableResponse(statusCode, body) {
 		return cachedChatResponse{}, false
 	}
 	return cachedChatResponse{
@@ -167,11 +255,38 @@ func (w *gatewayChatCacheCapture) cacheEntry(escrowID string, stream bool, sourc
 		Stream:          stream,
 		StatusCode:      statusCode,
 		ContentType:     w.Header().Get("Content-Type"),
-		Body:            append([]byte(nil), w.body.Bytes()...),
+		Body:            append([]byte(nil), body...),
 		SourceRequestID: sourceRequestID,
 	}, true
 }
 
+func cacheableResponse(statusCode int, body []byte) bool {
+	if len(body) == 0 || responseBodyHasNonCacheableError(body) {
+		return false
+	}
+	if statusCode == 0 {
+		statusCode = http.StatusOK
+	}
+	if statusCode >= 200 && statusCode < 300 {
+		return true
+	}
+	if statusCode == http.StatusBadRequest {
+		details, ok := jsonErrorPayloadDetails(body)
+		return ok && isCacheableOpenAIErrorDetails(details)
+	}
+	return false
+}
+
+func responseBodyHasNonCacheableError(body []byte) bool {
+	if details, ok := sseChunkErrorDetails(body); ok {
+		return !isCacheableOpenAIErrorDetails(details)
+	}
+	if details, ok := jsonErrorPayloadDetails(body); ok {
+		return !isCacheableOpenAIErrorDetails(details)
+	}
+	return false
+}
+
 func responseBodyHasRetriableCapabilityError(body []byte) bool {
 	if details, ok := sseChunkErrorDetails(body); ok {
 		return isRetriableCapabilityErrorMessage(details.Message)
@@ -181,3 +296,39 @@ func responseBodyHasRetriableCapabilityError(body []byte) bool {
 	}
 	return false
 }
+
+func isCacheableOpenAIErrorDetails(details sseErrorDetails) bool {
+	msg := strings.ToLower(details.Message)
+	typ := strings.ToLower(details.Type)
+	code := strings.ToLower(details.Code)
+	if strings.TrimSpace(msg) == "" {
+		return false
+	}
+	if isRetriableCapabilityErrorMessage(details.Message) {
+		return false
+	}
+	for _, marker := range []string{
+		"context canceled",
+		"context cancelled",
+		"client disconnected",
+		"request canceled",
+		"request cancelled",
+		"timeout",
+		"timed out",
+		"rate limit",
+		"overloaded",
+		"temporarily unavailable",
+		"service unavailable",
+		"internal server error",
+		"unsupported model",
+		"model not found",
+		"model_not_found",
+		"does not exist",
+		"not supported on this model",
+	} {
+		if strings.Contains(msg, marker) || strings.Contains(typ, marker) || strings.Contains(code, marker) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/devshard/cmd/devshardctl/response_cache_test.go b/devshard/cmd/devshardctl/response_cache_test.go
new file mode 100644
index 0000000000..3f80366818
--- /dev/null
+++ b/devshard/cmd/devshardctl/response_cache_test.go
@@ -0,0 +1,198 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestGatewayChatCacheCaptureRejectsCanceledRequestError(t *testing.T) {
+	rec := httptest.NewRecorder()
+	capture := &gatewayChatCacheCapture{ResponseWriter: rec}
+	writeGatewayJSONError(capture, http.StatusBadGateway, context.Canceled.Error())
+
+	entry, ok := capture.cacheEntry("escrow-1", false, "req-source", context.Canceled)
+
+	require.False(t, ok)
+	require.Empty(t, entry.Body)
+}
+
+func TestGatewayChatCacheCaptureAllowsSuccessfulResponse(t *testing.T) {
+	rec := httptest.NewRecorder()
+	capture := &gatewayChatCacheCapture{ResponseWriter: rec}
+	writeJSONPayload(capture, http.StatusOK, []byte(`{"choices":[{"message":{"content":"ok"}}]}`))
+
+	entry, ok := capture.cacheEntry("escrow-1", false, "req-source", nil)
+
+	require.True(t, ok)
+	require.Equal(t, http.StatusOK, entry.StatusCode)
+	require.JSONEq(t, `{"choices":[{"message":{"content":"ok"}}]}`, string(entry.Body))
+}
+
+func TestGatewayChatCacheCaptureAllowsDeterministicOpenAIStyleBadRequest(t *testing.T) {
+	rec := httptest.NewRecorder()
+	capture := &gatewayChatCacheCapture{ResponseWriter: rec}
+	writeJSONPayload(capture, http.StatusBadRequest, []byte(`{"error":{"message":"bad response_format schema","type":"BadRequestError","code":400}}`))
+
+	entry, ok := capture.cacheEntry("escrow-1", false, "req-source", nil)
+
+	require.True(t, ok)
+	require.Equal(t, http.StatusBadRequest, entry.StatusCode)
+	require.JSONEq(t, `{"error":{"message":"bad response_format schema","type":"BadRequestError","code":400}}`, string(entry.Body))
+}
+
+func TestGatewayChatCacheCaptureRejectsRuntimeAndCapabilityErrors(t *testing.T) {
+	tests := []struct {
+		name   string
+		status int
+		body   string
+	}{
+		{
+			name:   "context canceled",
+			status: http.StatusBadGateway,
+			body:   `{"error":{"message":"context canceled"}}`,
+		},
+		{
+			name:   "rate limited",
+			status: http.StatusTooManyRequests,
+			body:   `{"error":{"message":"rate limit exceeded","type":"RateLimitError","code":429}}`,
+		},
+		{
+			name:   "unsupported model",
+			status: http.StatusBadRequest,
+			body:   `{"error":{"message":"unsupported model \"Nope/Model\"","type":"BadRequestError","code":400}}`,
+		},
+		{
+			name:   "context length",
+			status: http.StatusBadRequest,
+			body:   `{"error":{"message":"This model's maximum context length is 131072 tokens. However, you requested 150000 tokens.","type":"BadRequestError","code":400}}`,
+		},
+		{
+			name:   "server error",
+			status: http.StatusInternalServerError,
+			body:   `{"error":{"message":"internal server error","type":"InternalServerError","code":500}}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			rec := httptest.NewRecorder()
+			capture := &gatewayChatCacheCapture{ResponseWriter: rec}
+			writeJSONPayload(capture, tt.status, []byte(tt.body))
+
+			entry, ok := capture.cacheEntry("escrow-1", false, "req-source", nil)
+
+			require.False(t, ok)
+			require.Empty(t, entry.Body)
+		})
+	}
+}
+
+func okBody(marker byte, size int) []byte {
+	filler := make([]byte, size)
+	for i := range filler {
+		filler[i] = 'a' + (marker+byte(i))%26
+	}
+	return []byte(`{"choices":[{"message":{"content":"` + string(filler) + `"}}]}`)
+}
+
+func cacheEntryForTest(marker byte, bodySize int) cachedChatResponse {
+	return cachedChatResponse{
+		EscrowID:   "escrow-1",
+		StatusCode: http.StatusOK,
+		Body:       okBody(marker, bodySize),
+	}
+}
+
+func TestChatResponseCacheSweepsExpiredEntriesOnSet(t *testing.T) {
+	cache := newChatResponseCache(time.Minute, 0)
+	start := time.Now()
+
+	cache.Set("old-1", cacheEntryForTest(1, 10), start)
+	cache.Set("old-2", cacheEntryForTest(2, 10), start)
+
+	count, _ := cache.Stats()
+	require.Equal(t, 2, count)
+
+	// A Set past both the TTL and the sweep interval must remove the
+	// expired entries even though their keys are never looked up again.
+	cache.Set("new", cacheEntryForTest(3, 10), start.Add(2*time.Minute))
+
+	count, _ = cache.Stats()
+	require.Equal(t, 1, count)
+	_, ok := cache.entries["old-1"]
+	require.False(t, ok)
+	_, ok = cache.entries["old-2"]
+	require.False(t, ok)
+	_, ok = cache.entries["new"]
+	require.True(t, ok)
+}
+
+func TestChatResponseCacheEvictsWhenOverByteCap(t *testing.T) {
+	// Cap fits roughly two 4KB entries plus overhead, not three.
+	cache := newChatResponseCache(time.Minute, 10_000)
+	now := time.Now()
+
+	cache.Set("a", cacheEntryForTest(1, 4096), now)
+	cache.Set("b", cacheEntryForTest(2, 4096), now)
+	cache.Set("c", cacheEntryForTest(3, 4096), now)
+
+	_, totalBytes := cache.Stats()
+	require.LessOrEqual(t, totalBytes, int64(10_000))
+
+	// The just-inserted entry must survive eviction.
+	_, ok := cache.entries["c"]
+	require.True(t, ok)
+}
+
+func TestChatResponseCacheOverwriteDoesNotLeakBytes(t *testing.T) {
+	cache := newChatResponseCache(time.Minute, 1<<20)
+	now := time.Now()
+
+	for i := 0; i < 100; i++ {
+		cache.Set("same-key", cacheEntryForTest(byte(i), 4096), now)
+	}
+
+	count, totalBytes := cache.Stats()
+	require.Equal(t, 1, count)
+	require.Less(t, totalBytes, int64(2*4096+2*chatCacheEntryOverhead))
+
+	entry, ok := cache.Get("same-key", now)
+	require.True(t, ok)
+	require.Equal(t, string(okBody(99, 4096)), string(entry.Body))
+}
+
+func TestChatResponseCacheGetDeletesExpiredAndAdjustsBytes(t *testing.T) {
+	cache := newChatResponseCache(time.Minute, 0)
+	now := time.Now()
+
+	cache.Set("k", cacheEntryForTest(1, 128), now)
+	_, totalBytes := cache.Stats()
+	require.Greater(t, totalBytes, int64(0))
+
+	_, ok := cache.Get("k", now.Add(2*time.Minute))
+	require.False(t, ok)
+
+	count, totalBytes := cache.Stats()
+	require.Equal(t, 0, count)
+	require.Equal(t, int64(0), totalBytes)
+}
+
+func TestChatResponseCacheDropsPreviouslyCachedNonCacheableErrors(t *testing.T) {
+	cache := newChatResponseCache(time.Minute, 0)
+	cache.entries["bad"] = cachedChatResponse{
+		EscrowID:   "escrow-1",
+		StatusCode: http.StatusBadGateway,
+		Body:       []byte(`{"error":{"message":"context canceled"}}`),
+		ExpiresAt:  time.Now().Add(time.Minute),
+	}
+
+	entry, ok := cache.Get("bad", time.Now())
+
+	require.False(t, ok)
+	require.Empty(t, entry.Body)
+}
diff --git a/devshard/cmd/devshardctl/session_picker.go b/devshard/cmd/devshardctl/session_picker.go
index 9041fda29b..023f34e0d8 100644
--- a/devshard/cmd/devshardctl/session_picker.go
+++ b/devshard/cmd/devshardctl/session_picker.go
@@ -314,9 +314,10 @@ func (p *sessionPicker) run() {
 		// No ghost outcome contacts the host; the kind is purely a
 		// log label (see ghostDispatcher doc).
 		var (
-			chosen    *pickerRequest
-			ghost     ghostKind
-			holdUntil time.Time
+			chosen              *pickerRequest
+			ghost               ghostKind
+			ghostParticipantKey string
+			holdUntil           time.Time
 		)
 		prepared, err := p.session.PrepareInferenceFn(func(b user.HostBinding) (user.InferenceParams, bool, error) {
 			p.mu.Lock()
@@ -353,6 +354,7 @@ func (p *sessionPicker) run() {
 			// more load on a host that just told us it's overwhelmed.
 			if p.throttleBlocked != nil && p.throttleBlocked(b.ParticipantKey) {
 				ghost = ghostThrottled
+				ghostParticipantKey = b.ParticipantKey
 				return ghostProbeParams(p.model), true, nil
 			}
 
@@ -451,12 +453,20 @@ func (p *sessionPicker) run() {
 
 		// Phase 4: dispatch.
 		if ghost != ghostNone {
-			logRequestStage(p.logCtx, "session_picker_ghost_probe",
+			fields := []any{
 				"reason", ghost.reason(),
 				"host_idx", prepared.HostIdx(),
 				"nonce", prepared.Nonce(),
 				"queue_depth", p.queueLen(),
-			)
+			}
+			if ghost == ghostThrottled {
+				fields = append(fields,
+					"no_send", true,
+					"participant_key", ghostParticipantKey,
+					"model_id", p.model,
+				)
+			}
+			logRequestStage(p.logCtx, "session_picker_ghost_probe", fields...)
 			if p.dispatchGhost != nil {
 				p.dispatchGhost(prepared, ghost, ghost.reason())
 			}
diff --git a/devshard/cmd/devshardctl/sse_fixtures_test.go b/devshard/cmd/devshardctl/sse_fixtures_test.go
new file mode 100644
index 0000000000..9601980f38
--- /dev/null
+++ b/devshard/cmd/devshardctl/sse_fixtures_test.go
@@ -0,0 +1,439 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"math/rand/v2"
+	"strconv"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+// Minimal vLLM-shaped SSE fixtures for raceWriter classification tests.
+const sseContentStream = "" +
+	`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","created":1,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","created":1,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"content":"ok"},"finish_reason":null}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","created":1,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"content":""},"finish_reason":"stop"}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-1","object":"chat.completion.chunk","created":1,"model":"Qwen/Qwen3","choices":[],"usage":{"prompt_tokens":3,"total_tokens":5,"completion_tokens":2}}` + "\n\n" +
+	`data: [DONE]` + "\n\n"
+
+const sseToolCallsStream = "" +
+	`data: {"id":"chatcmpl-2","object":"chat.completion.chunk","created":2,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-2","object":"chat.completion.chunk","created":2,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"tool_calls":[{"id":"call-1","type":"function","index":0,"function":{"name":"get_weather"}}]},"finish_reason":null}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-2","object":"chat.completion.chunk","created":2,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"q\":\"sf\"}"}}]},"finish_reason":null}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-2","object":"chat.completion.chunk","created":2,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"content":""},"finish_reason":"tool_calls"}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-2","object":"chat.completion.chunk","created":2,"model":"Qwen/Qwen3","choices":[],"usage":{"prompt_tokens":20,"total_tokens":40,"completion_tokens":20}}` + "\n\n" +
+	`data: [DONE]` + "\n\n"
+
+var sseEmbeddedFixtures = []struct {
+	name       string
+	body       string
+	wantSource string
+}{
+	{"delta.content", sseContentStream, "delta.content"},
+	{"delta.tool_calls", sseToolCallsStream, "delta.tool_calls"},
+}
+
+// Stream whose final content event carries no trailing newline (truncated
+// upstream, mid-event proxy close). Write only classifies up to the last '\n',
+// so the "ok" event lands in classifyPartial and is recovered by flushClassify.
+const sseNewlineLessFinalContent = "" +
+	`data: {"id":"chatcmpl-3","object":"chat.completion.chunk","created":3,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}` + "\n\n" +
+	`data: {"id":"chatcmpl-3","object":"chat.completion.chunk","created":3,"model":"Qwen/Qwen3","choices":[{"index":0,"delta":{"content":"ok"},"finish_reason":null}]}`
+
+// Same shape, but the newline-less final event is a non-retriable error.
+const sseNewlineLessFinalError = "" +
+	`data: {"error":{"message":"boom","type":"server_error","code":"internal"}}`
+
+func TestSseBlobClassifierNotEmpty(t *testing.T) {
+	for _, fx := range sseEmbeddedFixtures {
+		t.Run(fx.name, func(t *testing.T) {
+			src, ok := sseChunkContentSource([]byte(fx.body))
+			require.True(t, ok, "blob classifier returned EMPTY")
+			require.Equal(t, fx.wantSource, src)
+		})
+	}
+}
+
+// Regression: classifier must work for any chunk size, including sub-event.
+func TestSseRaceWriterAllChunkSizes(t *testing.T) {
+	chunkSizes := []int{1, 64, 256, 1024, 4096, 8192}
+	for _, fx := range sseEmbeddedFixtures {
+		for _, sz := range chunkSizes {
+			t.Run(fx.name+"/chunk="+strconv.Itoa(sz), func(t *testing.T) {
+				t.Parallel()
+				inf := mkRaceWriterInflight(t)
+				rw := mkRaceWriter(t, inf)
+				body := []byte(fx.body)
+				for i := 0; i < len(body); i += sz {
+					end := i + sz
+					if end > len(body) {
+						end = len(body)
+					}
+					_, err := rw.Write(body[i:end])
+					require.NoError(t, err)
+				}
+				require.False(t, isEmptyStreamAttempt(inf),
+					"classified empty (cc=%d oc=%d)",
+					inf.contentChunks.Load(), inf.outputChunks.Load())
+				require.Equal(t, fx.wantSource, inf.contentSource)
+			})
+		}
+	}
+}
+
+// Per-attempt cap: oversized newline-less stream is dropped, global counter balanced.
+func TestSseRaceWriterClassifyCapDrops(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+	_, err := rw.Write(bytes.Repeat([]byte("x"), maxClassifyPartial+1))
+	require.NoError(t, err)
+	require.Equal(t, 0, len(inf.classifyPartial))
+	require.Equal(t, before, classifyPartialBytes.Load())
+}
+
+// replaceClassify drops the trailing fragment when it exceeds the per-attempt cap.
+func TestSseRaceWriterReplaceClassifyPerAttemptCapDrops(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+	chunk := append([]byte("\n"), bytes.Repeat([]byte("x"), maxClassifyPartial+1)...)
+	_, err := rw.Write(chunk)
+	require.NoError(t, err)
+	require.Equal(t, 0, len(inf.classifyPartial))
+	require.Equal(t, before, classifyPartialBytes.Load())
+}
+
+// growClassify drops a newline-less chunk when the global cap is already reached.
+func TestSseRaceWriterGrowClassifyGlobalCapDrops(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	defer classifyPartialBytes.Store(before)
+	classifyPartialBytes.Store(maxClassifyPartialGlobal)
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+	_, err := rw.Write([]byte("data: partial-no-newline"))
+	require.NoError(t, err)
+	require.Equal(t, 0, len(inf.classifyPartial))
+	require.Equal(t, maxClassifyPartialGlobal, classifyPartialBytes.Load())
+}
+
+// replaceClassify drops the trailing fragment when the global cap is reached.
+func TestSseRaceWriterReplaceClassifyGlobalCapDrops(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	defer classifyPartialBytes.Store(before)
+	classifyPartialBytes.Store(maxClassifyPartialGlobal)
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+	_, err := rw.Write([]byte("\ntail"))
+	require.NoError(t, err)
+	require.Equal(t, 0, len(inf.classifyPartial))
+	require.Equal(t, maxClassifyPartialGlobal, classifyPartialBytes.Load())
+}
+
+// Dropping the buffer must free its backing array, not just shrink len — else
+// real memory outlives the gauge and can exceed the global cap.
+func TestSseRaceWriterDropReleasesBackingArray(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+	_, err := rw.Write(bytes.Repeat([]byte("x"), maxClassifyPartial-10))
+	require.NoError(t, err)
+	require.Greater(t, cap(inf.classifyPartial), 0)
+	_, err = rw.Write(bytes.Repeat([]byte("x"), 20))
+	require.NoError(t, err)
+	require.Equal(t, 0, cap(inf.classifyPartial), "drop must release the backing array")
+	require.Equal(t, before, classifyPartialBytes.Load())
+}
+
+// releaseClassifyPartial frees a len-0-but-large-cap buffer (the send-goroutine defer after a drop) and leaves the gauge unchanged when len is already 0.
+func TestReleaseClassifyPartialFreesLenZeroBuffer(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	inf := mkRaceWriterInflight(t)
+	inf.classifyPartial = make([]byte, 0, maxClassifyPartial)
+	inf.releaseClassifyPartial()
+	require.Nil(t, inf.classifyPartial)
+	require.Equal(t, before, classifyPartialBytes.Load())
+}
+
+// Realistic transport shape: arbitrary chunk boundaries from TLS/proxy flushes.
+func TestSseRaceWriterRandomChunking(t *testing.T) {
+	for fxIndex, fx := range sseEmbeddedFixtures {
+		t.Run(fx.name, func(t *testing.T) {
+			t.Parallel()
+			// Own rng per subtest: *rand.Rand is not safe for concurrent use.
+			rng := rand.New(rand.NewPCG(42, uint64(fxIndex)))
+			inf := mkRaceWriterInflight(t)
+			rw := mkRaceWriter(t, inf)
+			body := []byte(fx.body)
+			for i := 0; i < len(body); {
+				sz := 1 + rng.IntN(64)
+				end := i + sz
+				if end > len(body) {
+					end = len(body)
+				}
+				_, err := rw.Write(body[i:end])
+				require.NoError(t, err)
+				i = end
+			}
+			require.False(t, isEmptyStreamAttempt(inf),
+				"classified empty (cc=%d oc=%d)",
+				inf.contentChunks.Load(), inf.outputChunks.Load())
+			require.Equal(t, fx.wantSource, inf.contentSource)
+		})
+	}
+}
+
+// Regression: a content event delivered as the final, newline-less write is
+// stashed in classifyPartial during Write and would leave the attempt looking
+// empty. flushClassify (run once the upstream stream ends) must recover it.
+func TestSseRaceWriterFlushRecoversNewlineLessContent(t *testing.T) {
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+
+	_, err := rw.Write([]byte(sseNewlineLessFinalContent))
+	require.NoError(t, err)
+	// Before the flush the trailing content event is unclassified.
+	require.True(t, isEmptyStreamAttempt(inf),
+		"precondition: newline-less final event should be unclassified until flush")
+
+	rw.flushClassify()
+
+	require.False(t, isEmptyStreamAttempt(inf),
+		"flush must classify the newline-less final content event")
+	require.Equal(t, "delta.content", inf.contentSource)
+	require.Equal(t, 0, len(inf.classifyPartial), "flush must release the buffer")
+}
+
+// Regression: flushClassifyAndCheckEmpty must flush the buffered final event before reading contentChunks (a prior deferred flush ran after the decision, misclassifying content as empty).
+func TestFlushClassifyAndCheckEmptyFlushesBeforeDeciding(t *testing.T) {
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+
+	_, err := rw.Write([]byte(sseNewlineLessFinalContent))
+	require.NoError(t, err)
+	require.True(t, isEmptyStreamAttempt(inf),
+		"precondition: unflushed newline-less final event looks empty")
+
+	require.False(t, rw.flushClassifyAndCheckEmpty(),
+		"must flush the buffered final content before the empty-stream decision")
+	require.Equal(t, "delta.content", inf.contentSource)
+}
+
+// Regression: a newline-less final error event must resolve to an error stream, not empty, through the same flush-before-decide path.
+func TestFlushClassifyAndCheckEmptyFinalErrorIsNotEmpty(t *testing.T) {
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+
+	_, err := rw.Write([]byte(sseNewlineLessFinalError))
+	require.NoError(t, err)
+
+	require.False(t, rw.flushClassifyAndCheckEmpty(),
+		"final error event must not be classified as empty_stream")
+	require.True(t, isErrorStreamAttempt(inf))
+}
+
+// Regression: the same recovery must apply to a newline-less final error event
+// so the attempt is classified as an error stream, not an empty one.
+func TestSseRaceWriterFlushRecoversNewlineLessError(t *testing.T) {
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+
+	_, err := rw.Write([]byte(sseNewlineLessFinalError))
+	require.NoError(t, err)
+
+	rw.flushClassify()
+
+	require.True(t, isErrorStreamAttempt(inf), "flush must classify the final error event")
+	require.False(t, isEmptyStreamAttempt(inf))
+	require.Equal(t, "error.server_error", inf.errorSource)
+}
+
+// flushClassify is a no-op when nothing was buffered (normal newline-terminated
+// stream) and stays balanced against the global counter.
+func TestSseRaceWriterFlushNoBufferedTail(t *testing.T) {
+	before := classifyPartialBytes.Load()
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+
+	_, err := rw.Write([]byte(sseContentStream))
+	require.NoError(t, err)
+	require.False(t, isEmptyStreamAttempt(inf))
+	source := inf.contentSource
+	contentChunks := inf.contentChunks.Load()
+
+	rw.flushClassify()
+
+	require.Equal(t, source, inf.contentSource, "flush must not change an already-classified attempt")
+	require.Equal(t, contentChunks, inf.contentChunks.Load(), "flush must not double-count content")
+	require.Equal(t, before, classifyPartialBytes.Load())
+}
+
+// A probe attempt never classifies content, so flushClassify must leave it untouched.
+func TestSseRaceWriterFlushProbeNoop(t *testing.T) {
+	inf := mkRaceWriterInflight(t)
+	inf.probe = true
+	rw := mkRaceWriter(t, inf)
+
+	_, err := rw.Write([]byte(sseNewlineLessFinalContent))
+	require.NoError(t, err)
+
+	rw.flushClassify()
+
+	require.Equal(t, int64(0), inf.contentChunks.Load(), "probe flush must not count content")
+	require.Equal(t, "", inf.contentSource)
+}
+
+// On a cap drop, the raw write chunk is still classified best-effort rather than
+// silently skipped — a complete content line survives even when it can't buffer.
+func TestSseRaceWriterGracefulDegradationOnCapDrop(t *testing.T) {
+	inf := mkRaceWriterInflight(t)
+	rw := mkRaceWriter(t, inf)
+	_, err := rw.Write(bytes.Repeat([]byte("x"), maxClassifyPartial-10))
+	require.NoError(t, err)
+	_, err = rw.Write([]byte(`data: {"choices":[{"delta":{"content":"ok"}}]}`))
+	require.NoError(t, err)
+	require.False(t, isEmptyStreamAttempt(inf), "capped content chunk must still classify")
+	require.Equal(t, "delta.content", inf.contentSource)
+}
+
+// A hostile participant that fills its own budget must not starve another
+// attempt from a different participant sharing the global pool.
+func TestSseRaceWriterParticipantCapIsolatesParticipants(t *testing.T) {
+	restore := saveClassifyCaps()
+	defer restore()
+	maxClassifyPartial = 100
+	maxClassifyPartialParticipant = 150
+	maxClassifyPartialGlobal = 1 << 30
+
+	hostile := &atomic.Int64{}
+	honest := &atomic.Int64{}
+	infHostile := mkRaceWriterInflight(t)
+	infHostile.participantClassifyBytes = hostile
+	infHonest := mkRaceWriterInflight(t)
+	infHonest.participantClassifyBytes = honest
+
+	_, err := mkRaceWriter(t, infHostile).Write(bytes.Repeat([]byte("x"), 100))
+	require.NoError(t, err)
+	require.Equal(t, int64(100), hostile.Load())
+
+	// The honest participant still has its full budget available.
+	_, err = mkRaceWriter(t, infHonest).Write(bytes.Repeat([]byte("y"), 100))
+	require.NoError(t, err)
+	require.Equal(t, 100, len(infHonest.classifyPartial), "honest attempt must not be starved")
+	require.Equal(t, int64(100), honest.Load())
+}
+
+// The same participant is capped across concurrent attempts sharing its counter.
+func TestSseRaceWriterParticipantCapDropsOverBudget(t *testing.T) {
+	restore := saveClassifyCaps()
+	defer restore()
+	maxClassifyPartial = 100
+	maxClassifyPartialParticipant = 150
+	maxClassifyPartialGlobal = 1 << 30
+
+	shared := &atomic.Int64{}
+	first := mkRaceWriterInflight(t)
+	first.participantClassifyBytes = shared
+	second := mkRaceWriterInflight(t)
+	second.participantClassifyBytes = shared
+
+	_, err := mkRaceWriter(t, first).Write(bytes.Repeat([]byte("x"), 100))
+	require.NoError(t, err)
+	_, err = mkRaceWriter(t, second).Write(bytes.Repeat([]byte("y"), 100))
+	require.NoError(t, err)
+
+	require.Equal(t, 0, len(second.classifyPartial), "participant cap must drop the over-budget attempt")
+	require.Equal(t, int64(100), shared.Load(), "over-budget bytes rolled back")
+}
+
+// A global-cap drop must roll back the participant counter it already charged.
+func TestSseRaceWriterGlobalCapRollsBackParticipant(t *testing.T) {
+	restore := saveClassifyCaps()
+	defer restore()
+	maxClassifyPartial = 1000
+	maxClassifyPartialParticipant = 1000
+	maxClassifyPartialGlobal = 50
+
+	participant := &atomic.Int64{}
+	inf := mkRaceWriterInflight(t)
+	inf.participantClassifyBytes = participant
+	before := classifyPartialBytes.Load()
+
+	_, err := mkRaceWriter(t, inf).Write(bytes.Repeat([]byte("x"), 100))
+	require.NoError(t, err)
+
+	require.Equal(t, 0, len(inf.classifyPartial), "global cap drops the attempt")
+	require.Equal(t, int64(0), participant.Load(), "participant counter rolled back")
+	require.Equal(t, before, classifyPartialBytes.Load())
+}
+
+// Releasing the buffer decrements both the global and participant counters.
+func TestReleaseClassifyPartialDecrementsParticipant(t *testing.T) {
+	restore := saveClassifyCaps()
+	defer restore()
+	maxClassifyPartial = 1000
+	maxClassifyPartialParticipant = 1000
+	maxClassifyPartialGlobal = 1 << 30
+
+	participant := &atomic.Int64{}
+	inf := mkRaceWriterInflight(t)
+	inf.participantClassifyBytes = participant
+
+	_, err := mkRaceWriter(t, inf).Write(bytes.Repeat([]byte("x"), 100))
+	require.NoError(t, err)
+	require.Equal(t, int64(100), participant.Load())
+
+	inf.releaseClassifyPartial()
+
+	require.Equal(t, int64(0), participant.Load(), "release decrements participant counter")
+	require.Nil(t, inf.classifyPartial)
+}
+
+func TestConfigureClassifyCapsFromEnv(t *testing.T) {
+	restore := saveClassifyCaps()
+	defer restore()
+	t.Setenv("GATEWAY_CLASSIFY_MAX_ATTEMPT_BYTES", "2048")
+	t.Setenv("GATEWAY_CLASSIFY_MAX_PARTICIPANT_BYTES", "4096")
+	t.Setenv("GATEWAY_CLASSIFY_MAX_GLOBAL_BYTES", "8192")
+
+	configureClassifyCapsFromEnv()
+
+	require.Equal(t, 2048, maxClassifyPartial)
+	require.Equal(t, int64(4096), maxClassifyPartialParticipant)
+	require.Equal(t, int64(8192), maxClassifyPartialGlobal)
+}
+
+// saveClassifyCaps snapshots the tunable caps and returns a restore func.
+func saveClassifyCaps() func() {
+	attempt, participant, global := maxClassifyPartial, maxClassifyPartialParticipant, maxClassifyPartialGlobal
+	return func() {
+		maxClassifyPartial = attempt
+		maxClassifyPartialParticipant = participant
+		maxClassifyPartialGlobal = global
+	}
+}
+
+func mkRaceWriterInflight(t testing.TB) *inflight {
+	t.Helper()
+	return &inflight{
+		hostID:       "fixture-host",
+		escrowID:     "fixture-escrow",
+		nonce:        1,
+		done:         make(chan struct{}),
+		receiptCh:    make(chan struct{}),
+		firstTokenCh: make(chan struct{}),
+		receiptTime:  time.Now(),
+	}
+}
+
+func mkRaceWriter(t testing.TB, inf *inflight) *raceWriter {
+	t.Helper()
+	ctx := context.Background()
+	var sink bytes.Buffer
+	rg := newRaceGroup(ctx, ctx, inf.escrowID, &sink)
+	return &raceWriter{group: rg, nonce: inf.nonce, inf: inf}
+}
diff --git a/devshard/cmd/devshardctl/testutil/testutil.go b/devshard/cmd/devshardctl/testutil/testutil.go
new file mode 100644
index 0000000000..beb9ce5706
--- /dev/null
+++ b/devshard/cmd/devshardctl/testutil/testutil.go
@@ -0,0 +1,20 @@
+// Package testutil holds small assertion helpers shared across devshardctl test
+// packages. It imports "testing" on purpose: it is test-support code (like
+// net/http/httptest) and is only ever linked into _test binaries that import it.
+package testutil
+
+import "testing"
+
+// FloatPtr returns a pointer to v, for building optional float parameters in tests.
+func FloatPtr(v float64) *float64 { return &v }
+
+// MapAt returns items[index] as a map[string]any, failing the test if the element
+// is missing or not a map.
+func MapAt(t *testing.T, items []any, index int) map[string]any {
+	t.Helper()
+	value, ok := items[index].(map[string]any)
+	if !ok {
+		t.Fatalf("items[%d] is not a map: %T", index, items[index])
+	}
+	return value
+}
diff --git a/devshard/cmd/devshardctl/versions_cache.go b/devshard/cmd/devshardctl/versions_cache.go
new file mode 100644
index 0000000000..fd2f25958f
--- /dev/null
+++ b/devshard/cmd/devshardctl/versions_cache.go
@@ -0,0 +1,150 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"maps"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+// mlnodeVersionEntry is one element of the dapi public /v1/versions "mlnodes" list.
+type mlnodeVersionEntry struct {
+	NodeID                 string `json:"node_id"`
+	PoCValidationInference bool   `json:"poc_validation_inference"`
+}
+
+type versionsResponse struct {
+	MLNodes []mlnodeVersionEntry `json:"mlnodes"`
+}
+
+type versionsEntry struct {
+	capableNodes map[string]bool // node_id -> validation-inference capable
+	fetchedAt    time.Time
+}
+
+// VersionsCache polls each candidate miner's dapi /v1/versions in the background
+// and answers, per (miner, node_id), whether that node can serve inference during
+// PoC validation. Fail-closed: unknown miner/node, error, or stale entry -> false.
+type VersionsCache struct {
+	client *http.Client
+	ttl    time.Duration
+
+	mu         sync.RWMutex
+	candidates map[string]string // miner -> dapi base URL (inference_url)
+	entries    map[string]versionsEntry
+	now        func() time.Time
+}
+
+func NewVersionsCache(client *http.Client, ttl time.Duration) *VersionsCache {
+	return &VersionsCache{
+		client:     client,
+		ttl:        ttl,
+		candidates: map[string]string{},
+		entries:    map[string]versionsEntry{},
+		now:        time.Now,
+	}
+}
+
+// SetCandidates replaces the miner->URL set polled on the next pass and drops
+// entries for miners no longer present.
+func (c *VersionsCache) SetCandidates(minerURLs map[string]string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	next := make(map[string]string, len(minerURLs))
+	for miner, u := range minerURLs {
+		if miner == "" || strings.TrimSpace(u) == "" {
+			continue
+		}
+		next[miner] = u
+	}
+	c.candidates = next
+	for miner := range c.entries {
+		if _, ok := next[miner]; !ok {
+			delete(c.entries, miner)
+		}
+	}
+}
+
+// versionsURL builds the dapi public /v1/versions endpoint from a miner's
+// inference base URL (scheme+host[:port]).
+func versionsURL(base string) string {
+	return strings.TrimSuffix(strings.TrimSpace(base), "/") + "/v1/versions"
+}
+
+// Poll runs one pass over the current candidate set.
+func (c *VersionsCache) Poll(ctx context.Context) {
+	c.mu.RLock()
+	candidates := make(map[string]string, len(c.candidates))
+	maps.Copy(candidates, c.candidates)
+	c.mu.RUnlock()
+
+	for miner, base := range candidates {
+		nodes := c.fetchOne(ctx, base)
+		c.mu.Lock()
+		c.entries[miner] = versionsEntry{capableNodes: nodes, fetchedAt: c.now()}
+		c.mu.Unlock()
+	}
+}
+
+// fetchOne returns the per-node capability map, or nil on any error (fail-closed).
+func (c *VersionsCache) fetchOne(ctx context.Context, base string) map[string]bool {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, versionsURL(base), nil)
+	if err != nil {
+		return nil
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		io.Copy(io.Discard, resp.Body)
+		return nil
+	}
+	var parsed versionsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&parsed); err != nil {
+		return nil
+	}
+	nodes := make(map[string]bool, len(parsed.MLNodes))
+	for _, n := range parsed.MLNodes {
+		id := strings.TrimSpace(n.NodeID)
+		if id == "" {
+			continue
+		}
+		nodes[id] = n.PoCValidationInference
+	}
+	return nodes
+}
+
+// IsNodeValidationCapable reports whether the named node of the named miner is
+// currently known to be validation-inference capable and the knowledge is fresh.
+func (c *VersionsCache) IsNodeValidationCapable(miner, nodeID string) bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	entry, ok := c.entries[miner]
+	if !ok || entry.capableNodes == nil {
+		return false
+	}
+	if c.now().Sub(entry.fetchedAt) > c.ttl {
+		return false
+	}
+	return entry.capableNodes[nodeID]
+}
+
+// Run polls on a fixed interval until ctx is cancelled.
+func (c *VersionsCache) Run(ctx context.Context, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			c.Poll(ctx)
+		}
+	}
+}
diff --git a/devshard/cmd/devshardctl/versions_cache_test.go b/devshard/cmd/devshardctl/versions_cache_test.go
new file mode 100644
index 0000000000..516384e5d5
--- /dev/null
+++ b/devshard/cmd/devshardctl/versions_cache_test.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func mlnodesHandler(body string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/versions" {
+			http.Error(w, "bad path", http.StatusNotFound)
+			return
+		}
+		w.Write([]byte(body))
+	}
+}
+
+func TestVersionsCache_PollAndQuery(t *testing.T) {
+	// miner A: node a1 capable, a2 not.
+	srvA := httptest.NewServer(mlnodesHandler(`{"mlnodes":[{"node_id":"a1","poc_validation_inference":true},{"node_id":"a2","poc_validation_inference":false}]}`))
+	defer srvA.Close()
+	// miner B: 404 (old dapi).
+	srvB := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "nope", http.StatusNotFound)
+	}))
+	defer srvB.Close()
+
+	c := NewVersionsCache(&http.Client{Timeout: 2 * time.Second}, time.Minute)
+	c.SetCandidates(map[string]string{"A": srvA.URL, "B": srvB.URL})
+	c.Poll(context.Background())
+
+	if !c.IsNodeValidationCapable("A", "a1") {
+		t.Fatal("A/a1 should be capable")
+	}
+	if c.IsNodeValidationCapable("A", "a2") {
+		t.Fatal("A/a2 should not be capable")
+	}
+	if c.IsNodeValidationCapable("A", "unknownNode") {
+		t.Fatal("unknown node on known miner -> false")
+	}
+	if c.IsNodeValidationCapable("B", "anything") {
+		t.Fatal("B (404) must fail closed")
+	}
+	if c.IsNodeValidationCapable("never", "n") {
+		t.Fatal("never-polled miner must fail closed")
+	}
+}
+
+func TestVersionsCache_StaleFailsClosed(t *testing.T) {
+	srv := httptest.NewServer(mlnodesHandler(`{"mlnodes":[{"node_id":"n1","poc_validation_inference":true}]}`))
+	defer srv.Close()
+
+	c := NewVersionsCache(&http.Client{Timeout: time.Second}, time.Nanosecond) // immediately stale
+	c.SetCandidates(map[string]string{"m": srv.URL})
+	c.Poll(context.Background())
+	time.Sleep(time.Millisecond)
+	if c.IsNodeValidationCapable("m", "n1") {
+		t.Fatal("stale entry must fail closed")
+	}
+}
diff --git a/devshard/docs/host-health.md b/devshard/docs/host-health.md
index 529228103e..c9409b985a 100644
--- a/devshard/docs/host-health.md
+++ b/devshard/docs/host-health.md
@@ -2,41 +2,82 @@
 
 The devshard proxy uses two independent systems to handle misbehaving hosts:
 
-1. **ParticipantRequestLimiter** — hard quarantine, blocks all traffic
+1. **ParticipantRequestLimiter** — automatic probe/shadow quarantine and recovery
 2. **PerfTracker** — soft performance signal, influences speculative decisions
 
 Both are keyed by participant identity (gonka validator address, bech32).
+Automatic quarantine can also be scoped to one or more model IDs, so a host can
+be suppressed for the model it misbehaved on without suppressing the same
+participant for unrelated models.
 
 ## ParticipantRequestLimiter (Quarantine)
 
-A quarantined host receives zero real inference traffic. Nonces that land on
-a quarantined host are burned as silent ghost probes (the MsgStartInference
-is composed locally but no HTTP call is made). The host stays in the nonce
-rotation but is effectively skipped.
+`ParticipantRequestLimiter` tracks temporary health state for participants. A
+single per-model `failure_strikes` counter drives soft failures and probation:
+
+- `0` strikes: healthy, can win.
+- `1` or `2` strikes: probation. Real traffic is sent, but the host is
+  no-winner for the affected model.
+- `>= 3` strikes: quarantine.
+
+There are two automatic quarantine modes:
+
+- **Probe quarantine**: no real inference traffic is sent to the host for the
+  affected model. Nonces that land on the host are burned as silent ghost probes
+  (the `MsgStartInference` is composed locally but no HTTP call is made).
+- **Shadow quarantine**: real inference traffic is still sent for the affected
+  model, but the host is marked no-winner. If it produces content, redundancy
+  escalates so another host can win, and bad attempts still trigger timeout
+  votes/accounting.
+
+The manual suspicious-host endpoint uses the same no-winner behavior as shadow
+quarantine, but it is permanent until removed through the endpoint. Automatic
+quarantine is temporary and expires by wall-clock time.
 
 ### Quarantine triggers
 
-| Trigger | Duration | Path | Details |
-|---|---|---|---|
-| HTTP 429 or 503 | 60 min | any | Host reported overload or rate limit |
-| HTTP 404 on inference | 30 min | `/chat/completions` | Escrow not registered on host |
-| Non-EOF transport failure on inference | 30 min | `/chat/completions` | Dial timeout, connection refused, TLS error |
-| 3 consecutive EOF transport failures on inference | 30 min | `/chat/completions` | EOF-style stream/read failures. Streak resets on quarantine or on a successful inference. |
-| Transport failure on non-inference | none | `/verify-timeout`, `/gossip/*`, etc. | Logged but not quarantined — a flaky vote RPC should not remove an otherwise healthy inference host |
-| 3 consecutive empty streams | 30 min | inference result | Host returns receipt but zero content chunks, three times in a row. Empty streams are only counted when the overall request succeeded via another attempt. Streak resets on quarantine or on a successful inference. |
-| Stalled winner | 30 min | inference result | Host won the race, emitted content, then went silent long enough to trigger the inter-chunk stall timeout (1 min). Immediate quarantine, no streak. |
+| Trigger | Mode | Duration | Scope | Details |
+| --- | --- | ---: | --- | --- |
+| HTTP 429 or 503 | Probe | 60 min | Request model | Host reported overload or rate limit |
+| HTTP 404/403 on inference | Probe | 30 min | Request model | Escrow not registered on host, forbidden, or otherwise unavailable for inference |
+| Timestamp drift HTTP 401 on inference | Probe | 30 min | Request model | Host clock drift exceeds allowed bound |
+| Non-EOF transport failure on inference | Probe | 30 min | Request model | Dial timeout, connection refused, TLS error |
+| 3 soft strikes from EOF transport failures and/or empty streams | Probe or Shadow | 30 min | Request model | EOF-style transport failures use probe quarantine; empty-stream failures use shadow quarantine. Mixed soft failures share the same counter. |
+| Transport failure on non-inference | None | none | none | Logged but not quarantined. A flaky vote RPC should not remove an otherwise healthy inference host. |
+| Empty stream soft strike | Probation, then Shadow at 3 strikes | 30 min at quarantine | Request model | Host returns receipt but zero content chunks. Empty streams are only counted when the overall request succeeded via another attempt. |
+| EOF transport soft strike | Probation, then Probe at 3 strikes | 30 min at quarantine | Request model | EOF-style stream/read failure on inference. |
+| Stalled winner | Shadow | 30 min | Request model | Host won the race, emitted content, then went silent long enough to trigger the inter-chunk stall timeout. Immediate quarantine, no streak. |
+| Manual suspicious host | Shadow/no-winner | no expiration | Participant | Controlled by admin endpoint, persisted separately, cleared only by endpoint removal. |
 
 ### Quarantine behavior
 
-- Tokens are drained to zero on activation.
-- The longer of overlapping quarantines wins (e.g., a 503 during transport quarantine extends to 60 min).
-- State is persisted to `gateway.db` and survives container restarts.
-- When quarantine expires and tokens recover to full burst, the host is removed from tracking entirely (persistent record deleted).
-- A successful inference (`ObserveSuccessfulInference`) clears empty-stream and EOF streaks but does not end an active quarantine early.
+- Probe quarantine drains the participant token bucket to zero for the affected
+  model. `AllowRequest` rejects host calls for that model, and the picker burns
+  ghost probes instead.
+- Shadow quarantine keeps the host callable for the affected model, but
+  `Redundancy` marks attempts as no-winner. This is the same winning behavior as
+  suspicious hosts, but with a temporary expiry.
+- The longer of overlapping quarantines wins (for example, a 503 during a
+  30-minute transport quarantine extends it to 60 minutes).
+- Automatic quarantine state is persisted to `gateway.db` in
+  `participant_throttle_state` and survives container restarts. Persisted state
+  includes `model_ids` and `failure_strikes`; an empty model list means
+  legacy/global quarantine.
+- `quarantine_until_utc` is wall-clock based. If the gateway is down past the
+  expiry, the host does not restart the full timer on boot.
+- When automatic quarantine expires, the participant enters probation with
+  `failure_strikes = 2`. Probation is shadow/no-winner: traffic is still sent,
+  but the host cannot win.
+- A successful inference for the affected model decrements `failure_strikes` by
+  one. At `0`, probation succeeds, the host is removed from tracking, and its
+  persistent automatic-quarantine row is deleted.
+- A soft failure during probation increments the same counter. From the
+  post-quarantine `2` state, one more soft failure reaches `3` and re-enters
+  quarantine.
 
 ### Admin override
 
-```
+```http
 POST /v1/admin/participants/unquarantine
 Content-Type: application/json
 Authorization: Bearer $DEVSHARD_ADMIN_API_KEY
@@ -45,7 +86,8 @@ Authorization: Bearer $DEVSHARD_ADMIN_API_KEY
 ```
 
 Immediately clears quarantine and resets the token bucket. The host becomes
-available for the next nonce that maps to it.
+available for the next nonce that maps to it. This endpoint clears the
+participant's automatic quarantine row; it is not currently model-specific.
 
 ## PerfTracker (Performance Tracking)
 
@@ -64,7 +106,7 @@ challenge-receipt, and other protocol RPCs are invisible to it.
 For each non-probe inference attempt that reaches `race_completed`:
 
 | Field | Source |
-|---|---|
+| --- | --- |
 | `Responsive` | `true` if `resp.ConfirmedAt > 0` AND not an empty stream |
 | `SendTime` | Wall clock when `SendOnly` was called |
 | `ReceiptTime` | Wall clock when `devshard_receipt` SSE event arrived |
@@ -77,7 +119,7 @@ For each non-probe inference attempt that reaches `race_completed`:
 primary dispatch:
 
 | Decision | Condition | Effect |
-|---|---|---|
+| --- | --- | --- |
 | `primary_unresponsive` | `PerfTracker.IsUnresponsive(hostIdx)` — `ResponsiveRate < 0.5` in the rolling window | Start secondary immediately (delay=0) |
 | `secondary_faster` | Secondary host's estimated time is ≥50% faster than primary's | Start secondary immediately (delay=0) |
 | `receipt_timeout` | Default — neither of the above | Start secondary after `ReceiptTimeout` (5s) if no receipt arrives |
@@ -85,13 +127,13 @@ primary dispatch:
 ### Key differences from quarantine
 
 | Property | ParticipantRequestLimiter | PerfTracker |
-|---|---|---|
-| Blocks traffic? | Yes — ghost probe only | No — host still gets real requests |
-| Keyed by | Participant (gonka address) | Host index (slot position) |
-| Scope | All paths (inference, voting, gossip) | Inference only |
+| --- | --- | --- |
+| Blocks traffic? | Probe quarantine: yes. Shadow quarantine/probation: no, but no-winner. | No — host still gets real requests |
+| Keyed by | Participant (gonka address), optionally scoped by model ID | Host index (slot position) |
+| Scope | Inference-path failures for the affected model; manual suspicious is participant-wide | Inference only |
 | Persisted | Yes (gateway.db) | Yes (perf store), but rolling window |
 | Cross-escrow | Yes (process-wide) | No (per-escrow runtime) |
-| Recovery | Time-based (30-60 min) or admin override | Automatic — good samples push out bad ones |
+| Recovery | Time-based (30-60 min), two post-quarantine success decrements, or admin override | Automatic — good samples push out bad ones |
 
 ## Interaction between the two systems
 
@@ -99,11 +141,14 @@ The two systems are independent and can overlap:
 
 - A host can be perf-tracked as unresponsive (triggering immediate secondary
   dispatch) without being quarantined (it still receives real traffic).
-- A quarantined host is invisible to PerfTracker because no inference attempt
-  is made — no sample is recorded.
-- When quarantine ends, PerfTracker has no recent samples for the host, so
-  `IsUnresponsive` returns false (no data = not unresponsive), and the host
-  re-enters the normal `receipt_timeout` decision path.
+- A probe-quarantined host is invisible to PerfTracker for the affected model
+  because no inference attempt is made.
+- A shadow-quarantined or probationary host can still produce PerfTracker
+  samples because it receives real attempts, but it cannot become the winner.
+- When probe quarantine ends, PerfTracker may have no recent samples for the
+  host, so `IsUnresponsive` returns false (no data = not unresponsive), and the
+  host re-enters the normal `receipt_timeout` decision path while probation
+  keeps it no-winner.
 - A host that accumulates bad perf samples but never hits a quarantine trigger
   (e.g., consistently slow but always finishes) will stay in the
   `primary_unresponsive` or `secondary_faster` decision bucket — speculative
@@ -123,7 +168,7 @@ The two systems are independent and can overlap:
 - `participant_limit_stalled_winner_quarantine` — stalled winner
 - `participant_quarantine_cleared` — admin override via unquarantine endpoint
 - `participant_quarantine_ended` — natural expiry
-- `participant_limit_rejected` — request blocked by quarantine
+- `participant_limit_rejected` — request blocked by probe quarantine
 
 ### Performance
 
diff --git a/devshard/docs/inference-lifecycle.md b/devshard/docs/inference-lifecycle.md
index 0113a58445..ba6f569c96 100644
--- a/devshard/docs/inference-lifecycle.md
+++ b/devshard/docs/inference-lifecycle.md
@@ -64,7 +64,7 @@ zero, keeping the wire format bit-identical with
   returning `RequiredValidations` / `CompletedValidations` constantly
   at zero.
 - Host-local **validation observability** (outside the state root, exposed
-  on `GET /v1/devshard/stats/shards/{escrow_id}`) is populated when signed
+  on `GET /devshard/<version>/stats/shards/{escrow_id}`) is populated when signed
   diffs are applied; see
   [validation-observability-diff-apply.md](./validation-observability-diff-apply.md).
 
diff --git a/devshard/docs/protocol-version.md b/devshard/docs/protocol-version.md
index 7566ee617c..9d220ccf5b 100644
--- a/devshard/docs/protocol-version.md
+++ b/devshard/docs/protocol-version.md
@@ -10,9 +10,8 @@ At session bind, storage records this as `CreateSessionParams.Version` / `Sessio
 
 | Surface | Field / API | Value |
 |---------|-------------|--------|
-| Embedded dapi | `HostManager` ctor, `main.go` | `"v1"` → `types.LegacyRouteSessionVersion` |
 | devshardd | `NewHostManager(..., runtimeVersion, ...)` | versiond child name (e.g. from `DEVSHARD_BINARY_VERSION`) |
-| User / devshardctl | `VersionForRoutePrefix(routePrefix)` | `LegacyRouteSessionVersion` for `/v1/devshard`; else `/devshard/<name>` segment |
+| User / devshardctl | `VersionForRoutePrefix(routePrefix)` | `/devshard/<name>` segment |
 | Storage | `sessions.version` | Same bind tag as above |
 
 This tag is **not** hashed into the state root and is **not** sent as `state_root_and_protocol_version` on settlement.
diff --git a/devshard/docs/proxy-architecture.md b/devshard/docs/proxy-architecture.md
index bc9a39c641..e919413266 100644
--- a/devshard/docs/proxy-architecture.md
+++ b/devshard/docs/proxy-architecture.md
@@ -308,19 +308,36 @@ Important relationships:
 
 ### `ParticipantRequestLimiter`
 
-`ParticipantRequestLimiter` is a shared process-wide **reactive** limiter keyed by participant identity (gonka validator address, bech32).
+`ParticipantRequestLimiter` is a shared process-wide **reactive** limiter keyed
+by participant identity (gonka validator address, bech32). Automatic quarantine
+can also be scoped by model ID, so a participant can be suppressed for one model
+without suppressing unrelated models.
 
 It is responsible for:
 
-- quarantining a host after upstream `429`/`503`, transport failures on inference paths, repeated empty streams, or stalled winners
-- applying time-based quarantine (30 min for transport/empty-stream/stalled, 60 min for 429/503)
-- persisting throttle state to `gateway.db` so it survives reboots
-- letting `Gateway` reject escrows whose participant set includes a quarantined host
+- probe-quarantining a host after upstream `429`/`503`, non-EOF inference
+  transport failures, inference `404`/`403`, timestamp drift, or EOF soft
+  failures that raise the unified strike counter to the threshold
+- shadow-quarantining a host after empty-stream soft failures that raise the
+  unified strike counter to the threshold, stalled winners, or during
+  post-quarantine probation
+- applying time-based quarantine (30 min for transport/empty-stream/stalled, 60
+  min for 429/503)
+- persisting throttle state, quarantine mode, expiry, `failure_strikes`, and
+  affected model IDs to `gateway.db` so it survives reboots
+- letting `Gateway` skip escrows whose participants are probe-quarantined for
+  the request model, while shadow-quarantined participants still receive
+  no-winner attempts
 - providing an admin endpoint (`POST /v1/admin/participants/unquarantine`) to manually clear quarantine
 
 Transport failures on non-inference paths (verify-timeout, gossip, etc.) are logged but do **not** trigger quarantine.
 
-Hosts that have never triggered any quarantine signal are **not tracked** and are never rate-limited. When a tracked host's quarantine expires and tokens recover to the full burst value, the host is removed from tracking and its persistent record is deleted.
+Hosts that have never triggered any quarantine signal are **not tracked** and are
+never rate-limited. When a tracked host's quarantine expires, the host enters
+shadow/no-winner probation with two remaining strikes. Each successful
+inference decrements the strike counter; when it reaches zero and tokens are
+recovered, the host is removed from tracking and its persistent record is
+deleted.
 
 See [host-health.md](host-health.md) for the full quarantine trigger table, PerfTracker interaction, and diagnostic log signals.
 
diff --git a/devshard/docs/proxy.md b/devshard/docs/proxy.md
index 552e32888a..0d5a6a977b 100644
--- a/devshard/docs/proxy.md
+++ b/devshard/docs/proxy.md
@@ -147,7 +147,7 @@ Returns current session state.
     "create_devshard_fee": 10000,
     "fee_per_nonce": 1000,
     "vote_threshold": 8,
-    "validation_rate": 5000,
+    "validation_rate": 1000,
     "inference_seal_grace_nonces": 160,
     "inference_seal_grace_seconds": 3600
   }
@@ -243,11 +243,15 @@ curl http://localhost:8080/v1/admin/devshards/42/participants \
 ```
 
 Each participant entry includes `participant_key`, `slot_count`, `tracked`,
-`quarantined`, `blocked`, `request_allowed`, `available_for_capacity`, `tokens`,
-`burst`, and, when quarantined, `quarantine_until` and
-`quarantine_remaining_ms`. `blocked` means the gateway would reject a request to
-that host now; `available_for_capacity` is stricter and only becomes true once
-the host is fully recovered for capacity-weighted routing.
+`quarantined`, `quarantine_mode`, `model_ids`, `shadow_quarantined`,
+`probe_quarantined`, `probationary`, `blocked`, `request_allowed`,
+`available_for_capacity`, `tokens`, `burst`, `failure_strikes`, and, when quarantined,
+`quarantine_until` and `quarantine_remaining_ms`. `blocked` means probe
+quarantine or token exhaustion would reject a real host call now. Shadow
+quarantine and probation still send real attempts, but the host is treated as
+no-winner for the affected model. `model_ids` lists the models affected by the
+automatic quarantine row; an empty list means legacy/global state.
+`failure_strikes` is the unified per-model soft-failure/probation counter.
 
 ### POST /v1/admin/devshards/{id}/settle
 
diff --git a/devshard/docs/storage-design.md b/devshard/docs/storage-design.md
index c7f1591f06..573a9dec26 100644
--- a/devshard/docs/storage-design.md
+++ b/devshard/docs/storage-design.md
@@ -19,12 +19,14 @@ and the operational consequence.
 ```
 HostManager
   -> ManagedStorage
-       -> HybridStorage (thin wrapper)
-            -> exactly one backend chosen at boot:
-                 SQLite  OR  Postgres
+       -> HybridStorage (per-escrow router)
+            -> SQLite only
+            -> Postgres only
+            -> SQLite + Postgres during legacy drain
 ```
 
-`NewStorage` in `devshard/storage/factory.go` picks the backend once per process.
+`NewStorage` in `devshard/storage/factory.go` opens the backend set for the
+process. `HybridStorage` then routes each escrow to the backend that owns it.
 See [Storage mode selection](#storage-mode-selection) and
 [storage-modes-plan.md](./storage-modes-plan.md).
 
@@ -113,26 +115,65 @@ window; if old files accumulate, startup work grows until pruning catches up.
 
 ### Storage Mode Selection
 
-Decision: At boot, `NewStorage` selects **one** backend for the entire process.
-There is no per-request routing and no mid-run fallback between SQLite and
-Postgres.
-
-| Condition | Backend |
-| --- | --- |
-| `escrow_epoch` has rows in `_meta.db` | SQLite (drain transition if `PGHOST` set) |
-| `PGHOST` set and meta empty | Postgres (boot fails if PG unreachable) |
-| `PGHOST` unset, no `.pg-bound` | SQLite (fresh local store) |
-| `.pg-bound` present, `PGHOST` unset | Boot fails (set `PGHOST` or delete `.pg-bound`) |
-
-Postgres-mode boot writes `<storeDir>/.pg-bound`. While SQLite is draining,
-boot logs a WARN when `PGHOST` is set and `escrow_epoch` still has rows.
-
-Why: Dual-backend hybrid routing lost the in-memory route table on reboot and
-could fork append logs when Postgres was briefly down.
-
-Consequence: Postgres outage after boot fails operations on that store; it does
-not silently create sessions in SQLite. SQLite → Postgres promotion happens when
-`escrow_epoch` empties after settle/prune and the process restarts.
+Decision: `NewStorage` returns a per-session router (`HybridStorage`). The
+backend for a **new** escrow is chosen at `CreateSession` time — Postgres when
+`PGHOST` is set, otherwise SQLite. An **existing** escrow is always served by
+whichever backend physically holds it, so a store can serve legacy SQLite
+escrows and new Postgres escrows at the same time.
+
+| Condition | New escrows | Existing escrows |
+| --- | --- | --- |
+| `PGHOST` unset, no `.pg-bound` | SQLite | SQLite |
+| `PGHOST` unset, `.pg-bound` present, no SQLite sessions | Boot fails (would orphan PG sessions) | — |
+| `PGHOST` unset, `.pg-bound` present, SQLite sessions exist | Rejected (WARN: degraded mode) | SQLite-owned only |
+| `PGHOST` set, Postgres reachable, no local SQLite sessions | Postgres | Postgres |
+| `PGHOST` set, Postgres reachable, local SQLite sessions exist | Postgres | SQLite drains in place; Postgres for the rest |
+| `PGHOST` set, Postgres unavailable, local SQLite sessions exist | Rejected while reconnecting (WARN: degraded mode) | SQLite-owned only until PG reconnects |
+| `PGHOST` set, Postgres unavailable, no local SQLite sessions | Rejected while reconnecting (WARN: degraded mode) | None until PG reconnects |
+
+The `.pg-bound` marker tracks whether Postgres currently holds sessions for the
+store, not whether it ever did. Its invariant is: **`<storeDir>/.pg-bound`
+exists whenever Postgres holds at least one session.** It is written ahead of
+each new Postgres `CreateSession` and cleared once a prune drains Postgres to
+zero sessions (a boot-time reconcile also aligns it with reality and removes a
+stale marker left by a fully-drained previous run). The write is held under the
+same lock as the insert so a concurrent prune-driven clear cannot leave a live
+Postgres session unmarked across a crash. Prune-time clearing also proves
+emptiness against `devshard_session_index` before removing the marker, because a
+timed-out create can commit server-side without updating the in-memory index.
+Consequently a store whose Postgres sessions have all settled and pruned can
+boot SQLite-only again without manually deleting the marker; the marker only
+blocks the switch while Postgres sessions still exist.
+
+The router only attaches SQLite when the store has SQLite artifacts and
+`NewSQLite` reconciliation finds SQLite-owned escrows, so a store that has
+always been Postgres never opens `_meta.db`. When it attaches SQLite to drain
+legacy escrows it logs a WARN.
+
+Ownership resolution: the router derives an escrow's backend from each
+backend's own persistent index (SQLite `_meta.db` `escrow_epoch`, Postgres
+`devshard_session_index`) - cached in memory and rebuilt lazily - rather than a
+separate route table. Because `CreateSession` picks exactly one backend and
+never falls back, a given escrow lives in only one backend, so append logs
+cannot fork across backends. If both backends claim the same escrow, the router
+quarantines that escrow with `ErrEscrowBackendConflict` and logs the conflicting
+IDs at boot or promotion. Other escrows keep serving. This protects nodes that
+carry state from an older dual-routing bug or from a manual `.pg-bound` override.
+The earlier design failed because it kept an ephemeral route table that was lost
+on reboot and let the same escrow land in both backends when Postgres was
+briefly down.
+
+Consequence: A Postgres outage while `PGHOST` is set fails new-escrow creation
+(and Postgres-owned operations); the router never silently creates a
+Postgres-destined escrow in SQLite. Boot still succeeds in WARN-logged degraded
+mode, with or without local SQLite sessions. It serves known SQLite escrows,
+rejects new/unknown escrows, and runs a background reconnect loop. Once Postgres
+reconnects, the router logs an INFO, leaves degraded mode, sends new escrows to
+Postgres, and `devshardd` runs another `RecoverSessions()` pass so PG-owned
+active sessions are eagerly restored. Legacy SQLite escrows no longer pin the
+whole process to SQLite - they drain in place as they settle and prune while new
+escrows go straight to Postgres, without waiting for `escrow_epoch` to empty or
+for a restart.
 
 ### Managed Pruning Starts After Recovery
 
diff --git a/devshard/docs/upgrade-impl-notes.md b/devshard/docs/upgrade-impl-notes.md
index 5dd7ed4a05..eabaf310a3 100644
--- a/devshard/docs/upgrade-impl-notes.md
+++ b/devshard/docs/upgrade-impl-notes.md
@@ -1,30 +1,30 @@
 # Devshard Upgrade -- Implementation Notes
 
-Scope: the first versioned release only.
+Scope: the first versioned release and the follow-up legacy route deprecation.
 
 This document is about the temporary implementation we actually ship now. The
 long-term architecture stays in `devshard/docs/upgrade.md`.
 
 ## Current implementation contract
 
-The first versioned release is intentionally small:
+The first versioned release used a dual-route transition:
 
-- `/v1/devshard/*` remains the legacy path served directly by dapi
+- one route was served directly by dapi during the transition
 - `/devshard/<version>/*` is the new path served through
   `proxy -> versiond -> devshardd`
 - `devshardd` is a temporary standalone host binary built out of the
   `decentralized-api/` module
-- `devshardctl` defaults to its release version path and can still override the
-  route prefix for tests or local debugging
+- `devshardctl` defaults to `/devshard/<build-version>` and accepts
+  `DEVSHARD_ROUTE_PREFIX` only as an override for tests or local debugging
 
-The main goal of this release is to prove that the standalone host process can
-run behind versiond while the legacy dapi path continues to work unchanged.
+The main goal was to prove that the standalone host process can run behind
+versiond. Current binaries require clients to use `/devshard/<version>/*`.
 
 Version isolation is strict:
 
 - `/devshard/<version>/*` hosts must talk to other `/devshard/<version>/*`
   hosts
-- `/v1/devshard/*` hosts must talk only to `/v1/devshard/*` hosts
+- transition-era dapi hosts talked only to other dapi hosts
 - the temporary release should not add cross-prefix fallback between those two
   families
 
@@ -32,15 +32,13 @@ Version isolation is strict:
 
 ### Proxy and routing
 
-The proxy exposes two parallel routes:
+The proxy exposes the versioned route:
 
 ```text
-/v1/devshard/*        -> dapi legacy HostManager
 /devshard/<version>/* -> versiond-managed devshardd
 ```
 
-Location ordering matters. `/v1/devshard/*` must continue to hit dapi
-directly. `/devshard/*` is reserved for versiond-routed standalone binaries.
+`/devshard/*` is reserved for versiond-routed standalone binaries.
 
 ### Temporary standalone binary
 
@@ -79,7 +77,7 @@ stamp `devshardd` and `devshardctl` with the same version string.
 
 That same route/binary token is now bound into session state:
 
-- `v1` for the legacy `/v1/devshard/*` path
+- `v1` for sessions created by the transition-era dapi path
 - `<version>` for `/devshard/<version>/*`
 
 Settlement sends the cleartext version to mainnet and also includes it in the
@@ -113,11 +111,8 @@ Versiond-managed runtime state is persisted on the host under `./devshards`:
 
 ### Test shape
 
-Both flows are covered on purpose:
-
-- `DevshardTests.kt` verifies the legacy `/v1/devshard` path
-- `DevshardStandaloneTests.kt` verifies the standalone
-  `/devshard/<version>` path through proxy and versiond in two different modes
+`DevshardStandaloneTests.kt` verifies the standalone `/devshard/<version>` path
+through proxy and versiond in two different modes.
 
 The override-driven tests use `VERSIOND_FORCE=<version>` together with
 `VERSIOND_OVERRIDE_<version>` to run the locally built binary and exercise full
diff --git a/devshard/docs/upgrade.md b/devshard/docs/upgrade.md
index 538dbe1b9c..ebc1b714fc 100644
--- a/devshard/docs/upgrade.md
+++ b/devshard/docs/upgrade.md
@@ -11,15 +11,15 @@ The temporary implementation is tracked separately in
 Devshard binaries version independently of mainnet. Changing the devshard
 runtime should not require cosmovisor or a coordinated full-node upgrade.
 
-The stable client contract is path-based:
+The active client contract is path-based:
 
 ```
-/v1/devshard/*        -> legacy path, served directly by dapi
 /devshard/<version>/* -> versioned path, served by versiond-managed binaries
 ```
 
-The legacy path stays available for backward compatibility while the versioned
-path becomes the normal way to run newer devshard releases.
+Clients must choose a versioned route.
+
+The legacy `/v1/devshard/*` path is deprecated and returns `410 Gone`.
 
 ## Target flow
 
@@ -68,7 +68,6 @@ a version.
 The user chooses a version by selecting the HTTP path at session start:
 
 ```
-/v1/devshard/*        -> dapi, in-process
 /devshard/<version>/* -> versiond -> devshard binary for <version>
 ```
 
@@ -77,8 +76,8 @@ binary version off-chain. Every later diff must continue with that same
 version. A host running the wrong binary refuses to sign, so a version-mixing
 session cannot gather the threshold needed to settle.
 
-The bound version is recorded in shard state. Use `v1` for the legacy path and
-`<version>` for `/devshard/<version>/*`.
+The bound version is recorded in shard state. Use the `<version>` segment from
+`/devshard/<version>/*`.
 
 ## Deprecation
 
diff --git a/devshard/host/host.go b/devshard/host/host.go
index 929e8f3490..7cd9e51e8b 100644
--- a/devshard/host/host.go
+++ b/devshard/host/host.go
@@ -61,8 +61,8 @@ type HostResponse struct {
 	ConfirmedAt        int64  // executor wall-clock timestamp, 0 if not executor
 	Mempool            []*types.DevshardTx
 	ExecutionJob       *devshard.ExecuteRequest // non-nil if this host is the executor and execution is deferred
-	CachedResponseBody []byte // non-nil when reconnecting to a completed inference
-	StreamBytesRead    int64  // total bytes read from the host HTTP response body (SSE streams only)
+	CachedResponseBody []byte                   // non-nil when reconnecting to a completed inference
+	StreamBytesRead    int64                    // total bytes read from the host HTTP response body (SSE streams only)
 	InferenceID        uint64
 	ReceiptExpected    bool
 	ReceiptReason      observability.Reason
@@ -121,6 +121,11 @@ type Host struct {
 	completedResponses map[uint64][]byte // inference ID -> cached ML response body
 	ownSeed            int64             // deterministic seed derived from signer + escrowID
 
+	validationLifecycleMu sync.RWMutex
+	validationStartOnce   sync.Once
+	validationCloseOnce   sync.Once
+	validationClosed      bool
+
 	// Payload prune tracking. These fields are host-local off-state and must
 	// NOT participate in the state root or snapshot. The deterministic seal now
 	// lives in the state machine (autoSealLocked); the host only emits a
@@ -193,33 +198,61 @@ func NewHost(
 	}
 
 	h := &Host{
-		sm:                    sm,
-		signer:                signer,
-		engine:                engine,
-		escrowID:              escrowID,
-		slotIDs:               slotIDs,
-		group:                 group,
-		mempool:               NewMempool(),
-		checker:               checker,
-		slotToAddr:            slotToAddr,
-		addrToSlots:           addrToSlots,
-		sortedSlots:           sortedSlots,
-		executing:             make(map[uint64]struct{}),
-		validating:            make(map[uint64]struct{}),
-		completedResponses:    make(map[uint64][]byte),
-		ownSeed:               ownSeed,
-		prunedFired:           make(map[uint64]struct{}),
+		sm:                 sm,
+		signer:             signer,
+		engine:             engine,
+		escrowID:           escrowID,
+		slotIDs:            slotIDs,
+		group:              group,
+		mempool:            NewMempool(),
+		checker:            checker,
+		slotToAddr:         slotToAddr,
+		addrToSlots:        addrToSlots,
+		sortedSlots:        sortedSlots,
+		executing:          make(map[uint64]struct{}),
+		validating:         make(map[uint64]struct{}),
+		completedResponses: make(map[uint64][]byte),
+		ownSeed:            ownSeed,
+		prunedFired:        make(map[uint64]struct{}),
 	}
 	for _, opt := range opts {
 		opt(h)
 	}
-	if h.validator != nil {
-		h.validationQueue = make(chan validateJob, defaultValidationQueueSize)
-		h.startValidationWorkers(defaultValidationWorkers)
-	}
 	return h, nil
 }
 
+// Start launches background workers owned by this host. Callers should invoke
+// Start only after the host is registered somewhere that will also Close it.
+func (h *Host) Start() {
+	if h.validator == nil {
+		return
+	}
+	h.validationStartOnce.Do(func() {
+		h.validationLifecycleMu.Lock()
+		defer h.validationLifecycleMu.Unlock()
+		if h.validationClosed {
+			return
+		}
+		q := make(chan validateJob, defaultValidationQueueSize)
+		h.validationQueue = q
+		h.startValidationWorkers(q, defaultValidationWorkers)
+	})
+}
+
+// Close releases host-owned background workers. It is safe to call multiple
+// times and safe to call on hosts that were never started.
+func (h *Host) Close() {
+	h.validationCloseOnce.Do(func() {
+		h.validationLifecycleMu.Lock()
+		defer h.validationLifecycleMu.Unlock()
+		h.validationClosed = true
+		if h.validationQueue != nil {
+			close(h.validationQueue)
+			h.validationQueue = nil
+		}
+	})
+}
+
 // HostMempool returns the host's mempool. Use this to construct a
 // StalenessChecker after host creation, then set it via WithChecker option
 // or pass it during construction.
@@ -299,6 +332,7 @@ func (h *Host) MempoolTxs() []*types.DevshardTx {
 }
 
 func (h *Host) EscrowID() string              { return h.escrowID }
+func (h *Host) EpochID() uint64               { return h.epochID }
 func (h *Host) Group() []types.SlotAssignment { return h.group }
 func (h *Host) SlotIDs() map[uint32]bool      { return h.slotIDs }
 
@@ -911,7 +945,11 @@ const (
 // collectValidationJobs finds finished inferences that this host should validate.
 // Caller must hold h.mu.
 func (h *Host) collectValidationJobs() []validateJob {
-	if h.validator == nil || h.validationQueue == nil {
+	h.validationLifecycleMu.RLock()
+	q := h.validationQueue
+	closed := h.validationClosed
+	h.validationLifecycleMu.RUnlock()
+	if h.validator == nil || q == nil || closed {
 		return nil
 	}
 	if !h.completionRequestsEnabled() {
@@ -919,7 +957,7 @@ func (h *Host) collectValidationJobs() []validateJob {
 	}
 
 	st := h.sm.SnapshotState()
-	available := cap(h.validationQueue) - len(h.validationQueue)
+	available := cap(q) - len(q)
 	if available <= 0 {
 		return nil
 	}
@@ -958,10 +996,32 @@ func (h *Host) collectValidationJobs() []validateJob {
 			mySlotCount := uint32(len(h.slotIDs))
 			executorSlotCount := h.sm.AddressSlotCount(executorAddr)
 			totalSlots := h.sm.TotalSlots()
-			if !state.ShouldValidate(h.ownSeed, infID, mySlotCount, executorSlotCount, totalSlots, st.Config.ValidationRate) {
+			rate := st.Config.ValidationRate
+			selected := state.ShouldValidate(h.ownSeed, infID, mySlotCount, executorSlotCount, totalSlots, rate)
+			logging.Debug("validation_rate_sample",
+				"subsystem", "validation",
+				"escrow_id", h.escrowID,
+				"inference_id", infID,
+				"validation_rate", rate,
+				"validator_slot_count", mySlotCount,
+				"executor_slot_count", executorSlotCount,
+				"total_slots", totalSlots,
+				"selected", selected,
+			)
+			if !selected {
 				continue
 			}
 			flow = validationFlowShouldValidate
+		} else {
+			logging.Debug("validation_rate_sample",
+				"subsystem", "validation",
+				"escrow_id", h.escrowID,
+				"inference_id", infID,
+				"validation_rate", st.Config.ValidationRate,
+				"status", uint8(rec.Status),
+				"selected", true,
+				"flow", string(validationFlowChallenged),
+			)
 		}
 
 		validatorSlot := h.sortedSlots[0]
@@ -989,10 +1049,10 @@ func (h *Host) collectValidationJobs() []validateJob {
 	return jobs
 }
 
-func (h *Host) startValidationWorkers(count int) {
+func (h *Host) startValidationWorkers(q <-chan validateJob, count int) {
 	for i := 0; i < count; i++ {
 		go func() {
-			for job := range h.validationQueue {
+			for job := range q {
 				h.validateAsync(context.Background(), job)
 			}
 		}()
@@ -1000,23 +1060,54 @@ func (h *Host) startValidationWorkers(count int) {
 }
 
 func (h *Host) enqueueValidation(job validateJob) {
-	if h.validationQueue == nil {
+	h.validationLifecycleMu.RLock()
+	q := h.validationQueue
+	closed := h.validationClosed
+	if q == nil || closed {
+		h.validationLifecycleMu.RUnlock()
 		h.mu.Lock()
 		delete(h.validating, job.inferenceID)
 		h.mu.Unlock()
+		logging.Debug("validation_enqueued",
+			"subsystem", "validation",
+			"escrow_id", h.escrowID,
+			"inference_id", job.inferenceID,
+			"flow", string(job.flow),
+			"queued", false,
+			"reason", "no_queue",
+		)
 		return
 	}
 
 	select {
-	case h.validationQueue <- job:
+	case q <- job:
 		observability.IncValidation(observability.StageValidationPicked, observability.MetricStatusQueued)
-		observability.SetValidationQueueDepth(h.escrowID, len(h.validationQueue))
+		observability.SetValidationQueueDepth(h.escrowID, len(q))
+		h.validationLifecycleMu.RUnlock()
+		logging.Debug("validation_enqueued",
+			"subsystem", "validation",
+			"escrow_id", h.escrowID,
+			"inference_id", job.inferenceID,
+			"validator_slot", job.validatorSlot,
+			"executor_address", job.executorAddress,
+			"flow", string(job.flow),
+			"queued", true,
+		)
 	default:
+		h.validationLifecycleMu.RUnlock()
 		h.mu.Lock()
 		delete(h.validating, job.inferenceID)
 		h.mu.Unlock()
 		observability.IncValidation(observability.StageValidationPicked, observability.MetricStatusError)
 		observability.IncValidationQueueDrop()
+		logging.Debug("validation_enqueued",
+			"subsystem", "validation",
+			"escrow_id", h.escrowID,
+			"inference_id", job.inferenceID,
+			"flow", string(job.flow),
+			"queued", false,
+			"reason", "queue_full",
+		)
 		observability.Log(context.Background(), observability.LevelWarn, "validation queue full; retry later", observability.StageValidationPicked, observability.WhereHostValidationQueue, h.escrowID, observability.ReasonQueueFull, nil, "inference_id", job.inferenceID)
 	}
 }
@@ -1047,18 +1138,32 @@ func (h *Host) hasMempoolValidationOrVote(infID uint64) bool {
 func (h *Host) validateAsync(ctx context.Context, job validateJob) {
 	ctx, _ = logging.WithRequestID(ctx, fmt.Sprintf("validate-%d", job.inferenceID))
 	observability.IncValidation(observability.StageValidationStarted, observability.MetricStatusOK)
+	st := h.sm.SnapshotState()
 	observability.Log(ctx, observability.LevelInfo, "validation started", observability.StageValidationStarted, observability.WhereHostValidate, h.escrowID, "", nil,
 		"inference_id", job.inferenceID,
 		"executor_address", job.executorAddress,
 		"validator_slot", job.validatorSlot,
-		"validation_flow", string(job.flow))
+		"validation_flow", string(job.flow),
+		"validation_rate", st.Config.ValidationRate)
+	logging.Debug("validation_triggered",
+		"subsystem", "validation",
+		"escrow_id", h.escrowID,
+		"inference_id", job.inferenceID,
+		"validator_slot", job.validatorSlot,
+		"executor_address", job.executorAddress,
+		"flow", string(job.flow),
+		"validation_rate", st.Config.ValidationRate,
+	)
 	defer func() {
 		h.mu.Lock()
 		delete(h.validating, job.inferenceID)
 		h.mu.Unlock()
-		if h.validationQueue != nil {
-			observability.SetValidationQueueDepth(h.escrowID, len(h.validationQueue))
+		h.validationLifecycleMu.RLock()
+		q := h.validationQueue
+		if q != nil {
+			observability.SetValidationQueueDepth(h.escrowID, len(q))
 		}
+		h.validationLifecycleMu.RUnlock()
 	}()
 
 	result, err := h.validator.Validate(ctx, devshard.ValidateRequest{
diff --git a/devshard/host/host_test.go b/devshard/host/host_test.go
index 5556801aa3..1ad8f05959 100644
--- a/devshard/host/host_test.go
+++ b/devshard/host/host_test.go
@@ -1,9 +1,11 @@
 package host
 
 import (
+	"bytes"
 	"context"
 	"crypto/sha256"
 	"fmt"
+	"runtime/pprof"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -22,6 +24,12 @@ import (
 	"devshard/types"
 )
 
+func countValidationWorkerGoroutines() int {
+	var buf bytes.Buffer
+	_ = pprof.Lookup("goroutine").WriteTo(&buf, 2)
+	return bytes.Count(buf.Bytes(), []byte("devshard/host.(*Host).startValidationWorkers.func1"))
+}
+
 // recordingPeer implements gossip.PeerClient and records GossipTxs calls.
 // Used by tests that exercise the host's recovery-gossip trigger.
 type recordingPeer struct {
@@ -1144,6 +1152,56 @@ func (e *blockingValidationEngine) Validate(ctx context.Context, _ devshard.Vali
 	}
 }
 
+func TestHost_NewHostDoesNotStartValidationWorkers(t *testing.T) {
+	hosts := []*signing.Secp256k1Signer{
+		testutil.MustGenerateKey(t),
+		testutil.MustGenerateKey(t),
+		testutil.MustGenerateKey(t),
+	}
+	user := testutil.MustGenerateKey(t)
+	group := testutil.MakeGroup(hosts)
+	config := testutil.DefaultConfig(len(hosts))
+	verifier := signing.NewSecp256k1Verifier()
+	sm, err := state.NewStateMachine("escrow-lifecycle", config, group, 1_000_000, user.Address(), verifier, testutil.MustMemoryStore(t, "escrow-lifecycle", user.Address(), config, group, 1_000_000))
+	require.NoError(t, err)
+
+	before := countValidationWorkerGoroutines()
+	_, err = NewHost(sm, hosts[0], stub.NewInferenceEngine(), "escrow-lifecycle", group, nil,
+		WithValidator(stub.NewValidationEngine()))
+	require.NoError(t, err)
+	require.Equal(t, before, countValidationWorkerGoroutines(), "NewHost must not start validation workers before Start")
+}
+
+func TestHost_StartCloseStopsValidationWorkers(t *testing.T) {
+	hosts := []*signing.Secp256k1Signer{
+		testutil.MustGenerateKey(t),
+		testutil.MustGenerateKey(t),
+		testutil.MustGenerateKey(t),
+	}
+	user := testutil.MustGenerateKey(t)
+	group := testutil.MakeGroup(hosts)
+	config := testutil.DefaultConfig(len(hosts))
+	verifier := signing.NewSecp256k1Verifier()
+	sm, err := state.NewStateMachine("escrow-lifecycle-close", config, group, 1_000_000, user.Address(), verifier, testutil.MustMemoryStore(t, "escrow-lifecycle-close", user.Address(), config, group, 1_000_000))
+	require.NoError(t, err)
+
+	h, err := NewHost(sm, hosts[0], stub.NewInferenceEngine(), "escrow-lifecycle-close", group, nil,
+		WithValidator(stub.NewValidationEngine()))
+	require.NoError(t, err)
+
+	before := countValidationWorkerGoroutines()
+	h.Start()
+	require.Eventually(t, func() bool {
+		return countValidationWorkerGoroutines() >= before+defaultValidationWorkers
+	}, time.Second, 10*time.Millisecond)
+
+	h.Close()
+	h.Close()
+	require.Eventually(t, func() bool {
+		return countValidationWorkerGoroutines() == before
+	}, time.Second, 10*time.Millisecond)
+}
+
 func TestHost_ValidationTriggersOnFinishedInference(t *testing.T) {
 	// 2 hosts. Host 0 is the validator, host 1 is executor for inference 1.
 	// With 2 hosts and 100% ValidationRate, probability = 1/(2-1) = 1.0 (guaranteed).
@@ -1167,6 +1225,8 @@ func TestHost_ValidationTriggersOnFinishedInference(t *testing.T) {
 	h, err := NewHost(sm, hosts[0], engine, "escrow-1", group, nil,
 		WithGrace(10), WithValidator(valEngine), WithEpochID(42))
 	require.NoError(t, err)
+	h.Start()
+	t.Cleanup(h.Close)
 
 	// Nonce 1: StartInference (executor = slot 1, not host 0).
 	diff1 := testutil.SignDiff(t, user, "escrow-1", 1, []*types.DevshardTx{testutil.StartTx(1)})
@@ -1267,6 +1327,8 @@ func TestHost_ValidationQueueLimitsConcurrentWorkers(t *testing.T) {
 	h, err := NewHost(sm, hosts[0], stub.NewInferenceEngine(), "escrow-queue", group, nil,
 		WithGrace(100), WithValidator(validator))
 	require.NoError(t, err)
+	h.Start()
+	t.Cleanup(h.Close)
 
 	var diffs []types.Diff
 	nonce := uint64(1)
diff --git a/devshard/host/prune_test.go b/devshard/host/prune_test.go
index 558fe4258e..82049c8699 100644
--- a/devshard/host/prune_test.go
+++ b/devshard/host/prune_test.go
@@ -95,12 +95,12 @@ func newPruneRigGrace(t *testing.T, observerIdx, numHosts int, sealGraceNonces,
 	// ConfirmedAt progress. ConfirmedAt values in the helpers below advance in
 	// steps larger than 5 so a single newer confirmed inference clears the gate.
 	config := types.SessionConfig{
-		RefusalTimeout:             60,
-		ExecutionTimeout:           1200,
-		TokenPrice:                 1,
-		VoteThreshold:              uint32(numHosts) / 2,
-		ValidationRate:             0,
-		InferenceSealGraceNonces:            sealGraceNonces,
+		RefusalTimeout:            60,
+		ExecutionTimeout:          1200,
+		TokenPrice:                1,
+		VoteThreshold:             uint32(numHosts) / 2,
+		ValidationRate:            0,
+		InferenceSealGraceNonces:  sealGraceNonces,
 		InferenceSealGraceSeconds: clearGraceSeconds,
 		// ValidationRate=0 + no WithValidator means no async validation
 		// will sneak in and emit unrelated mempool entries.
@@ -116,8 +116,7 @@ func newPruneRigGrace(t *testing.T, observerIdx, numHosts int, sealGraceNonces,
 		Group:          group,
 		InitialBalance: 1_000_000,
 	}))
-	sm, err := state.NewStateMachine("escrow-1", config, group, 1_000_000, user.Address(), verifier, store,
-	)
+	sm, err := state.NewStateMachine("escrow-1", config, group, 1_000_000, user.Address(), verifier, store)
 	require.NoError(t, err)
 
 	sink := &recordingPruneSink{}
@@ -450,12 +449,12 @@ func TestHost_PruneSink_NilSafe_NoEmission(t *testing.T) {
 	user := testutil.MustGenerateKey(t)
 	group := testutil.MakeGroup(hosts)
 	config := types.SessionConfig{
-		RefusalTimeout:             60,
-		ExecutionTimeout:           1200,
-		TokenPrice:                 1,
-		VoteThreshold:              2,
-		ValidationRate:             0,
-		InferenceSealGraceNonces:            pruneTestInferenceSealGraceNonces,
+		RefusalTimeout:            60,
+		ExecutionTimeout:          1200,
+		TokenPrice:                1,
+		VoteThreshold:             2,
+		ValidationRate:            0,
+		InferenceSealGraceNonces:  pruneTestInferenceSealGraceNonces,
 		InferenceSealGraceSeconds: pruneTestInferenceSealGraceSeconds,
 	}
 	verifier := signing.NewSecp256k1Verifier()
@@ -500,6 +499,8 @@ func TestHost_ValidateAsync_SkippedDoesNotEnqueueValidation(t *testing.T) {
 	h, err := NewHost(sm, hosts[0], engine, "escrow-1", group, nil,
 		WithGrace(10), WithValidator(skipper), WithEpochID(42))
 	require.NoError(t, err)
+	h.Start()
+	t.Cleanup(h.Close)
 
 	// Start inference 1 (executor = slot 1).
 	rig := &pruneTestRig{
diff --git a/devshard/host/validation_obs_test.go b/devshard/host/validation_obs_test.go
index 44ce63b908..befc327a63 100644
--- a/devshard/host/validation_obs_test.go
+++ b/devshard/host/validation_obs_test.go
@@ -44,7 +44,7 @@ func newObsRig(t *testing.T, store storage.Storage, opts ...HostOption) *obsTest
 		VoteThreshold:    uint32(len(hosts)) / 2,
 		ValidationRate:   0,
 		// Small, explicit seal gates for deterministic auto-seal in tests.
-		InferenceSealGraceNonces:            pruneTestInferenceSealGraceNonces,
+		InferenceSealGraceNonces:  pruneTestInferenceSealGraceNonces,
 		InferenceSealGraceSeconds: pruneTestInferenceSealGraceSeconds,
 	}
 	verifier := signing.NewSecp256k1Verifier()
@@ -483,6 +483,8 @@ func TestHost_ValidateAsync_DoesNotRecordObsBeforeDiff(t *testing.T) {
 	h, err := NewHost(sm, hosts[0], engine, "escrow-1", group, nil,
 		WithStorage(store), WithValidator(valEngine), WithVerifier(verifier))
 	require.NoError(t, err)
+	h.Start()
+	t.Cleanup(h.Close)
 
 	diff1 := testutil.SignDiff(t, user, "escrow-1", 1, []*types.DevshardTx{testutil.StartTx(1)})
 	_, err = h.HandleRequest(context.Background(), HostRequest{Diffs: []types.Diff{diff1}})
@@ -541,6 +543,8 @@ func TestHost_ValidateAsync_RecordsObsAfterDiffApplied(t *testing.T) {
 	h, err := NewHost(sm, hosts[0], engine, "escrow-1", group, nil,
 		WithStorage(store), WithValidator(valEngine), WithVerifier(verifier))
 	require.NoError(t, err)
+	h.Start()
+	t.Cleanup(h.Close)
 
 	diff1 := testutil.SignDiff(t, user, "escrow-1", 1, []*types.DevshardTx{testutil.StartTx(1)})
 	_, err = h.HandleRequest(context.Background(), HostRequest{Diffs: []types.Diff{diff1}})
diff --git a/devshard/internal/testutil/testutil.go b/devshard/internal/testutil/testutil.go
index e6e12cff8e..66cc24ed94 100644
--- a/devshard/internal/testutil/testutil.go
+++ b/devshard/internal/testutil/testutil.go
@@ -58,16 +58,16 @@ func MakeGroup(signers []*signing.Secp256k1Signer) []types.SlotAssignment {
 const TestInferenceSealGraceSeconds uint32 = 1
 
 // DefaultConfig returns a SessionConfig with VoteThreshold = numHosts/2
-// and ValidationRate = 5000 (50%).
+// and the production default ValidationRate.
 func DefaultConfig(numHosts int) types.SessionConfig {
 	return types.NormalizeSessionConfig(types.SessionConfig{
-		RefusalTimeout:             60,
-		ExecutionTimeout:           1200,
-		TokenPrice:                 1,
-		VoteThreshold:              uint32(numHosts) / 2,
-		ValidationRate:             5000,
-		CreateDevshardFee:          0,
-		FeePerNonce:                0,
+		RefusalTimeout:            60,
+		ExecutionTimeout:          1200,
+		TokenPrice:                1,
+		VoteThreshold:             uint32(numHosts) / 2,
+		ValidationRate:            types.DefaultValidationRate,
+		CreateDevshardFee:         0,
+		FeePerNonce:               0,
 		InferenceSealGraceSeconds: TestInferenceSealGraceSeconds,
 	}, numHosts)
 }
diff --git a/devshard/json.go b/devshard/json.go
index 90b969a206..87400eb670 100644
--- a/devshard/json.go
+++ b/devshard/json.go
@@ -6,6 +6,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
+	"strconv"
+	"strings"
 )
 
 // CanonicalizeJSON returns a deterministic JSON encoding with sorted keys and
@@ -41,6 +43,31 @@ func CanonicalPromptHash(prompt []byte) ([]byte, error) {
 	return h[:], nil
 }
 
+// JSONNumericFloat64 converts a JSON-decoded numeric value to float64. Accepts
+// float64, int / int64 / uint64, json.Number, and string (trimmed and parsed)
+// because some clients serialize numerics as strings for fields like
+// temperature / top_p.
+func JSONNumericFloat64(value any) (float64, bool) {
+	switch v := value.(type) {
+	case float64:
+		return v, true
+	case int:
+		return float64(v), true
+	case int64:
+		return float64(v), true
+	case uint64:
+		return float64(v), true
+	case json.Number:
+		number, err := v.Float64()
+		return number, err == nil
+	case string:
+		number, err := strconv.ParseFloat(strings.TrimSpace(v), 64)
+		return number, err == nil
+	default:
+		return 0, false
+	}
+}
+
 // JSONNumericUint64 converts a JSON-decoded numeric value to uint64. Accepts
 // float64 (only when integer-valued and non-negative), int / int64 / uint64,
 // and json.Number. Returns (0, false) for any other type or out-of-range value.
diff --git a/devshard/json_test.go b/devshard/json_test.go
index f5ca5f6cb8..e52736534d 100644
--- a/devshard/json_test.go
+++ b/devshard/json_test.go
@@ -135,6 +135,44 @@ func TestCanonicalPromptHash_StoredPayloadMatchesDirectHash(t *testing.T) {
 		"validator sha256(stored_canonical) must equal user CanonicalPromptHash(original)")
 }
 
+func TestJSONNumericFloat64(t *testing.T) {
+	cases := []struct {
+		name string
+		in   any
+		want float64
+		ok   bool
+	}{
+		{"float64_positive", 1.5, 1.5, true},
+		{"float64_zero", float64(0), 0, true},
+		{"float64_negative", -2.5, -2.5, true},
+		{"int_positive", 7, 7, true},
+		{"int_negative", -3, -3, true},
+		{"int64_positive", int64(42), 42, true},
+		{"uint64", uint64(99), 99, true},
+		{"json_Number_float", json.Number("3.14"), 3.14, true},
+		{"json_Number_integer", json.Number("42"), 42, true},
+		{"json_Number_negative", json.Number("-1.5"), -1.5, true},
+		{"json_Number_garbage", json.Number("abc"), 0, false},
+		{"string_float", "1.5", 1.5, true},
+		{"string_integer", "100", 100, true},
+		{"string_trimmed", "  2.5  ", 2.5, true},
+		{"string_negative", "-0.25", -0.25, true},
+		{"string_invalid", "abc", 0, false},
+		{"string_empty", "", 0, false},
+		{"bool", true, 0, false},
+		{"nil", nil, 0, false},
+		{"slice", []int{1, 2}, 0, false},
+		{"map", map[string]int{"x": 1}, 0, false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got, ok := JSONNumericFloat64(c.in)
+			require.Equal(t, c.ok, ok, "ok mismatch")
+			require.Equal(t, c.want, got, "value mismatch")
+		})
+	}
+}
+
 func TestJSONNumericUint64(t *testing.T) {
 	cases := []struct {
 		name string
diff --git a/devshard/mlnode/client.go b/devshard/mlnode/client.go
index a0d1e947d2..21f8d82f17 100644
--- a/devshard/mlnode/client.go
+++ b/devshard/mlnode/client.go
@@ -2,6 +2,7 @@ package mlnode
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"devshard/nodemanager/gen"
@@ -12,6 +13,18 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+// Sentinel errors returned by Acquire. Callers should use errors.Is / the
+// Is* helpers rather than matching error strings.
+//
+//	ErrNoNodesAvailable — dapi is up but has no free node for the model
+//	                      (stay on the gRPC path; do not fall back).
+//	ErrUnavailable      — node-manager is unreachable (dapi down / transport);
+//	                      fall back to the local ML-node cache.
+var (
+	ErrNoNodesAvailable = errors.New("nodemanager: no nodes available")
+	ErrUnavailable      = errors.New("nodemanager: unavailable")
+)
+
 // Client is a gRPC client for the node-manager NodeManager service.
 type Client struct {
 	conn   *grpc.ClientConn
@@ -49,20 +62,51 @@ func ClientForTest(client gen.NodeManagerClient) *Client {
 
 // Acquire reserves an available ML node for the given model.
 // excludedNodeIDs contains node IDs that failed earlier in the same retry loop.
+//
+// On failure the returned error wraps a sentinel and preserves the gRPC status
+// code so callers can branch with IsNoNodesAvailable / IsUnavailable (or
+// errors.Is / status.Code).
 func (c *Client) Acquire(ctx context.Context, model string, excludedNodeIDs []string) (*gen.AcquireMLNodeResponse, error) {
 	resp, err := c.client.AcquireMLNode(ctx, &gen.AcquireMLNodeRequest{
 		Model:         model,
 		ExcludedNodes: excludedNodeIDs,
 	})
 	if err != nil {
-		if code := status.Code(err); code == codes.ResourceExhausted {
-			return nil, fmt.Errorf("nodemanager: no nodes available for model %q", model)
-		}
-		return nil, fmt.Errorf("nodemanager: acquire: %w", err)
+		return nil, classifyAcquireError(model, err)
 	}
 	return resp, nil
 }
 
+// classifyAcquireError maps a gRPC Acquire failure onto a sentinel while
+// keeping the original status error in the chain (status.Code still works).
+func classifyAcquireError(model string, err error) error {
+	switch status.Code(err) {
+	case codes.ResourceExhausted:
+		return fmt.Errorf("%w for model %q: %w", ErrNoNodesAvailable, model, err)
+	case codes.Unavailable:
+		return fmt.Errorf("%w: %w", ErrUnavailable, err)
+	default:
+		// Non-status transport failures (e.g. connection errors before a
+		// status is attached) are treated as unavailable so callers can fall back.
+		if _, ok := status.FromError(err); !ok {
+			return fmt.Errorf("%w: %w", ErrUnavailable, err)
+		}
+		return fmt.Errorf("nodemanager: acquire: %w", err)
+	}
+}
+
+// IsNoNodesAvailable reports whether err means dapi is reachable but has no
+// free node for the requested model. Callers should stay on the gRPC path.
+func IsNoNodesAvailable(err error) bool {
+	return errors.Is(err, ErrNoNodesAvailable) || status.Code(err) == codes.ResourceExhausted
+}
+
+// IsUnavailable reports whether err means the node-manager is unreachable
+// (dapi down or transport failure). Callers should fall back to the local cache.
+func IsUnavailable(err error) bool {
+	return errors.Is(err, ErrUnavailable) || status.Code(err) == codes.Unavailable
+}
+
 // Release reports the outcome of a completed inference to node-manager.
 func (c *Client) Release(ctx context.Context, lockID string, outcome gen.ReleaseOutcome) error {
 	_, err := c.client.ReleaseMLNode(ctx, &gen.ReleaseMLNodeRequest{
diff --git a/devshard/mlnode/client_test.go b/devshard/mlnode/client_test.go
index 0137a39388..2e8931b1f7 100644
--- a/devshard/mlnode/client_test.go
+++ b/devshard/mlnode/client_test.go
@@ -2,6 +2,8 @@ package mlnode
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"net"
 	"testing"
 
@@ -76,10 +78,14 @@ func TestClient_Acquire_NoNodesAvailable(t *testing.T) {
 	_, err := c.Acquire(context.Background(), "model-a", nil)
 
 	require.Error(t, err)
-	assert.Contains(t, err.Error(), "no nodes available")
+	assert.True(t, errors.Is(err, ErrNoNodesAvailable))
+	assert.True(t, IsNoNodesAvailable(err))
+	assert.False(t, IsUnavailable(err))
+	assert.Equal(t, codes.ResourceExhausted, status.Code(err))
+	assert.Contains(t, err.Error(), "model-a")
 }
 
-func TestClient_Acquire_ServerError(t *testing.T) {
+func TestClient_Acquire_Unavailable(t *testing.T) {
 	srv := &mockServer{
 		acquireFunc: func(_ context.Context, _ *gen.AcquireMLNodeRequest) (*gen.AcquireMLNodeResponse, error) {
 			return nil, status.Error(codes.Unavailable, "queue full")
@@ -90,6 +96,50 @@ func TestClient_Acquire_ServerError(t *testing.T) {
 	_, err := c.Acquire(context.Background(), "model-a", nil)
 
 	require.Error(t, err)
+	assert.True(t, errors.Is(err, ErrUnavailable))
+	assert.True(t, IsUnavailable(err))
+	assert.False(t, IsNoNodesAvailable(err))
+	assert.Equal(t, codes.Unavailable, status.Code(err))
+}
+
+func TestClient_Acquire_OtherStatusPreserved(t *testing.T) {
+	srv := &mockServer{
+		acquireFunc: func(_ context.Context, _ *gen.AcquireMLNodeRequest) (*gen.AcquireMLNodeResponse, error) {
+			return nil, status.Error(codes.Internal, "boom")
+		},
+	}
+
+	c := startMockServer(t, srv)
+	_, err := c.Acquire(context.Background(), "model-a", nil)
+
+	require.Error(t, err)
+	assert.False(t, IsNoNodesAvailable(err))
+	assert.False(t, IsUnavailable(err))
+	assert.Equal(t, codes.Internal, status.Code(err))
+	assert.Contains(t, err.Error(), "nodemanager: acquire")
+}
+
+func TestClassifyAcquireError_NonStatusIsUnavailable(t *testing.T) {
+	err := classifyAcquireError("model-a", errors.New("connection refused"))
+	assert.True(t, errors.Is(err, ErrUnavailable))
+	assert.True(t, IsUnavailable(err))
+	assert.False(t, IsNoNodesAvailable(err))
+}
+
+func TestIsNoNodesAvailable_And_IsUnavailable(t *testing.T) {
+	assert.False(t, IsNoNodesAvailable(nil))
+	assert.False(t, IsUnavailable(nil))
+
+	assert.True(t, IsNoNodesAvailable(ErrNoNodesAvailable))
+	assert.True(t, IsNoNodesAvailable(status.Error(codes.ResourceExhausted, "x")))
+	assert.True(t, IsNoNodesAvailable(fmt.Errorf("wrap: %w", ErrNoNodesAvailable)))
+
+	assert.True(t, IsUnavailable(ErrUnavailable))
+	assert.True(t, IsUnavailable(status.Error(codes.Unavailable, "x")))
+	assert.True(t, IsUnavailable(fmt.Errorf("wrap: %w", ErrUnavailable)))
+
+	assert.False(t, IsNoNodesAvailable(ErrUnavailable))
+	assert.False(t, IsUnavailable(ErrNoNodesAvailable))
 }
 
 func TestClient_Release_AllOutcomes(t *testing.T) {
diff --git a/devshard/mlnode/manager.go b/devshard/mlnode/manager.go
new file mode 100644
index 0000000000..cec817c6d7
--- /dev/null
+++ b/devshard/mlnode/manager.go
@@ -0,0 +1,255 @@
+package mlnode
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// DefaultCacheTTL is the live-flow window. A model counts as actively served
+// when it has a node observed within this span; pruning runs only for such
+// models (see pruneAll).
+const DefaultCacheTTL = 10 * time.Minute
+
+// DefaultStaleTTL is the node-retirement age: an unobserved node is dropped
+// after this long, and only while its model still has a live flow. Must be
+// >= the fresh window.
+const DefaultStaleTTL = time.Hour
+
+// cachedNode is one ML node endpoint learned from a successful Acquire.
+// lastSeen and endpoint are updated atomically so the inference hot path
+// (Observe of an already-known node) never takes a write lock.
+type cachedNode struct {
+	nodeID   string
+	endpoint atomic.Value // string
+	lastSeen atomic.Int64 // unix nano
+}
+
+func (n *cachedNode) setEndpoint(endpoint string) {
+	n.endpoint.Store(endpoint)
+}
+
+func (n *cachedNode) getEndpoint() string {
+	v, _ := n.endpoint.Load().(string)
+	return v
+}
+
+// modelCache holds nodes for a single model. The write lock is taken only to
+// insert a new nodeID or to prune, not on every Observe.
+type modelCache struct {
+	mu     sync.RWMutex
+	nodes  map[string]*cachedNode // nodeID -> node
+	order  []string               // stable round-robin order of nodeIDs
+	cursor atomic.Uint64
+}
+
+// Manager is a passive ML-node cache for standalone devshardd fallback.
+// Observe records nodes from successful AcquireMLNode responses; PickNode
+// selects one when dapi is unreachable.
+//
+// Selection prefers nodes inside staleTTL, then falls back to older retained
+// nodes only when no fresher candidate remains. Pruning is flow-gated (see
+// pruneAll), so the last-known nodes survive an outage of any length.
+//
+// Concurrency:
+//   - Observe of a known node is lock-free (atomic lastSeen/endpoint update).
+//   - Observe of a new node takes only that model's write lock.
+//   - PickNode takes a per-model read lock.
+//   - Prune runs periodically via Start, off the inference hot path.
+type Manager struct {
+	byModel       sync.Map // string -> *modelCache
+	freshTTL      time.Duration
+	staleTTL      time.Duration
+	pruneInterval time.Duration
+	now           func() time.Time
+}
+
+// NewManager returns a Manager whose live-flow window is ttl (DefaultCacheTTL
+// when non-positive). Node-retirement age is DefaultStaleTTL, clamped up to ttl
+// so it is never below the fresh window. Prune interval is ttl/2; call Start to
+// enable pruning.
+func NewManager(ttl time.Duration) *Manager {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	pruneInterval := ttl / 2
+	if pruneInterval <= 0 {
+		pruneInterval = time.Minute
+	}
+	staleTTL := DefaultStaleTTL
+	if staleTTL < ttl {
+		staleTTL = ttl
+	}
+	return &Manager{
+		freshTTL:      ttl,
+		staleTTL:      staleTTL,
+		pruneInterval: pruneInterval,
+		now:           time.Now,
+	}
+}
+
+// Start runs periodic pruning until ctx is cancelled. Without it nothing is
+// pruned; PickNode still serves whatever is cached.
+func (m *Manager) Start(ctx context.Context) {
+	interval := m.pruneInterval
+	go func() {
+		t := time.NewTicker(interval)
+		defer t.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-t.C:
+				m.pruneAll()
+			}
+		}
+	}()
+}
+
+// Observe records (or refreshes) a node endpoint for model from a successful
+// Acquire. Empty model, nodeID, or endpoint are ignored.
+//
+// Hot path (node already cached): atomic updates only, no prune.
+// Cold path (new nodeID): per-model write lock for insert.
+func (m *Manager) Observe(model, nodeID, endpoint string) {
+	if model == "" || nodeID == "" || endpoint == "" {
+		return
+	}
+
+	mc := m.getOrCreateModel(model)
+	nowNano := m.now().UnixNano()
+
+	mc.mu.RLock()
+	node, ok := mc.nodes[nodeID]
+	mc.mu.RUnlock()
+	if ok {
+		node.lastSeen.Store(nowNano)
+		node.setEndpoint(endpoint)
+		return
+	}
+
+	mc.mu.Lock()
+	defer mc.mu.Unlock()
+	if node, ok = mc.nodes[nodeID]; ok {
+		node.lastSeen.Store(nowNano)
+		node.setEndpoint(endpoint)
+		return
+	}
+	node = &cachedNode{nodeID: nodeID}
+	node.lastSeen.Store(nowNano)
+	node.setEndpoint(endpoint)
+	mc.nodes[nodeID] = node
+	mc.order = append(mc.order, nodeID)
+}
+
+// PickNode round-robins the next non-excluded node for model. excluded may be
+// nil; ok is false when none remain. It prefers nodes within staleTTL and
+// serves an older one only when no fresher candidate remains. A past-staleTTL
+// node survives only while the model has no fresh flow (see pruneAll), so an
+// older node is served only during a real outage, not when dapi is merely slow.
+func (m *Manager) PickNode(model string, excluded map[string]struct{}) (endpoint, nodeID string, ok bool) {
+	if model == "" {
+		return "", "", false
+	}
+	v, loaded := m.byModel.Load(model)
+	if !loaded {
+		return "", "", false
+	}
+	mc := v.(*modelCache)
+
+	mc.mu.RLock()
+	defer mc.mu.RUnlock()
+
+	n := len(mc.order)
+	if n == 0 {
+		return "", "", false
+	}
+
+	nowNano := m.now().UnixNano()
+	staleNano := m.staleTTL.Nanoseconds()
+	start := int(mc.cursor.Load() % uint64(n))
+
+	for _, preferFresh := range [2]bool{true, false} {
+		for i := 0; i < n; i++ {
+			idx := (start + i) % n
+			id := mc.order[idx]
+			if excluded != nil {
+				if _, skip := excluded[id]; skip {
+					continue
+				}
+			}
+			node := mc.nodes[id]
+			if node == nil {
+				continue
+			}
+			if preferFresh && nowNano-node.lastSeen.Load() > staleNano {
+				continue
+			}
+			mc.cursor.Store(uint64((idx + 1) % n))
+			return node.getEndpoint(), id, true
+		}
+	}
+	return "", "", false
+}
+
+func (m *Manager) getOrCreateModel(model string) *modelCache {
+	if v, ok := m.byModel.Load(model); ok {
+		return v.(*modelCache)
+	}
+	mc := &modelCache{nodes: make(map[string]*cachedNode)}
+	actual, _ := m.byModel.LoadOrStore(model, mc)
+	return actual.(*modelCache)
+}
+
+// pruneAll drops nodes unobserved for staleTTL, but only from models that still
+// have a fresh observe (within freshTTL). A model with no fresh observe (dapi
+// down or idle) is left intact, so its last-known nodes persist. Runs from the
+// Start ticker, not from Observe/PickNode.
+func (m *Manager) pruneAll() {
+	nowNano := m.now().UnixNano()
+	freshNano := m.freshTTL.Nanoseconds()
+	staleNano := m.staleTTL.Nanoseconds()
+
+	m.byModel.Range(func(_, value any) bool {
+		mc := value.(*modelCache)
+		mc.mu.Lock()
+		if modelHasFreshNode(mc, nowNano, freshNano) {
+			alive := mc.order[:0]
+			for _, id := range mc.order {
+				node := mc.nodes[id]
+				if node == nil {
+					continue
+				}
+				if nowNano-node.lastSeen.Load() > staleNano {
+					delete(mc.nodes, id)
+					continue
+				}
+				alive = append(alive, id)
+			}
+			for i := len(alive); i < len(mc.order); i++ {
+				mc.order[i] = ""
+			}
+			mc.order = alive
+			if len(mc.order) > 0 {
+				mc.cursor.Store(mc.cursor.Load() % uint64(len(mc.order)))
+			} else {
+				mc.cursor.Store(0)
+			}
+		}
+		mc.mu.Unlock()
+		return true
+	})
+}
+
+// modelHasFreshNode reports whether the model has at least one node observed
+// within freshNano. Caller holds mc.mu.
+func modelHasFreshNode(mc *modelCache, nowNano, freshNano int64) bool {
+	for _, id := range mc.order {
+		node := mc.nodes[id]
+		if node != nil && nowNano-node.lastSeen.Load() < freshNano {
+			return true
+		}
+	}
+	return false
+}
diff --git a/devshard/mlnode/manager_test.go b/devshard/mlnode/manager_test.go
new file mode 100644
index 0000000000..b6f519e373
--- /dev/null
+++ b/devshard/mlnode/manager_test.go
@@ -0,0 +1,364 @@
+package mlnode
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewManager_Defaults(t *testing.T) {
+	m := NewManager(0)
+	assert.Equal(t, DefaultCacheTTL, m.freshTTL)
+	assert.Equal(t, DefaultStaleTTL, m.staleTTL)
+	assert.Equal(t, DefaultCacheTTL/2, m.pruneInterval)
+
+	m = NewManager(-time.Second)
+	assert.Equal(t, DefaultCacheTTL, m.freshTTL)
+	assert.Equal(t, DefaultStaleTTL, m.staleTTL)
+
+	m = NewManager(time.Minute)
+	assert.Equal(t, time.Minute, m.freshTTL)
+	assert.Equal(t, 30*time.Second, m.pruneInterval)
+	assert.Equal(t, DefaultStaleTTL, m.staleTTL)
+
+	// staleTTL is clamped up so it is never below the fresh window.
+	m = NewManager(2 * time.Hour)
+	assert.Equal(t, 2*time.Hour, m.freshTTL)
+	assert.Equal(t, 2*time.Hour, m.staleTTL)
+}
+
+func TestManager_Observe_InsertsAndRefreshes(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	m := NewManager(time.Hour)
+	m.now = func() time.Time { return now }
+
+	m.Observe("model-a", "node-1", "http://n1/v1")
+	endpoint, nodeID, ok := m.PickNode("model-a", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", nodeID)
+	assert.Equal(t, "http://n1/v1", endpoint)
+
+	// Same node_id updates endpoint and lastSeen without growing the cache.
+	now = now.Add(time.Minute)
+	m.Observe("model-a", "node-1", "http://n1/v2")
+	endpoint, nodeID, ok = m.PickNode("model-a", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", nodeID)
+	assert.Equal(t, "http://n1/v2", endpoint)
+
+	mc := loadModel(t, m, "model-a")
+	mc.mu.RLock()
+	require.Len(t, mc.nodes, 1)
+	assert.Equal(t, now.UnixNano(), mc.nodes["node-1"].lastSeen.Load())
+	mc.mu.RUnlock()
+}
+
+func TestManager_Observe_IgnoresEmptyFields(t *testing.T) {
+	m := NewManager(time.Hour)
+	m.Observe("", "node-1", "http://n1")
+	m.Observe("model-a", "", "http://n1")
+	m.Observe("model-a", "node-1", "")
+
+	_, _, ok := m.PickNode("model-a", nil)
+	assert.False(t, ok)
+}
+
+func TestManager_Observe_KnownNodeIsLockFree(t *testing.T) {
+	// Concurrent Observe of an already-known node must not deadlock and must
+	// refresh lastSeen. This is the inference hot path.
+	now := time.Unix(1_700_000_000, 0)
+	var nowMu sync.Mutex
+	m := NewManager(time.Hour)
+	m.now = func() time.Time {
+		nowMu.Lock()
+		defer nowMu.Unlock()
+		return now
+	}
+
+	m.Observe("model-a", "node-1", "http://n1")
+
+	var wg sync.WaitGroup
+	for range 32 {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for range 100 {
+				nowMu.Lock()
+				now = now.Add(time.Nanosecond)
+				nowMu.Unlock()
+				m.Observe("model-a", "node-1", "http://n1")
+			}
+		}()
+	}
+	wg.Wait()
+
+	mc := loadModel(t, m, "model-a")
+	mc.mu.RLock()
+	require.Len(t, mc.nodes, 1)
+	assert.Greater(t, mc.nodes["node-1"].lastSeen.Load(), time.Unix(1_700_000_000, 0).UnixNano())
+	mc.mu.RUnlock()
+}
+
+func TestManager_PickNode_RoundRobin(t *testing.T) {
+	m := NewManager(time.Hour)
+	m.now = func() time.Time { return time.Unix(1_700_000_000, 0) }
+
+	m.Observe("model-a", "node-1", "http://n1")
+	m.Observe("model-a", "node-2", "http://n2")
+	m.Observe("model-a", "node-3", "http://n3")
+
+	got := make([]string, 0, 6)
+	for range 6 {
+		_, nodeID, ok := m.PickNode("model-a", nil)
+		require.True(t, ok)
+		got = append(got, nodeID)
+	}
+	assert.Equal(t, []string{"node-1", "node-2", "node-3", "node-1", "node-2", "node-3"}, got)
+}
+
+func TestManager_PickNode_Exclusion(t *testing.T) {
+	m := NewManager(time.Hour)
+	m.now = func() time.Time { return time.Unix(1_700_000_000, 0) }
+
+	m.Observe("model-a", "node-1", "http://n1")
+	m.Observe("model-a", "node-2", "http://n2")
+	m.Observe("model-a", "node-3", "http://n3")
+
+	excluded := map[string]struct{}{"node-1": {}, "node-3": {}}
+	endpoint, nodeID, ok := m.PickNode("model-a", excluded)
+	require.True(t, ok)
+	assert.Equal(t, "node-2", nodeID)
+	assert.Equal(t, "http://n2", endpoint)
+
+	// All excluded -> no candidate.
+	excluded["node-2"] = struct{}{}
+	_, _, ok = m.PickNode("model-a", excluded)
+	assert.False(t, ok)
+}
+
+func TestManager_PickNode_RoundRobinSkipsExcluded(t *testing.T) {
+	m := NewManager(time.Hour)
+	m.now = func() time.Time { return time.Unix(1_700_000_000, 0) }
+
+	m.Observe("model-a", "node-1", "http://n1")
+	m.Observe("model-a", "node-2", "http://n2")
+	m.Observe("model-a", "node-3", "http://n3")
+
+	// Advance past node-1 so cursor points at node-2.
+	_, id, ok := m.PickNode("model-a", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", id)
+
+	// Exclude node-2; next pick should be node-3, then wrap to node-1.
+	excluded := map[string]struct{}{"node-2": {}}
+	_, id, ok = m.PickNode("model-a", excluded)
+	require.True(t, ok)
+	assert.Equal(t, "node-3", id)
+
+	_, id, ok = m.PickNode("model-a", excluded)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", id)
+}
+
+func TestManager_PerModelIsolation(t *testing.T) {
+	m := NewManager(time.Hour)
+	m.now = func() time.Time { return time.Unix(1_700_000_000, 0) }
+
+	m.Observe("model-a", "node-1", "http://a1")
+	m.Observe("model-b", "node-2", "http://b2")
+
+	_, id, ok := m.PickNode("model-a", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", id)
+
+	_, id, ok = m.PickNode("model-b", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-2", id)
+
+	_, _, ok = m.PickNode("model-c", nil)
+	assert.False(t, ok)
+}
+
+func TestManager_PickNode_ServesStaleNode(t *testing.T) {
+	// PickNode is only reached during a dapi outage, so age must not gate
+	// selection: a long-idle last-known node is still served.
+	now := time.Unix(1_700_000_000, 0)
+	m := NewManager(time.Minute)
+	m.staleTTL = 2 * time.Minute
+	m.now = func() time.Time { return now }
+
+	m.Observe("model-a", "node-1", "http://n1")
+
+	now = now.Add(time.Hour) // far past both windows, and no prune ran
+	endpoint, nodeID, ok := m.PickNode("model-a", nil)
+	require.True(t, ok)
+	assert.Equal(t, "node-1", nodeID)
+	assert.Equal(t, "http://n1", endpoint)
+}
+
+func TestManager_PickNode_PrefersFreshOverStale(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	m := NewManager(time.Minute) // freshTTL
+	m.staleTTL = 2 * time.Minute
+	m.now = func() time.Time { return now }
+
+	m.Observe("model-a", "node-stale", "http://stale")
+	now = now.Add(3 * time.Minute) // node-stale is now past staleTTL
+	m.Observe("model-a", "node-fresh", "http://fresh")
+
+	// The stale node is never served while a fresher one exists, even as
+	// round-robin cycles.
+	for range 3 {
+		_, id, ok := m.PickNode("model-a", nil)
+		require.True(t, ok)
+		assert.Equal(t, "node-fresh", id)
+	}
+}
+
+func TestManager_PickNode_ServesStaleWhenFreshExcluded(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	m := NewManager(time.Minute)
+	m.staleTTL = 2 * time.Minute
+	m.now = func() time.Time { return now }
+
+	m.Observe("model-a", "node-stale", "http://stale")
+	now = now.Add(3 * time.Minute)
+	m.Observe("model-a", "node-fresh", "http://fresh")
+
+	// With the only fresh node excluded, the second pass serves the stale one.
+	excluded := map[string]struct{}{"node-fresh": {}}
+	_, id, ok := m.PickNode("model-a", excluded)
+	require.True(t, ok)
+	assert.Equal(t, "node-stale", id)
+}
+
+func TestManager_PruneAll_DropsStaleWhenFlowPresent(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	m := NewManager(time.Minute) // freshTTL
+	m.staleTTL = 5 * time.Minute
+	m.now = func() time.Time { return now }
+
+	m.Observe("model-a", "node-old", "http://old")
+
+	// node-old ages past staleTTL; node-fresh proves the model is still churning.
+	now = now.Add(6 * time.Minute)
+	m.Observe("model-a", "node-fresh", "http://fresh")
+
+	m.pruneAll()
+
+	mc := loadModel(t, m, "model-a")
+	mc.mu.RLock()
+	_, hasOld := mc.nodes["node-old"]
+	_, hasFresh := mc.nodes["node-fresh"]
+	mc.mu.RUnlock()
+	assert.False(t, hasOld, "stale node dropped once a fresh observe proves live flow")
+	assert.True(t, hasFresh)
+}
+
+func TestManager_PruneAll_RetainsWhenNoFlow(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	m := NewManager(time.Minute) // freshTTL
+	m.staleTTL = 5 * time.Minute
+	m.now = func() time.Time { return now }
+
+	m.Observe("model-a", "node-1", "http://n1")
+	m.Observe("model-a", "node-2", "http://n2")
+
+	// dapi down: no more observes. Advance far past both windows.
+	now = now.Add(time.Hour)
+	m.pruneAll()
+
+	mc := loadModel(t, m, "model-a")
+	mc.mu.RLock()
+	require.Len(t, mc.nodes, 2, "no live flow -> nothing pruned; last-known set retained")
+	mc.mu.RUnlock()
+
+	// The retained nodes are still selectable for fallback.
+	_, _, ok := m.PickNode("model-a", nil)
+	assert.True(t, ok)
+}
+
+func TestManager_Start_RetainsWithoutFlow(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	var nowMu sync.Mutex
+	m := NewManager(50 * time.Millisecond)
+	m.staleTTL = 100 * time.Millisecond
+	m.pruneInterval = 20 * time.Millisecond
+	m.now = func() time.Time {
+		nowMu.Lock()
+		defer nowMu.Unlock()
+		return now
+	}
+
+	m.Observe("model-a", "node-1", "http://n1")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	m.Start(ctx)
+
+	nowMu.Lock()
+	now = now.Add(time.Second) // far past fresh and stale windows
+	nowMu.Unlock()
+
+	// Prune ticks keep running, but with no fresh observe the model is never
+	// pruned away.
+	require.Never(t, func() bool {
+		_, exists := m.byModel.Load("model-a")
+		return !exists
+	}, 200*time.Millisecond, 20*time.Millisecond)
+}
+
+func TestManager_Start_PrunesStaleWithFlow(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	var nowMu sync.Mutex
+	m := NewManager(50 * time.Millisecond)
+	m.staleTTL = 100 * time.Millisecond
+	m.pruneInterval = 20 * time.Millisecond
+	m.now = func() time.Time {
+		nowMu.Lock()
+		defer nowMu.Unlock()
+		return now
+	}
+
+	m.Observe("model-a", "node-old", "http://old")
+
+	nowMu.Lock()
+	now = now.Add(200 * time.Millisecond) // node-old is now stale
+	nowMu.Unlock()
+	m.Observe("model-a", "node-fresh", "http://fresh") // live flow
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	m.Start(ctx)
+
+	// A live flow lets the ticker drop the stale node while keeping the fresh one.
+	require.Eventually(t, func() bool {
+		v, ok := m.byModel.Load("model-a")
+		if !ok {
+			return false
+		}
+		mc := v.(*modelCache)
+		mc.mu.RLock()
+		defer mc.mu.RUnlock()
+		_, hasOld := mc.nodes["node-old"]
+		_, hasFresh := mc.nodes["node-fresh"]
+		return !hasOld && hasFresh
+	}, time.Second, 10*time.Millisecond)
+}
+
+func TestManager_PickNode_EmptyModel(t *testing.T) {
+	m := NewManager(time.Hour)
+	_, _, ok := m.PickNode("", nil)
+	assert.False(t, ok)
+}
+
+func loadModel(t *testing.T, m *Manager, model string) *modelCache {
+	t.Helper()
+	v, ok := m.byModel.Load(model)
+	require.True(t, ok)
+	return v.(*modelCache)
+}
diff --git a/devshard/observability/ctx.go b/devshard/observability/ctx.go
index 7b3ec489f8..17988c3461 100644
--- a/devshard/observability/ctx.go
+++ b/devshard/observability/ctx.go
@@ -101,7 +101,6 @@ const (
 	ReasonSignVoteErr                 Reason = "sign_vote_err"
 	ReasonValidationStatusChanged     Reason = "validation_status_changed"
 	ReasonPartialResponseInterrupted  Reason = "partial_response_after_interruption"
-	ReasonApplicationErr              Reason = "application_err"
 	ReasonTransportErr                Reason = "transport_err"
 	ReasonTimeout                     Reason = "timeout"
 	ReasonHTTP5xx                     Reason = "http_5xx"
diff --git a/devshard/observability/metrics_lifecycle.go b/devshard/observability/metrics_lifecycle.go
index 744a77ea60..bad4a85a81 100644
--- a/devshard/observability/metrics_lifecycle.go
+++ b/devshard/observability/metrics_lifecycle.go
@@ -256,6 +256,12 @@ func SetMempoolSize(escrowID string, size int) {
 	mempoolSize.WithLabelValues(escrowID).Set(float64(size))
 }
 
+func DeleteEscrowMetrics(escrowID string) {
+	ensureMetrics()
+	validationQueueDepth.DeleteLabelValues(escrowID)
+	mempoolSize.DeleteLabelValues(escrowID)
+}
+
 func SetBuildInfo(binary, version, commit string) {
 	ensureMetrics()
 	buildInfo.WithLabelValues(binary, version, commit).Set(1)
diff --git a/devshard/paths.go b/devshard/paths.go
index 196977d7a5..f7cdf5b377 100644
--- a/devshard/paths.go
+++ b/devshard/paths.go
@@ -3,97 +3,40 @@ package devshard
 import (
 	"fmt"
 	"strings"
-
-	"devshard/types"
-)
-
-const (
-	LegacyRoutePrefix = "/v1/devshard"
 )
 
 func VersionedRoutePrefix(version string) string {
 	return "/devshard/" + version
 }
 
-func NormalizeRoutePrefix(routePrefix string) string {
-	if routePrefix == "" {
-		return LegacyRoutePrefix
-	}
-	return routePrefix
-}
-
-func ResolveVersionedRoutePrefix(version, routePrefix string) string {
-	if routePrefix != "" {
-		return routePrefix
+// VersionForRoutePrefix maps a versioned HTTP route prefix to the runtime tag
+// used when creating a user-side session.
+func ResolveRoutePrefix(routePrefix string) (string, string, error) {
+	normalized := strings.TrimRight(strings.TrimSpace(routePrefix), "/")
+	if !strings.HasPrefix(normalized, "/") {
+		return "", "", fmt.Errorf("unsupported devshard route prefix %q", routePrefix)
 	}
-	return VersionedRoutePrefix(version)
-}
-
-// VersionForRoutePrefix maps an HTTP route prefix to the version tag used when
-// creating a user-side session (state machine + optional SQLite row). This is
-// not the same as the URL path alone:
-//
-//   - LegacyRoutePrefix (/v1/devshard): session tag is types.LegacyRouteSessionVersion
-//     ("v1"), matching embedded dapi HostManager boundVersion (gm/microrelease
-//     used types.LegacySessionVersion for the same value).
-//   - VersionedRoutePrefix (/devshard/<name>): <name> is the versiond runtime
-//     name (must match the host's boundVersion and storage session pin).
-//
-// HTTP clients still use routePrefix on transport.HTTPClient; this function
-// only resolves the session/storage tag. See devshard/docs/protocol-version.md.
-
-func ProtocolRouteVersion(protocol types.ProtocolVersion) string {
-	if protocol == "" {
-		protocol = types.ProtocolV1
-	}
-	version := string(protocol)
-	if strings.HasPrefix(version, "v") {
-		return version
-	}
-	return "v" + version
-}
-
-func ProtocolSessionVersion(protocol types.ProtocolVersion) string {
-	if protocol == "" {
-		protocol = types.ProtocolV1
+	parts := strings.Split(strings.TrimPrefix(normalized, "/"), "/")
+	if len(parts) == 2 && parts[0] == "devshard" && parts[1] != "" {
+		return normalized, parts[1], nil
 	}
-	return ProtocolRouteVersion(protocol)
-}
 
-func ResolveHostRoutePrefix(protocol types.ProtocolVersion, routePrefix string) string {
-	if routePrefix != "" {
-		return routePrefix
-	}
-	if protocol == types.ProtocolV1 {
-		return LegacyRoutePrefix
-	}
-	return VersionedRoutePrefix(ProtocolRouteVersion(protocol))
+	return "", "", fmt.Errorf("unsupported devshard route prefix %q", routePrefix)
 }
 
 func VersionForRoutePrefix(routePrefix string) (string, error) {
-	normalized := NormalizeRoutePrefix(routePrefix)
-	if normalized == LegacyRoutePrefix {
-		return types.LegacyRouteSessionVersion, nil
+	_, version, err := ResolveRoutePrefix(routePrefix)
+	if err != nil {
+		return "", err
 	}
-
-	trimmed := strings.Trim(normalized, "/")
-	parts := strings.Split(trimmed, "/")
-	if len(parts) == 2 && parts[0] == "devshard" && parts[1] != "" {
-		return parts[1], nil
-	}
-
-	return "", fmt.Errorf("unsupported devshard route prefix %q", routePrefix)
+	return version, nil
 }
 
 func SessionPayloadPath(routePrefix, escrowID string) string {
-	normalized := strings.TrimPrefix(NormalizeRoutePrefix(routePrefix), "/")
+	normalized := strings.TrimPrefix(routePrefix, "/")
 	return fmt.Sprintf("%s/sessions/%s/payloads", normalized, escrowID)
 }
 
-func LegacySessionPayloadPath(escrowID string) string {
-	return SessionPayloadPath(LegacyRoutePrefix, escrowID)
-}
-
 func VersionedSessionPayloadPath(version, escrowID string) string {
 	return SessionPayloadPath(VersionedRoutePrefix(version), escrowID)
 }
diff --git a/devshard/paths_test.go b/devshard/paths_test.go
index b6a535a3f0..6ca6ae5ae2 100644
--- a/devshard/paths_test.go
+++ b/devshard/paths_test.go
@@ -1,46 +1,6 @@
 package devshard
 
-import (
-	"testing"
-
-	"devshard/types"
-)
-
-func TestNormalizeRoutePrefixDefaultsToLegacy(t *testing.T) {
-	if got := NormalizeRoutePrefix(""); got != LegacyRoutePrefix {
-		t.Fatalf("NormalizeRoutePrefix(\"\") = %q, want %q", got, LegacyRoutePrefix)
-	}
-}
-
-func TestResolveVersionedRoutePrefix(t *testing.T) {
-	if got := ResolveVersionedRoutePrefix("v1", ""); got != VersionedRoutePrefix("v1") {
-		t.Fatalf("ResolveVersionedRoutePrefix(\"v1\", \"\") = %q, want %q", got, VersionedRoutePrefix("v1"))
-	}
-	if got := ResolveVersionedRoutePrefix("v1", LegacyRoutePrefix); got != LegacyRoutePrefix {
-		t.Fatalf("ResolveVersionedRoutePrefix override = %q, want %q", got, LegacyRoutePrefix)
-	}
-}
-
-func TestResolveHostRoutePrefix(t *testing.T) {
-	if got := ResolveHostRoutePrefix(types.ProtocolV1, ""); got != LegacyRoutePrefix {
-		t.Fatalf("ResolveHostRoutePrefix(v1) = %q, want %q", got, LegacyRoutePrefix)
-	}
-	if got := ResolveHostRoutePrefix(types.ProtocolV1, LegacyRoutePrefix); got != LegacyRoutePrefix {
-		t.Fatalf("ResolveHostRoutePrefix override = %q, want %q", got, LegacyRoutePrefix)
-	}
-}
-
-func TestProtocolSessionVersion(t *testing.T) {
-	if got := ProtocolSessionVersion(types.ProtocolV1); got != "v1" {
-		t.Fatalf("ProtocolSessionVersion(v1) = %q, want %q", got, "v1")
-	}
-	if got := ProtocolSessionVersion("v1"); got != "v1" {
-		t.Fatalf("ProtocolSessionVersion(route-style v1) = %q, want %q", got, "v1")
-	}
-	if got := ProtocolSessionVersion(""); got != "v1" {
-		t.Fatalf("ProtocolSessionVersion(\"\") = %q, want %q", got, "v1")
-	}
-}
+import "testing"
 
 func TestVersionForRoutePrefix(t *testing.T) {
 	tests := []struct {
@@ -50,14 +10,9 @@ func TestVersionForRoutePrefix(t *testing.T) {
 		wantErr     bool
 	}{
 		{
-			name:        "default legacy",
+			name:        "empty route rejected",
 			routePrefix: "",
-			want:        "v1",
-		},
-		{
-			name:        "explicit legacy",
-			routePrefix: LegacyRoutePrefix,
-			want:        "v1",
+			wantErr:     true,
 		},
 		{
 			name:        "old subnet host route rejected",
@@ -95,19 +50,75 @@ func TestVersionForRoutePrefix(t *testing.T) {
 	}
 }
 
-func TestSessionPayloadPath(t *testing.T) {
+func TestResolveRoutePrefix(t *testing.T) {
 	tests := []struct {
 		name        string
 		routePrefix string
-		escrowID    string
-		want        string
+		wantPrefix  string
+		wantVersion string
+		wantErr     bool
 	}{
 		{
-			name:        "legacy",
+			name:        "versioned",
+			routePrefix: "/devshard/v2",
+			wantPrefix:  "/devshard/v2",
+			wantVersion: "v2",
+		},
+		{
+			name:        "trims whitespace and trailing slash",
+			routePrefix: " /devshard/dev/ ",
+			wantPrefix:  "/devshard/dev",
+			wantVersion: "dev",
+		},
+		{
+			name:        "empty route rejected",
 			routePrefix: "",
-			escrowID:    "1",
-			want:        "v1/devshard/sessions/1/payloads",
+			wantErr:     true,
+		},
+		{
+			name:        "legacy route rejected",
+			routePrefix: "/v1/devshard",
+			wantErr:     true,
+		},
+		{
+			name:        "missing version rejected",
+			routePrefix: "/devshard",
+			wantErr:     true,
+		},
+		{
+			name:        "nested version rejected",
+			routePrefix: "/devshard/v2/extra",
+			wantErr:     true,
 		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotPrefix, gotVersion, err := ResolveRoutePrefix(tt.routePrefix)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatalf("ResolveRoutePrefix(%q) error = nil, want non-nil", tt.routePrefix)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("ResolveRoutePrefix(%q) error = %v", tt.routePrefix, err)
+			}
+			if gotPrefix != tt.wantPrefix || gotVersion != tt.wantVersion {
+				t.Fatalf("ResolveRoutePrefix(%q) = (%q, %q), want (%q, %q)",
+					tt.routePrefix, gotPrefix, gotVersion, tt.wantPrefix, tt.wantVersion)
+			}
+		})
+	}
+}
+
+func TestSessionPayloadPath(t *testing.T) {
+	tests := []struct {
+		name        string
+		routePrefix string
+		escrowID    string
+		want        string
+	}{
 		{
 			name:        "versioned",
 			routePrefix: VersionedRoutePrefix("v1"),
diff --git a/devshard/protocol/http_test.go b/devshard/protocol/http_test.go
index ef8e01d329..86c3d89496 100644
--- a/devshard/protocol/http_test.go
+++ b/devshard/protocol/http_test.go
@@ -36,6 +36,14 @@ type httpTestEnv struct {
 	gossips     []*gossip.Gossip
 }
 
+const httpTestRoutePrefix = "/devshard/test"
+
+func httpTestClient(baseURL string, escrowID string, signer signing.Signer) *transport.HTTPClient {
+	cfg := transport.DefaultClientConfig()
+	cfg.RoutePrefix = httpTestRoutePrefix
+	return transport.NewHTTPClient(baseURL, escrowID, signer, cfg)
+}
+
 // setupHTTPEnv creates a full HTTP test environment with storage, gossip,
 // sig accumulation, and mempool sink wired together.
 // Optional cfgs override the default SessionConfig.
@@ -82,7 +90,7 @@ func setupHTTPEnv(t *testing.T, numHosts int, balance, grace uint64, cfgs ...typ
 		servers[i] = srv
 
 		e := echo.New()
-		g := e.Group("/v1/devshard")
+		g := e.Group(httpTestRoutePrefix)
 		srv.Register(g)
 		ts := httptest.NewServer(e)
 		t.Cleanup(ts.Close)
@@ -94,10 +102,10 @@ func setupHTTPEnv(t *testing.T, numHosts int, balance, grace uint64, cfgs ...typ
 	hostClients := make([]*transport.HTTPClient, numHosts)
 	userClients := make([]user.HostClient, numHosts)
 	for i := range httpServers {
-		c := transport.NewHTTPClient(httpServers[i].URL, "escrow-1", userSigner)
+		c := httpTestClient(httpServers[i].URL, "escrow-1", userSigner)
 		clients[i] = c
 		userClients[i] = c
-		hostClients[i] = transport.NewHTTPClient(httpServers[i].URL, "escrow-1", hostSigners[i])
+		hostClients[i] = httpTestClient(httpServers[i].URL, "escrow-1", hostSigners[i])
 	}
 
 	// Wire peer clients for timeout verification.
@@ -196,7 +204,7 @@ func TestHTTP_Auth_Rejected(t *testing.T) {
 
 	// Create a client with a different signer (not the user).
 	badSigner := testutil.MustGenerateKey(t)
-	badClient := transport.NewHTTPClient(env.httpServers[0].URL, "escrow-1", badSigner)
+	badClient := httpTestClient(env.httpServers[0].URL, "escrow-1", badSigner)
 
 	diff := testutil.SignDiff(t, env.userSigner, "escrow-1", 1, []*types.DevshardTx{testutil.StartTx(1)})
 	_, err := badClient.Send(context.Background(), host.HostRequest{
@@ -786,7 +794,7 @@ func TestHTTP_LazyTxGossipHTTP(t *testing.T) {
 
 	// Gossip those txs to host 0 via HTTP.
 	// Use a host signer (gossip is host-to-host, user is forbidden).
-	hostClient := transport.NewHTTPClient(env.httpServers[0].URL, "escrow-1", env.signers[1])
+	hostClient := httpTestClient(env.httpServers[0].URL, "escrow-1", env.signers[1])
 	err = hostClient.GossipTxs(ctx, resp.Mempool)
 	require.NoError(t, err)
 
@@ -872,7 +880,7 @@ func TestAttack_UserCannotGossip(t *testing.T) {
 	ctx := context.Background()
 
 	// Create a client authenticated as the user (not a group member).
-	userClient := transport.NewHTTPClient(env.httpServers[0].URL, "escrow-1", env.userSigner)
+	userClient := httpTestClient(env.httpServers[0].URL, "escrow-1", env.userSigner)
 
 	// User attempts to gossip nonce -> must be rejected.
 	err := userClient.GossipNonce(ctx, 1, []byte("fake-hash"), []byte("fake-sig"), 0)
@@ -907,12 +915,12 @@ func TestAttack_GossipUnverifiedNonce(t *testing.T) {
 
 	// Attacker (group member host 2) sends a gossip nonce with a fake stateHash
 	// and garbage stateSig. Should be rejected because sig doesn't verify.
-	hostClient := transport.NewHTTPClient(env.httpServers[1].URL, "escrow-1", env.signers[2])
+	hostClient := httpTestClient(env.httpServers[1].URL, "escrow-1", env.signers[2])
 	err = hostClient.GossipNonce(ctx, 1, []byte("fake-hash"), []byte("garbage-sig"), 2)
 	require.Error(t, err, "gossip with invalid sig should be rejected")
 
 	// Now send the real gossip from a legitimate host. Must NOT be rejected as equivocation.
-	hostClient1 := transport.NewHTTPClient(env.httpServers[1].URL, "escrow-1", env.signers[0])
+	hostClient1 := httpTestClient(env.httpServers[1].URL, "escrow-1", env.signers[0])
 	err = hostClient1.GossipNonce(ctx, 1, resp.StateHash, resp.StateSig, 0)
 	require.NoError(t, err, "real gossip must not be rejected after fake was blocked")
 }
@@ -939,7 +947,7 @@ func TestAttack_GossipEmptySigBypass(t *testing.T) {
 
 	// Attacker (group member host 2) sends gossip with empty StateSig to bypass
 	// signature verification. Must be rejected.
-	hostClient := transport.NewHTTPClient(env.httpServers[1].URL, "escrow-1", env.signers[2])
+	hostClient := httpTestClient(env.httpServers[1].URL, "escrow-1", env.signers[2])
 	err = hostClient.GossipNonce(ctx, 1, []byte("fake-hash"), nil, 2)
 	require.Error(t, err, "gossip with empty sig must be rejected")
 
@@ -948,7 +956,7 @@ func TestAttack_GossipEmptySigBypass(t *testing.T) {
 	require.Error(t, err, "gossip with invalid slot id must be rejected")
 
 	// Real gossip must still work after the rejected attempts.
-	hostClient1 := transport.NewHTTPClient(env.httpServers[1].URL, "escrow-1", env.signers[0])
+	hostClient1 := httpTestClient(env.httpServers[1].URL, "escrow-1", env.signers[0])
 	err = hostClient1.GossipNonce(ctx, 1, resp.StateHash, resp.StateSig, 0)
 	require.NoError(t, err, "real gossip must succeed after rejected bypass attempts")
 }
diff --git a/devshard/runtimeconfig/chain_provider_test.go b/devshard/runtimeconfig/chain_provider_test.go
index 6c1218899d..f5b72ef7a0 100644
--- a/devshard/runtimeconfig/chain_provider_test.go
+++ b/devshard/runtimeconfig/chain_provider_test.go
@@ -110,7 +110,7 @@ func TestChainProvider_InitialFetchPopulatesSnapshot_v0_2_13Chain(t *testing.T)
 func TestChainProvider_v0_2_12Chain_ZeroNewFieldsPreserveCompiledDefaults(t *testing.T) {
 	// On a v0.2.12 chain the new DevshardEscrowParams fields decode as zero.
 	// The chain provider must store those zeros so downstream
-	// ApplyLiveSessionParams "if > 0 override" semantics fall back to compiled
+	// Older chain/dapi omit validation_rate (zero); lane A bind uses compiled
 	// defaults instead of nuking SessionConfig.
 	f := &fakeFetcher{
 		responses: []fakeFetchResponse{
diff --git a/devshard/runtimeconfig/grpc_provider_test.go b/devshard/runtimeconfig/grpc_provider_test.go
index a27b2dbb44..f2f72995aa 100644
--- a/devshard/runtimeconfig/grpc_provider_test.go
+++ b/devshard/runtimeconfig/grpc_provider_test.go
@@ -142,6 +142,15 @@ func TestGRPCProvider_LongPoll_NextRequestUsesNewHeight(t *testing.T) {
 	assert.Equal(t, int64(100), calls[1].GetClientParamsBlockHeight())
 }
 
+func waitGRPCServerCalls(t *testing.T, srv *testserver.Server, n int, timeout time.Duration) {
+	t.Helper()
+	deadline := time.Now().Add(timeout)
+	for len(srv.Calls()) < n && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
+	require.GreaterOrEqual(t, len(srv.Calls()), n)
+}
+
 func TestGRPCProvider_ServerNotSyncedPausesBetweenPolls(t *testing.T) {
 	srv := testserver.New()
 	// Repeat full-config-at-height-0: a single handler would be consumed and the fake
@@ -158,16 +167,23 @@ func TestGRPCProvider_ServerNotSyncedPausesBetweenPolls(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
+	clock := newFakeClock(time.Unix(0, 0))
+	const backoff = 50 * time.Millisecond
 	cfg := testConfig(t, client, func(c *Config) {
-		c.ErrorBackoffMin = 50 * time.Millisecond
+		c.ErrorBackoffMin = backoff
+		c.Clock = clock
 	})
 	_, err := New(ctx, cfg)
 	require.NoError(t, err)
 
-	time.Sleep(30 * time.Millisecond)
+	waitGRPCServerCalls(t, srv, 1, time.Second)
 	require.Equal(t, 1, len(srv.Calls()), "expected one initial_fetch while server height is 0, not a busy loop")
 
-	time.Sleep(60 * time.Millisecond)
+	deadline := time.Now().Add(time.Second)
+	for len(srv.Calls()) < 2 && time.Now().Before(deadline) {
+		clock.Advance(10 * time.Millisecond)
+		time.Sleep(time.Millisecond)
+	}
 	calls := len(srv.Calls())
 	assert.GreaterOrEqual(t, calls, 2, "second poll after server-not-synced backoff")
 	assert.LessOrEqual(t, calls, 3, "expected backoff between polls while height stays 0, got %d calls", calls)
diff --git a/devshard/state/machine.go b/devshard/state/machine.go
index eef08cfe1f..54dea0dcc3 100644
--- a/devshard/state/machine.go
+++ b/devshard/state/machine.go
@@ -225,6 +225,7 @@ func NewStateMachine(
 		"create_devshard_fee", config.CreateDevshardFee,
 		"token_price", config.TokenPrice,
 		"vote_threshold", config.VoteThreshold,
+		"validation_rate", config.ValidationRate,
 		"user_address", userAddress,
 		"protocol_version", sm.ProtocolVersion(),
 	)
@@ -494,6 +495,14 @@ func (sm *StateMachine) Balance() uint64 {
 	return sm.state.Balance
 }
 
+// Config returns a copy of the session config (a small value type). Use this
+// instead of SnapshotState().Config to avoid deep-copying the inference map.
+func (sm *StateMachine) Config() types.SessionConfig {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+	return sm.state.Config
+}
+
 // SnapshotState returns a deep copy of the current escrow state.
 func (sm *StateMachine) SnapshotState() types.EscrowState {
 	sm.mu.RLock()
@@ -501,6 +510,57 @@ func (sm *StateMachine) SnapshotState() types.EscrowState {
 	return *cloneEscrowState(sm.state)
 }
 
+// SnapshotStateNoInferences returns a deep copy of the escrow state with the
+// (potentially large) inference map omitted. All other fields, including the
+// small per-slot maps, are copied. Use it for summary/state endpoints that do
+// not render individual inference records, avoiding the cost of copying up to
+// tens of thousands of them.
+func (sm *StateMachine) SnapshotStateNoInferences() types.EscrowState {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+	src := sm.state
+	// Shallow struct copy; SealedAcc ([]byte) is shared deliberately: it is
+	// only ever replaced wholesale (append to a nil slice), never mutated in
+	// place, so readers of the snapshot see a stable value.
+	s := *src
+	s.Inferences = nil
+
+	s.Group = make([]types.SlotAssignment, len(src.Group))
+	copy(s.Group, src.Group)
+
+	s.HostStats = make(map[uint32]*types.HostStats, len(src.HostStats))
+	for k, v := range src.HostStats {
+		cp := *v
+		s.HostStats[k] = &cp
+	}
+
+	s.WarmKeys = make(map[uint32]string, len(src.WarmKeys))
+	maps.Copy(s.WarmKeys, src.WarmKeys)
+
+	return s
+}
+
+// SnapshotInferences returns a deep copy of just the inference map. Use it for
+// endpoints that render the full inference list without paying to copy the
+// rest of the escrow state.
+func (sm *StateMachine) SnapshotInferences() map[uint64]*types.InferenceRecord {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+	return copyInferences(sm.state.Inferences)
+}
+
+// InferenceStatusCounts returns the total number of inferences and a per-status
+// breakdown, computed under the read lock without deep-copying any records.
+func (sm *StateMachine) InferenceStatusCounts() (int, map[types.InferenceStatus]int) {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+	counts := make(map[types.InferenceStatus]int)
+	for _, rec := range sm.state.Inferences {
+		counts[rec.Status]++
+	}
+	return len(sm.state.Inferences), counts
+}
+
 // ExportState returns a deep-copied pointer form used by recovery snapshots.
 func (sm *StateMachine) ExportState() *types.EscrowState {
 	sm.mu.RLock()
diff --git a/devshard/state/seal.go b/devshard/state/seal.go
index 812ba51b3b..22a1fb5d96 100644
--- a/devshard/state/seal.go
+++ b/devshard/state/seal.go
@@ -1,7 +1,6 @@
 package state
 
 import (
-	"encoding/json"
 	"fmt"
 	"slices"
 
@@ -374,10 +373,6 @@ func (sm *StateMachine) logAutoSealDiagnosticLocked(
 	if len(candidates) == 0 && len(sealed) == 0 {
 		return
 	}
-	candidatesJSON, err := json.Marshal(candidates)
-	if err != nil {
-		candidatesJSON = []byte(fmt.Sprintf("marshal error: %v", err))
-	}
 	args := []any{
 		"subsystem", side,
 		"diagnostic", "auto_seal",
@@ -387,9 +382,9 @@ func (sm *StateMachine) logAutoSealDiagnosticLocked(
 		"inference_seal_grace_nonces", sealGraceNonces,
 		"inference_seal_grace_seconds", graceSeconds,
 		"state_clock_confirmed_at", stateClock,
-		"candidates", string(candidatesJSON),
 		"sealed_ids", sealed,
 		"sealed_count", len(sealed),
+		"candidates_count", len(candidates),
 		"live_inferences_count", len(sm.state.Inferences),
 	}
 	if clockWin.Known {
diff --git a/devshard/storage/factory.go b/devshard/storage/factory.go
index e01dafd83d..670ed5f3b6 100644
--- a/devshard/storage/factory.go
+++ b/devshard/storage/factory.go
@@ -9,7 +9,10 @@ import (
 	"time"
 )
 
-const defaultPGConnectTimeout = 2 * time.Second
+const (
+	defaultPGConnectTimeout    = 2 * time.Second
+	defaultPGReconnectInterval = 5 * time.Second
+)
 
 // ErrStoragePGBoundWithoutPostgres is returned when the store directory was
 // previously used in Postgres mode but PGHOST is unset at boot.
@@ -17,96 +20,121 @@ var ErrStoragePGBoundWithoutPostgres = errors.New(
 	"devshard store was previously bound to Postgres; running SQLite-only now would orphan PG sessions. Set PGHOST or delete .pg-bound to override",
 )
 
-type storageBackendKind string
-
-const (
-	storageBackendSQLite   storageBackendKind = "sqlite"
-	storageBackendPostgres storageBackendKind = "postgres"
-)
+// ErrStoragePostgresUnavailable is returned for new sessions while running in
+// degraded SQLite-only mode because PGHOST is set but Postgres is unreachable.
+var ErrStoragePostgresUnavailable = errors.New("devshard postgres storage is configured but unavailable")
 
 // NewStorage builds the canonical Storage for a host process.
 //
-// At boot it selects exactly one backend for the process lifetime:
-//   - SQLite when escrow_epoch has rows in _meta.db, or when PGHOST is unset on a
-//     fresh store (no .pg-bound marker).
-//   - Postgres when PGHOST is set, escrow_epoch is empty, and Postgres connects
-//     within PG_CONNECT_TIMEOUT.
-//   - Boot fails when .pg-bound exists but PGHOST is unset (would orphan PG sessions).
+// The returned store is a per-session router (HybridStorage):
+//   - When PGHOST is unset it is SQLite-only. If .pg-bound exists and SQLite
+//     still has sessions, boot enters degraded SQLite-owned-only mode: existing
+//     SQLite escrows are served, but new/unknown escrows are rejected because
+//     they may belong to unavailable Postgres.
+//   - When PGHOST is set, Postgres is the backend for all new escrows. If
+//     Postgres is temporarily unavailable, boot enters degraded mode instead of
+//     taking the whole process down.
+//   - When PGHOST is set and Postgres connects, legacy SQLite escrows are
+//     attached alongside Postgres so they keep being served and drain in place
+//     while new escrows go to Postgres.
+//
+// A given escrow lives in exactly one backend: CreateSession picks one backend
+// and never falls back to SQLite for Postgres-destined new escrows, so append
+// logs cannot fork across backends.
 //
 // See devshard/docs/storage-design.md#storage-mode-selection.
 func NewStorage(ctx context.Context, storeDir string) (Storage, error) {
-	kind, err := decideStorageBackend(storeDir)
-	if err != nil {
-		return nil, err
-	}
-
-	connectTimeout := pgConnectTimeout()
+	pgHost := os.Getenv("PGHOST")
 
-	switch kind {
-	case storageBackendSQLite:
-		logSQLiteTransitionWarn(storeDir)
-		sqlite, err := NewSQLite(storeDir)
+	if pgHost == "" {
+		pgBound, err := ReadPGBound(storeDir)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("read pg-bound marker: %w", err)
 		}
-		slog.Info("devshard storage: using sqlite", "dir", storeDir)
-		return NewHybridStorage(sqlite), nil
-
-	case storageBackendPostgres:
-		connectCtx, cancel := context.WithTimeout(ctx, connectTimeout)
-		defer cancel()
-		pg, err := NewPostgres(connectCtx)
-		if err != nil {
-			return nil, fmt.Errorf("postgres storage: %w", err)
+		if pgBound {
+			sqlite, sqliteDrain, err := openSQLiteDrain(storeDir)
+			if err != nil {
+				return nil, fmt.Errorf("open sqlite degraded: %w", err)
+			}
+			if sqliteDrain {
+				slog.Warn(
+					"devshard storage: .pg-bound present but PGHOST unset; serving sqlite-owned escrows only and rejecting new escrows",
+					"dir", storeDir,
+				)
+				return newDegradedSQLiteRouter(sqlite, storeDir, ErrStoragePGBoundWithoutPostgres), nil
+			}
+			return nil, ErrStoragePGBoundWithoutPostgres
 		}
-		if err := ensurePGBoundMarker(storeDir); err != nil {
-			pg.Close()
+		sqlite, err := NewSQLite(storeDir)
+		if err != nil {
 			return nil, err
 		}
-		slog.Info("devshard storage: using postgres", "dir", storeDir)
-		return NewHybridStorage(pg), nil
-
-	default:
-		return nil, fmt.Errorf("unknown storage backend kind %q", kind)
+		slog.Info("devshard storage: using sqlite", "dir", storeDir)
+		return newHybridRouter(sqlite, nil, false, storeDir), nil
 	}
-}
 
-func decideStorageBackend(storeDir string) (storageBackendKind, error) {
-	pgHost := os.Getenv("PGHOST")
+	sqlite, sqliteDrain, err := openSQLiteDrain(storeDir)
+	if err != nil {
+		return nil, fmt.Errorf("open sqlite drain: %w", err)
+	}
 
-	hasSQLite, err := HasSQLiteSessions(storeDir)
+	pg, err := openPostgresWithTimeout(ctx)
 	if err != nil {
-		return "", fmt.Errorf("probe sqlite sessions: %w", err)
+		slog.Warn(
+			"devshard storage: postgres unavailable; entering degraded mode while reconnect runs",
+			"dir", storeDir,
+			"sqlite_drain", sqliteDrain,
+			"error", err,
+		)
+		router := newDegradedSQLiteRouter(sqlite, storeDir, fmt.Errorf("%w: %w", ErrStoragePostgresUnavailable, err))
+		router.startPostgresReconnect(ctx, openPostgresWithTimeout, pgReconnectInterval())
+		return router, nil
 	}
 
-	if hasSQLite {
-		return storageBackendSQLite, nil
+	if sqliteDrain {
+		slog.Warn(
+			"devshard storage: serving legacy sqlite escrows alongside postgres; they drain in place as they settle and prune while new escrows go to postgres",
+			"dir", storeDir,
+		)
 	}
 
-	if pgHost != "" {
-		return storageBackendPostgres, nil
+	router := newHybridRouter(sqlite, pg, true, storeDir)
+	// Align .pg-bound with reality: present only while PG holds sessions. The
+	// marker is written ahead of each new PG session and cleared once PG drains.
+	if err := router.reconcilePGBoundAtBoot(); err != nil {
+		_ = router.Close()
+		return nil, fmt.Errorf("reconcile pg-bound: %w", err)
 	}
+	router.logConflictedEscrows("boot")
+	slog.Info("devshard storage: using postgres for new escrows", "dir", storeDir, "sqlite_drain", sqliteDrain)
+	return router, nil
+}
 
-	pgBound, err := ReadPGBound(storeDir)
+func openSQLiteDrain(storeDir string) (Storage, bool, error) {
+	hasSQLiteArtifacts, err := HasSQLiteArtifacts(storeDir)
 	if err != nil {
-		return "", fmt.Errorf("read pg-bound marker: %w", err)
+		return nil, false, fmt.Errorf("probe sqlite artifacts: %w", err)
 	}
-	if pgBound {
-		return "", ErrStoragePGBoundWithoutPostgres
+	if !hasSQLiteArtifacts {
+		return nil, false, nil
 	}
-
-	return storageBackendSQLite, nil
-}
-
-func ensurePGBoundMarker(storeDir string) error {
-	pgBound, err := ReadPGBound(storeDir)
+	s, err := NewSQLite(storeDir)
 	if err != nil {
-		return err
+		return nil, false, err
+	}
+	if s.HasAnySessions() {
+		return s, true, nil
 	}
-	if pgBound {
-		return nil
+	if err := s.Close(); err != nil {
+		return nil, false, fmt.Errorf("close empty sqlite store: %w", err)
 	}
-	return WritePGBound(storeDir)
+	return nil, false, nil
+}
+
+func openPostgresWithTimeout(ctx context.Context) (Storage, error) {
+	connectCtx, cancel := context.WithTimeout(ctx, pgConnectTimeout())
+	defer cancel()
+	return NewPostgres(connectCtx)
 }
 
 func pgConnectTimeout() time.Duration {
@@ -117,16 +145,10 @@ func pgConnectTimeout() time.Duration {
 	return connectTimeout
 }
 
-func logSQLiteTransitionWarn(storeDir string) {
-	if os.Getenv("PGHOST") == "" {
-		return
-	}
-	hasSQLite, err := HasSQLiteSessions(storeDir)
-	if err != nil || !hasSQLite {
-		return
+func pgReconnectInterval() time.Duration {
+	interval, err := time.ParseDuration(os.Getenv("PG_RECONNECT_INTERVAL"))
+	if err != nil || interval <= 0 {
+		return defaultPGReconnectInterval
 	}
-	slog.Warn(
-		"devshard storage: draining sqlite sessions while PGHOST is set; settle and prune until escrow_epoch is empty, then restart for postgres-only mode",
-		"dir", storeDir,
-	)
+	return interval
 }
diff --git a/devshard/storage/factory_test.go b/devshard/storage/factory_test.go
index 8099eb0b5c..98718fe6a7 100644
--- a/devshard/storage/factory_test.go
+++ b/devshard/storage/factory_test.go
@@ -2,11 +2,14 @@ package storage
 
 import (
 	"context"
+	"fmt"
 	"os"
+	"sort"
+	"sync"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
-
 )
 
 func TestNewStorage_postgresWhenPGHOSTAndEmptyMeta(t *testing.T) {
@@ -25,18 +28,50 @@ func TestNewStorage_postgresWhenPGHOSTAndEmptyMeta(t *testing.T) {
 
 	hybrid, ok := store.(*HybridStorage)
 	require.True(t, ok)
-	_, ok = hybrid.backend.(*Postgres)
+	_, ok = hybrid.pg.(*Postgres)
 	require.True(t, ok, "expected postgres backend")
+	require.Nil(t, hybrid.sqlite, "sqlite must not be attached without legacy sessions")
 
 	_, err = os.Stat(MetaDBPath(storeDir))
 	require.True(t, os.IsNotExist(err), "sqlite meta must not be opened in postgres mode")
 
 	pgBound, err := ReadPGBound(storeDir)
 	require.NoError(t, err)
-	require.True(t, pgBound)
+	require.False(t, pgBound, "empty postgres has no sessions to orphan, so .pg-bound must not be set")
 }
 
-func TestNewStorage_postgresBootFailsWhenUnreachable(t *testing.T) {
+func TestNewStorage_pgBoundLifecycleTracksPGSessions(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
+	}
+	cleanup := setupPostgresContainer(t)
+	defer cleanup()
+
+	storeDir := t.TempDir()
+	store, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.False(t, pgBound, "empty postgres must not set .pg-bound at boot")
+
+	params := paramsForEpoch("pg-escrow", 10)
+	params.Version = storageTestVersion
+	require.NoError(t, store.CreateSession(params))
+
+	pgBound, err = ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound, "creating a postgres session must write .pg-bound")
+
+	require.NoError(t, store.PruneEpoch(10))
+
+	pgBound, err = ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.False(t, pgBound, "draining the last postgres session must clear .pg-bound")
+}
+
+func TestNewStorage_postgresBootDegradesWhenUnreachable(t *testing.T) {
 	t.Setenv("PGHOST", "127.0.0.1")
 	t.Setenv("PGPORT", "1")
 	t.Setenv("PGDATABASE", "missing")
@@ -44,15 +79,148 @@ func TestNewStorage_postgresBootFailsWhenUnreachable(t *testing.T) {
 	t.Setenv("PGPASSWORD", "missing")
 
 	storeDir := t.TempDir()
-	_, err := NewStorage(context.Background(), storeDir)
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "postgres storage")
+	store, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+
+	hybrid := store.(*HybridStorage)
+	require.True(t, hybrid.degradedOwnerOnly)
+	require.Nil(t, hybrid.sqlite)
+	require.Nil(t, hybrid.pg)
+	err = store.CreateSession(paramsForEpoch("new-escrow", 10))
+	require.ErrorIs(t, err, ErrStoragePostgresUnavailable)
 
 	_, err = os.Stat(MetaDBPath(storeDir))
 	require.True(t, os.IsNotExist(err))
 }
 
-func TestNewStorage_sqliteWhenMetaHasRowsAndPGHOSTSet(t *testing.T) {
+func TestNewStorage_pgUnavailableServesSQLiteOwnedOnlyAndRejectsNew(t *testing.T) {
+	storeDir := t.TempDir()
+
+	t.Setenv("PGHOST", "")
+	sqliteStore, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	require.NoError(t, sqliteStore.CreateSession(paramsForEpoch("sqlite-owned", 9)))
+	require.NoError(t, sqliteStore.AppendDiff("sqlite-owned", makeDiffRecord(1)))
+	require.NoError(t, sqliteStore.Close())
+
+	t.Setenv("PGHOST", "127.0.0.1")
+	t.Setenv("PGPORT", "1")
+	t.Setenv("PGDATABASE", "missing")
+	t.Setenv("PGUSER", "missing")
+	t.Setenv("PGPASSWORD", "missing")
+
+	logs := captureStorageLogs(t)
+	store, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+	requireStorageLogEntry(t, readStorageLogEntries(t, logs),
+		"devshard storage: postgres unavailable; entering degraded mode while reconnect runs")
+
+	hybrid := store.(*HybridStorage)
+	require.True(t, hybrid.degradedOwnerOnly)
+	require.Nil(t, hybrid.pg)
+	sqlite := hybrid.sqlite.(*SQLite)
+	require.True(t, sqlite.HasEscrow("sqlite-owned"))
+
+	meta, err := store.GetSessionMeta("sqlite-owned")
+	require.NoError(t, err)
+	require.Equal(t, uint64(1), meta.LatestNonce)
+	require.NoError(t, store.AppendDiff("sqlite-owned", makeDiffRecord(2)))
+
+	err = store.CreateSession(paramsForEpoch("new-escrow", 10))
+	require.ErrorIs(t, err, ErrStoragePostgresUnavailable)
+	require.False(t, sqlite.HasEscrow("new-escrow"), "new escrow must not fall back to SQLite")
+}
+
+func TestNewStorage_pgUnavailableReconnectsAndPromotes(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
+	}
+	storeDir := t.TempDir()
+	t.Setenv("PG_RECONNECT_INTERVAL", "20ms")
+
+	t.Setenv("PGHOST", "")
+	sqliteStore, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	require.NoError(t, sqliteStore.CreateSession(paramsForEpoch("sqlite-owned", 9)))
+	require.NoError(t, sqliteStore.Close())
+
+	t.Setenv("PGHOST", "127.0.0.1")
+	t.Setenv("PGPORT", "1")
+	t.Setenv("PGDATABASE", "missing")
+	t.Setenv("PGUSER", "missing")
+	t.Setenv("PGPASSWORD", "missing")
+
+	store, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+	hybrid := store.(*HybridStorage)
+	require.True(t, hybrid.degradedOwnerOnly)
+	require.Nil(t, hybrid.pg)
+
+	cleanup := setupPostgresContainer(t)
+	t.Cleanup(cleanup)
+
+	require.Eventually(t, func() bool {
+		hybrid.mu.RLock()
+		pg := hybrid.pg
+		degraded := hybrid.degradedOwnerOnly
+		hybrid.mu.RUnlock()
+		return pg != nil && !degraded
+	}, 30*time.Second, 50*time.Millisecond)
+
+	sqlite := hybrid.sqlite.(*SQLite)
+	pg := hybrid.pg.(*Postgres)
+	require.True(t, sqlite.HasEscrow("sqlite-owned"))
+	require.False(t, pg.HasEscrow("sqlite-owned"))
+	require.NoError(t, store.CreateSession(paramsForEpoch("pg-after-reconnect", 10)))
+	require.True(t, pg.HasEscrow("pg-after-reconnect"))
+	require.False(t, sqlite.HasEscrow("pg-after-reconnect"), "new escrow must not fall back to SQLite after promotion")
+}
+
+func TestNewStorage_pgUnavailableEmptyStoreReconnectsAndPromotes(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
+	}
+	storeDir := t.TempDir()
+	t.Setenv("PG_RECONNECT_INTERVAL", "20ms")
+
+	t.Setenv("PGHOST", "127.0.0.1")
+	t.Setenv("PGPORT", "1")
+	t.Setenv("PGDATABASE", "missing")
+	t.Setenv("PGUSER", "missing")
+	t.Setenv("PGPASSWORD", "missing")
+
+	store, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+	hybrid := store.(*HybridStorage)
+	require.True(t, hybrid.degradedOwnerOnly)
+	require.Nil(t, hybrid.sqlite)
+	require.Nil(t, hybrid.pg)
+
+	err = store.CreateSession(paramsForEpoch("new-before-pg", 10))
+	require.ErrorIs(t, err, ErrStoragePostgresUnavailable)
+	_, err = os.Stat(MetaDBPath(storeDir))
+	require.True(t, os.IsNotExist(err), "empty degraded boot must not create sqlite meta")
+
+	cleanup := setupPostgresContainer(t)
+	t.Cleanup(cleanup)
+
+	require.Eventually(t, func() bool {
+		hybrid.mu.RLock()
+		pg := hybrid.pg
+		degraded := hybrid.degradedOwnerOnly
+		hybrid.mu.RUnlock()
+		return pg != nil && !degraded
+	}, 30*time.Second, 50*time.Millisecond)
+
+	require.NoError(t, store.CreateSession(paramsForEpoch("pg-after-empty-reconnect", 10)))
+	require.True(t, hybrid.pg.(*Postgres).HasEscrow("pg-after-empty-reconnect"))
+}
+
+func TestNewStorage_attachesSQLiteAndPostgresWhenMetaHasRowsAndPGHOSTSet(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
 	}
@@ -60,7 +228,10 @@ func TestNewStorage_sqliteWhenMetaHasRowsAndPGHOSTSet(t *testing.T) {
 	defer cleanup()
 
 	storeDir := t.TempDir()
-	require.NoError(t, insertMetaEscrowRow(storeDir, "drain-me", 3))
+	sqliteSeed, err := NewSQLite(storeDir)
+	require.NoError(t, err)
+	require.NoError(t, sqliteSeed.CreateSession(paramsForEpoch("drain-me", 3)))
+	require.NoError(t, sqliteSeed.Close())
 
 	logs := captureStorageLogs(t)
 	store, err := NewStorage(context.Background(), storeDir)
@@ -68,11 +239,278 @@ func TestNewStorage_sqliteWhenMetaHasRowsAndPGHOSTSet(t *testing.T) {
 	t.Cleanup(func() { _ = store.Close() })
 
 	hybrid := store.(*HybridStorage)
-	_, ok := hybrid.backend.(*SQLite)
-	require.True(t, ok)
+	_, ok := hybrid.sqlite.(*SQLite)
+	require.True(t, ok, "legacy sqlite escrows must still be served")
+	_, ok = hybrid.pg.(*Postgres)
+	require.True(t, ok, "postgres must back new escrows")
+	require.True(t, hybrid.preferPG, "new escrows must prefer postgres")
 
 	requireStorageLogEntry(t, readStorageLogEntries(t, logs),
-		"devshard storage: draining sqlite sessions while PGHOST is set; settle and prune until escrow_epoch is empty, then restart for postgres-only mode")
+		"devshard storage: serving legacy sqlite escrows alongside postgres; they drain in place as they settle and prune while new escrows go to postgres")
+}
+
+// TestNewStorage_sqliteEscrowSurvivesPostgresEnablement exercises the full
+// transition: a store starts SQLite-only (no PGHOST) with a live escrow, then
+// PGHOST is enabled on the next boot. The pre-existing escrow must keep running
+// on SQLite while brand-new escrows are created in Postgres.
+func TestNewStorage_sqliteEscrowSurvivesPostgresEnablement(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
+	}
+	cleanup := setupPostgresContainer(t)
+	defer cleanup()
+	pgHost := os.Getenv("PGHOST")
+
+	storeDir := t.TempDir()
+	ctx := context.Background()
+
+	// Phase 1: SQLite only. Create an escrow and write to it.
+	t.Setenv("PGHOST", "")
+	sqliteStore, err := NewStorage(ctx, storeDir)
+	require.NoError(t, err)
+	h1 := sqliteStore.(*HybridStorage)
+	require.Nil(t, h1.pg, "phase 1 must be sqlite-only")
+	_, ok := h1.sqlite.(*SQLite)
+	require.True(t, ok)
+
+	require.NoError(t, sqliteStore.CreateSession(paramsForEpoch("sqlite-escrow", 5)))
+	require.NoError(t, sqliteStore.AppendDiff("sqlite-escrow", makeDiffRecord(1)))
+	require.NoError(t, sqliteStore.Close())
+
+	// Phase 2: enable Postgres. Both backends attach.
+	t.Setenv("PGHOST", pgHost)
+	store, err := NewStorage(ctx, storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+
+	h := store.(*HybridStorage)
+	sqlite, ok := h.sqlite.(*SQLite)
+	require.True(t, ok, "legacy sqlite backend must stay attached")
+	pg, ok := h.pg.(*Postgres)
+	require.True(t, ok, "postgres backend must attach")
+
+	// The pre-existing escrow is still served and stays physically in SQLite.
+	meta, err := store.GetSessionMeta("sqlite-escrow")
+	require.NoError(t, err)
+	require.Equal(t, uint64(5), meta.EpochID)
+	require.Equal(t, uint64(1), meta.LatestNonce)
+	require.True(t, sqlite.HasEscrow("sqlite-escrow"))
+	require.False(t, pg.HasEscrow("sqlite-escrow"))
+
+	// It keeps accepting writes on SQLite after Postgres is enabled.
+	require.NoError(t, store.AppendDiff("sqlite-escrow", makeDiffRecord(2)))
+	diffs, err := store.GetDiffs("sqlite-escrow", 1, 2)
+	require.NoError(t, err)
+	require.Len(t, diffs, 2)
+	require.True(t, sqlite.HasEscrow("sqlite-escrow"))
+	require.False(t, pg.HasEscrow("sqlite-escrow"))
+
+	// A new escrow is created in Postgres, not SQLite.
+	require.NoError(t, store.CreateSession(paramsForEpoch("pg-escrow", 6)))
+	require.True(t, pg.HasEscrow("pg-escrow"), "new escrow must be created in postgres")
+	require.False(t, sqlite.HasEscrow("pg-escrow"), "new escrow must not touch sqlite")
+
+	require.NoError(t, store.AppendDiff("pg-escrow", makeDiffRecord(1)))
+	pgDiffs, err := store.GetDiffs("pg-escrow", 1, 1)
+	require.NoError(t, err)
+	require.Len(t, pgDiffs, 1)
+
+	// Recovery surfaces both escrows together.
+	active, err := store.ListActiveSessions()
+	require.NoError(t, err)
+	ids := make([]string, 0, len(active))
+	for _, a := range active {
+		ids = append(ids, a.EscrowID)
+	}
+	sort.Strings(ids)
+	require.Equal(t, []string{"pg-escrow", "sqlite-escrow"}, ids)
+
+	// A live Postgres session now exists, so .pg-bound is set.
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound)
+}
+
+func TestNewStorage_pgHostSetReconcilesSQLiteEpochFilesWhenMetaRowsMissing(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
+	}
+	cleanup := setupPostgresContainer(t)
+	defer cleanup()
+	pgHost := os.Getenv("PGHOST")
+
+	storeDir := t.TempDir()
+	ctx := context.Background()
+
+	t.Setenv("PGHOST", "")
+	sqliteStore, err := NewStorage(ctx, storeDir)
+	require.NoError(t, err)
+	require.NoError(t, sqliteStore.CreateSession(paramsForEpoch("recovered-sqlite", 5)))
+	require.NoError(t, sqliteStore.AppendDiff("recovered-sqlite", makeDiffRecord(1)))
+	require.NoError(t, sqliteStore.Close())
+
+	metaDB, err := openMetaDB(MetaDBPath(storeDir))
+	require.NoError(t, err)
+	_, err = metaDB.Exec(`DELETE FROM escrow_epoch`)
+	require.NoError(t, err)
+	require.NoError(t, metaDB.Close())
+
+	hasRows, err := HasSQLiteSessions(storeDir)
+	require.NoError(t, err)
+	require.False(t, hasRows, "the old factory probe would miss the recoverable SQLite session")
+
+	t.Setenv("PGHOST", pgHost)
+	store, err := NewStorage(ctx, storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+
+	h := store.(*HybridStorage)
+	sqlite, ok := h.sqlite.(*SQLite)
+	require.True(t, ok, "SQLite must attach after reconciliation repairs _meta.db")
+	pg, ok := h.pg.(*Postgres)
+	require.True(t, ok)
+
+	meta, err := store.GetSessionMeta("recovered-sqlite")
+	require.NoError(t, err)
+	require.Equal(t, uint64(5), meta.EpochID)
+	require.Equal(t, uint64(1), meta.LatestNonce)
+	require.True(t, sqlite.HasEscrow("recovered-sqlite"))
+	require.False(t, pg.HasEscrow("recovered-sqlite"))
+
+	require.NoError(t, store.CreateSession(paramsForEpoch("new-pg", 6)))
+	require.True(t, pg.HasEscrow("new-pg"))
+	require.False(t, sqlite.HasEscrow("new-pg"))
+}
+
+func TestNewStorage_sqliteToPostgresManySessionsMixedStatusConcurrent(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping postgres factory test in -short mode (requires Docker)")
+	}
+	cleanup := setupPostgresContainer(t)
+	defer cleanup()
+	pgHost := os.Getenv("PGHOST")
+
+	const legacyCount = 60
+	const newCount = 40
+
+	storeDir := t.TempDir()
+	ctx := context.Background()
+
+	t.Setenv("PGHOST", "")
+	sqliteStore, err := NewStorage(ctx, storeDir)
+	require.NoError(t, err)
+	for i := 0; i < legacyCount; i++ {
+		escrowID := fmt.Sprintf("legacy-%03d", i)
+		require.NoError(t, sqliteStore.CreateSession(paramsForEpoch(escrowID, 20+uint64(i%4))))
+		if i%3 == 0 {
+			require.NoError(t, sqliteStore.MarkSettled(escrowID))
+			continue
+		}
+		require.NoError(t, sqliteStore.AppendDiff(escrowID, makeDiffRecord(1)))
+		require.NoError(t, sqliteStore.AppendDiff(escrowID, makeDiffRecord(2)))
+	}
+	require.NoError(t, sqliteStore.Close())
+
+	t.Setenv("PGHOST", pgHost)
+	store, err := NewStorage(ctx, storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+
+	h := store.(*HybridStorage)
+	sqlite, ok := h.sqlite.(*SQLite)
+	require.True(t, ok, "legacy SQLite sessions must attach for drain")
+	pg, ok := h.pg.(*Postgres)
+	require.True(t, ok)
+
+	var wg sync.WaitGroup
+	errs := make(chan error, legacyCount+newCount)
+	for i := 0; i < legacyCount; i++ {
+		i := i
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			escrowID := fmt.Sprintf("legacy-%03d", i)
+			meta, err := store.GetSessionMeta(escrowID)
+			if err != nil {
+				errs <- err
+				return
+			}
+			if i%3 == 0 {
+				if meta.Status != "settled" {
+					errs <- fmt.Errorf("%s status = %s, want settled", escrowID, meta.Status)
+				}
+				return
+			}
+			if meta.Status != "active" {
+				errs <- fmt.Errorf("%s status = %s, want active", escrowID, meta.Status)
+				return
+			}
+			errs <- store.AppendDiff(escrowID, makeDiffRecord(3))
+		}()
+	}
+	for i := 0; i < newCount; i++ {
+		i := i
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			escrowID := fmt.Sprintf("pg-%03d", i)
+			if err := store.CreateSession(paramsForEpoch(escrowID, 30+uint64(i%4))); err != nil {
+				errs <- err
+				return
+			}
+			if err := store.AppendDiff(escrowID, makeDiffRecord(1)); err != nil {
+				errs <- err
+				return
+			}
+			if i%4 == 0 {
+				errs <- store.MarkSettled(escrowID)
+			}
+		}()
+	}
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		require.NoError(t, err)
+	}
+
+	for i := 0; i < legacyCount; i++ {
+		escrowID := fmt.Sprintf("legacy-%03d", i)
+		require.True(t, sqlite.HasEscrow(escrowID), "%s must remain SQLite-owned", escrowID)
+		require.False(t, pg.HasEscrow(escrowID), "%s must not be recreated in PG", escrowID)
+	}
+	for i := 0; i < newCount; i++ {
+		escrowID := fmt.Sprintf("pg-%03d", i)
+		require.True(t, pg.HasEscrow(escrowID), "%s must be PG-owned", escrowID)
+		require.False(t, sqlite.HasEscrow(escrowID), "%s must not be created in SQLite", escrowID)
+	}
+
+	active, err := store.ListActiveSessions()
+	require.NoError(t, err)
+	gotActive := make([]string, 0, len(active))
+	for _, session := range active {
+		gotActive = append(gotActive, session.EscrowID)
+	}
+	sort.Strings(gotActive)
+
+	var wantActive []string
+	for i := 0; i < legacyCount; i++ {
+		if i%3 != 0 {
+			wantActive = append(wantActive, fmt.Sprintf("legacy-%03d", i))
+		}
+	}
+	for i := 0; i < newCount; i++ {
+		if i%4 != 0 {
+			wantActive = append(wantActive, fmt.Sprintf("pg-%03d", i))
+		}
+	}
+	sort.Strings(wantActive)
+	require.Equal(t, wantActive, gotActive)
+
+	for _, escrowID := range []string{"legacy-000", "pg-000"} {
+		meta, err := store.GetSessionMeta(escrowID)
+		require.NoError(t, err)
+		require.Equal(t, "settled", meta.Status)
+	}
 }
 
 func TestNewStorage_sqliteWhenMetaHasRowsPGHOSTUnset(t *testing.T) {
@@ -85,8 +523,9 @@ func TestNewStorage_sqliteWhenMetaHasRowsPGHOSTUnset(t *testing.T) {
 	t.Cleanup(func() { _ = store.Close() })
 
 	hybrid := store.(*HybridStorage)
-	_, ok := hybrid.backend.(*SQLite)
+	_, ok := hybrid.sqlite.(*SQLite)
 	require.True(t, ok)
+	require.Nil(t, hybrid.pg, "postgres must not be attached without PGHOST")
 }
 
 func TestNewStorage_postgresWhenEmptyMetaAndPGHOST(t *testing.T) {
@@ -105,12 +544,41 @@ func TestNewStorage_postgresWhenEmptyMetaAndPGHOST(t *testing.T) {
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = store.Close() })
 
-	_, ok := store.(*HybridStorage).backend.(*Postgres)
+	_, ok := store.(*HybridStorage).pg.(*Postgres)
 	require.True(t, ok)
 
 	pgBound, err := ReadPGBound(storeDir)
 	require.NoError(t, err)
-	require.True(t, pgBound)
+	require.False(t, pgBound, "empty postgres has no sessions to orphan, so .pg-bound must not be set")
+}
+
+func TestNewStorage_pgBoundWithoutPGHOSTServesSQLiteOwnedOnlyAndRejectsNew(t *testing.T) {
+	t.Setenv("PGHOST", "")
+	storeDir := t.TempDir()
+	sqliteStore, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	require.NoError(t, sqliteStore.CreateSession(paramsForEpoch("sqlite-owned", 9)))
+	require.NoError(t, sqliteStore.Close())
+	require.NoError(t, WritePGBound(storeDir))
+
+	logs := captureStorageLogs(t)
+	store, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = store.Close() })
+	requireStorageLogEntry(t, readStorageLogEntries(t, logs),
+		"devshard storage: .pg-bound present but PGHOST unset; serving sqlite-owned escrows only and rejecting new escrows")
+
+	hybrid := store.(*HybridStorage)
+	require.True(t, hybrid.degradedOwnerOnly)
+	require.Nil(t, hybrid.pg)
+	sqlite := hybrid.sqlite.(*SQLite)
+	require.True(t, sqlite.HasEscrow("sqlite-owned"))
+
+	_, err = store.GetSessionMeta("sqlite-owned")
+	require.NoError(t, err)
+	err = store.CreateSession(paramsForEpoch("new-escrow", 10))
+	require.ErrorIs(t, err, ErrStoragePGBoundWithoutPostgres)
+	require.False(t, sqlite.HasEscrow("new-escrow"), "new escrow must not fall back to SQLite")
 }
 
 func TestNewStorage_failsWhenPGBoundWithoutPGHOST(t *testing.T) {
@@ -143,7 +611,7 @@ func TestNewStorage_freshSQLiteWithoutPGHOST(t *testing.T) {
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = store.Close() })
 
-	_, ok := store.(*HybridStorage).backend.(*SQLite)
+	_, ok := store.(*HybridStorage).sqlite.(*SQLite)
 	require.True(t, ok)
 }
 
@@ -170,10 +638,13 @@ func TestNewStorage_postgresModeNoForkWhenPGDownAfterSessionInPG(t *testing.T) {
 	t.Setenv("PGUSER", "missing")
 	t.Setenv("PGPASSWORD", "missing")
 
-	_, err = NewStorage(context.Background(), storeDir)
-	require.Error(t, err, "postgres mode must fail boot when PG is down")
+	degraded, err := NewStorage(context.Background(), storeDir)
+	require.NoError(t, err, "postgres mode should degrade instead of failing boot when PG is down")
+	t.Cleanup(func() { _ = degraded.Close() })
+
+	err = degraded.CreateSession(paramsForEpoch("new-while-pg-down", 10))
+	require.ErrorIs(t, err, ErrStoragePostgresUnavailable)
 
 	_, err = os.Stat(MetaDBPath(storeDir))
-	require.True(t, os.IsNotExist(err), "must not open sqlite when postgres mode boot fails")
+	require.True(t, os.IsNotExist(err), "must not open sqlite when postgres mode degrades without sqlite artifacts")
 }
-
diff --git a/devshard/storage/hybrid.go b/devshard/storage/hybrid.go
index 10374c9bfc..5f81b61fe7 100644
--- a/devshard/storage/hybrid.go
+++ b/devshard/storage/hybrid.go
@@ -1,109 +1,691 @@
 package storage
 
 import (
+	"context"
 	"fmt"
+	"log/slog"
+	"os"
+	"sort"
+	"sync"
+	"time"
 
 	"devshard/types"
 )
 
-// HybridStorage forwards every Storage call to a single backend chosen at
-// process startup by NewStorage. It exists so ManagedStorage and callers keep
-// a stable wrapper type without dual-backend routing.
+// HybridStorage routes every escrow to exactly one backend and can serve two
+// backends at once. New escrows are created in Postgres when it is configured
+// (PGHOST set), otherwise in SQLite. Existing escrows are always served by
+// whichever backend physically holds them, so a store can drain legacy SQLite
+// sessions while creating new Postgres sessions without a process restart.
+//
+// Ownership is derived from each backend's own persistent escrow index (SQLite
+// _meta.db, Postgres devshard_session_index) rather than a separate route table
+// that could be lost on reboot. Because CreateSession picks exactly one backend
+// and never falls back, a given escrow only ever lives in one backend, so
+// append logs cannot fork across backends.
 type HybridStorage struct {
-	backend Storage
+	sqlite   Storage
+	pg       Storage
+	preferPG bool
+	storeDir string // enables .pg-bound maintenance; empty disables it
+
+	// degradedOwnerOnly means only already-owned escrows may use the single
+	// SQLite backend. New/unknown escrows fail with newSessionErr instead of
+	// falling back to SQLite while Postgres is unavailable or unconfigured.
+	degradedOwnerOnly bool
+	newSessionErr     error
+
+	reconnectStop chan struct{}
+	reconnectDone chan struct{}
+
+	onPromoted []func()
+	promoted   bool
+
+	mu sync.RWMutex
+
+	// markerMu serializes .pg-bound maintenance with the Postgres session-count
+	// changes that drive it, so a prune-driven clear cannot interleave with a
+	// PG CreateSession and leave a live PG session unmarked.
+	markerMu   sync.Mutex
+	pgBoundSet bool // guarded by markerMu: whether .pg-bound is present on disk
+}
+
+// escrowOwner is implemented by backends that can answer whether they hold an
+// escrow in their in-memory routing index.
+type escrowOwner interface {
+	HasEscrow(escrowID string) bool
+}
+
+// sessionPresence is implemented by backends that can report whether they still
+// hold any session. Used to decide when .pg-bound can be cleared.
+type sessionPresence interface {
+	HasAnySessions() bool
+}
+
+// livePresence is implemented by backends that can prove emptiness against the
+// database itself rather than the in-memory index. Required before clearing
+// .pg-bound after a failed create: a timed-out insert may have committed
+// server-side without the in-memory index ever learning about it.
+type livePresence interface {
+	HasAnySessionsLive() (bool, error)
+}
+
+// escrowIDLister is implemented by backends that can expose their in-memory
+// escrow index for duplicate-backend diagnostics.
+type escrowIDLister interface {
+	EscrowIDs() []string
+}
+
+// PostgresPromotionWatcher lets callers react after a degraded router promotes
+// Postgres in-process.
+type PostgresPromotionWatcher interface {
+	OnPostgresPromoted(func())
+}
+
+// newHybridRouter wires the per-session router. Either backend may be nil, but
+// at least one must be non-nil. preferPG selects the backend for brand-new
+// escrows when both backends are present. storeDir enables .pg-bound marker
+// maintenance for the Postgres backend.
+func newHybridRouter(sqlite, pg Storage, preferPG bool, storeDir string) *HybridStorage {
+	return &HybridStorage{
+		sqlite:   sqlite,
+		pg:       pg,
+		preferPG: preferPG,
+		storeDir: storeDir,
+	}
+}
+
+func newDegradedSQLiteRouter(sqlite Storage, storeDir string, newSessionErr error) *HybridStorage {
+	return &HybridStorage{
+		sqlite:            sqlite,
+		storeDir:          storeDir,
+		degradedOwnerOnly: true,
+		newSessionErr:     newSessionErr,
+	}
+}
+
+func (h *HybridStorage) backends() []Storage {
+	h.mu.RLock()
+	sqlite := h.sqlite
+	pg := h.pg
+	h.mu.RUnlock()
+
+	bs := make([]Storage, 0, 2)
+	if sqlite != nil {
+		bs = append(bs, sqlite)
+	}
+	if pg != nil {
+		bs = append(bs, pg)
+	}
+	return bs
+}
+
+// backendFor returns the backend that owns escrowID, or nil when neither
+// backend knows it yet. If both backends claim it, the escrow is quarantined.
+func (h *HybridStorage) backendFor(escrowID string) (Storage, error) {
+	h.mu.RLock()
+	sqlite := h.sqlite
+	pg := h.pg
+	degradedOwnerOnly := h.degradedOwnerOnly
+	h.mu.RUnlock()
+
+	if pg == nil {
+		if degradedOwnerOnly {
+			if owns(sqlite, escrowID) {
+				return sqlite, nil
+			}
+			return nil, nil
+		}
+		return sqlite, nil
+	}
+	if sqlite == nil {
+		return pg, nil
+	}
+
+	sqliteOwns := owns(sqlite, escrowID)
+	pgOwns := owns(pg, escrowID)
+	switch {
+	case sqliteOwns && pgOwns:
+		return nil, fmt.Errorf("%w: %s", ErrEscrowBackendConflict, escrowID)
+	case sqliteOwns:
+		return sqlite, nil
+	case pgOwns:
+		return pg, nil
+	default:
+		return nil, nil
+	}
+}
+
+func (h *HybridStorage) postgresBackend() Storage {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	return h.pg
 }
 
-// NewHybridStorage wraps the backend selected at boot.
-func NewHybridStorage(backend Storage) *HybridStorage {
-	return &HybridStorage{backend: backend}
+func (h *HybridStorage) newSessionError() error {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	return h.newSessionErr
+}
+
+func owns(b Storage, escrowID string) bool {
+	if b == nil {
+		return false
+	}
+	o, ok := b.(escrowOwner)
+	if !ok {
+		return false
+	}
+	return o.HasEscrow(escrowID)
+}
+
+// routed returns the owning backend for an existing escrow, or ErrSessionNotFound.
+func (h *HybridStorage) routed(escrowID string) (Storage, error) {
+	b, err := h.backendFor(escrowID)
+	if err != nil {
+		return nil, err
+	}
+	if b == nil {
+		return nil, fmt.Errorf("%w: %s", ErrSessionNotFound, escrowID)
+	}
+	return b, nil
+}
+
+// newSessionBackend picks the backend for a brand-new escrow: Postgres when it
+// is configured (preferPG), otherwise SQLite. Falls back to whichever backend
+// is present when only one is configured.
+func (h *HybridStorage) newSessionBackend() Storage {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	if h.preferPG && h.pg != nil {
+		return h.pg
+	}
+	if h.sqlite != nil {
+		return h.sqlite
+	}
+	return h.pg
 }
 
 func (h *HybridStorage) CreateSession(params CreateSessionParams) error {
-	return h.backend.CreateSession(params)
+	b, err := h.backendFor(params.EscrowID)
+	if err != nil {
+		return err
+	}
+	if b == nil {
+		if err := h.newSessionError(); err != nil {
+			return fmt.Errorf("%w: escrow %s", err, params.EscrowID)
+		}
+		b = h.newSessionBackend()
+	}
+
+	pg := h.postgresBackend()
+	if pg != nil && b == pg && h.storeDir != "" {
+		// Postgres-bound session: keep .pg-bound present for as long as PG holds
+		// any session. Write the marker ahead of the insert and hold markerMu
+		// across the insert so a concurrent prune-driven clear cannot observe an
+		// empty index between the write-ahead and the insert landing.
+		h.markerMu.Lock()
+		defer h.markerMu.Unlock()
+		if err := h.ensurePGBoundLocked(); err != nil {
+			return err
+		}
+		if err := b.CreateSession(params); err != nil {
+			h.maybeClearPGBoundLocked("postgres_create_failed", "escrow_id", params.EscrowID, "create_error", err)
+			return err
+		}
+		return nil
+	}
+
+	if err := b.CreateSession(params); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ensurePGBoundLocked writes the .pg-bound marker if it is not already present.
+// Caller must hold markerMu.
+func (h *HybridStorage) ensurePGBoundLocked() error {
+	if h.pgBoundSet {
+		return nil
+	}
+	if err := WritePGBound(h.storeDir); err != nil {
+		return fmt.Errorf("write pg-bound: %w", err)
+	}
+	h.pgBoundSet = true
+	return nil
+}
+
+// maybeClearPGBoundLocked removes the write-ahead marker only when Postgres
+// provably has no sessions. Caller must hold markerMu.
+func (h *HybridStorage) maybeClearPGBoundLocked(reason string, attrs ...any) {
+	pg := h.postgresBackend()
+	if pg == nil || h.storeDir == "" || !h.pgBoundSet || pgHasSessions(pg) {
+		return
+	}
+	args := []any{"dir", h.storeDir, "reason", reason}
+	args = append(args, attrs...)
+
+	lp, ok := pg.(livePresence)
+	if !ok {
+		slog.Warn("devshard storage: keeping .pg-bound; backend cannot live-check postgres emptiness", args...)
+		return
+	}
+	has, err := lp.HasAnySessionsLive()
+	if err != nil {
+		args = append(args, "live_check_error", err)
+		slog.Warn("devshard storage: keeping .pg-bound; live postgres emptiness check failed", args...)
+		return
+	}
+	if has {
+		return
+	}
+	if err := os.Remove(PGBoundPath(h.storeDir)); err != nil && !os.IsNotExist(err) {
+		args = append(args, "cleanup_error", err)
+		slog.Warn("devshard storage: failed to clear .pg-bound after postgres drained", args...)
+		return
+	}
+	h.pgBoundSet = false
+	slog.Info("devshard storage: cleared .pg-bound; postgres has no remaining sessions", args...)
+}
+
+type storageOpener func(context.Context) (Storage, error)
+
+func (h *HybridStorage) startPostgresReconnect(ctx context.Context, opener storageOpener, interval time.Duration) {
+	if interval <= 0 {
+		interval = time.Second
+	}
+	h.mu.Lock()
+	if h.reconnectStop != nil || h.pg != nil || !h.degradedOwnerOnly {
+		h.mu.Unlock()
+		return
+	}
+	stop := make(chan struct{})
+	done := make(chan struct{})
+	h.reconnectStop = stop
+	h.reconnectDone = done
+	h.mu.Unlock()
+
+	go func() {
+		defer close(done)
+		t := time.NewTicker(interval)
+		defer t.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-stop:
+				return
+			case <-t.C:
+			}
+
+			pg, err := opener(ctx)
+			if err != nil {
+				slog.Warn("devshard storage: postgres reconnect failed; staying in degraded sqlite-owned-only mode",
+					"dir", h.storeDir, "error", err)
+				continue
+			}
+			if err := h.promotePostgres(pg); err != nil {
+				_ = pg.Close()
+				slog.Warn("devshard storage: postgres reconnect succeeded but promotion failed; staying degraded",
+					"dir", h.storeDir, "error", err)
+				continue
+			}
+			return
+		}
+	}()
+}
+
+func (h *HybridStorage) promotePostgres(pg Storage) error {
+	if pg == nil {
+		return fmt.Errorf("postgres backend is nil")
+	}
+	if err := h.reconcilePGBoundFor(pg); err != nil {
+		return err
+	}
+	h.mu.Lock()
+	if h.pg != nil {
+		h.mu.Unlock()
+		_ = pg.Close()
+		return nil
+	}
+	h.pg = pg
+	h.preferPG = true
+	h.degradedOwnerOnly = false
+	h.newSessionErr = nil
+	h.promoted = true
+	hooks := append([]func(){}, h.onPromoted...)
+	h.mu.Unlock()
+	slog.Info("devshard storage: postgres reconnected; leaving degraded sqlite-owned-only mode", "dir", h.storeDir)
+	h.logConflictedEscrows("postgres promotion")
+	for _, hook := range hooks {
+		go hook()
+	}
+	return nil
+}
+
+// OnPostgresPromoted registers fn to run after a degraded router promotes
+// Postgres. If promotion already happened, fn runs asynchronously immediately.
+func (h *HybridStorage) OnPostgresPromoted(fn func()) {
+	if fn == nil {
+		return
+	}
+	h.mu.Lock()
+	if h.promoted {
+		h.mu.Unlock()
+		go fn()
+		return
+	}
+	h.onPromoted = append(h.onPromoted, fn)
+	h.mu.Unlock()
+}
+
+func (h *HybridStorage) maybeClearPGBound(reason string, attrs ...any) {
+	h.markerMu.Lock()
+	defer h.markerMu.Unlock()
+	h.maybeClearPGBoundLocked(reason, attrs...)
+}
+
+// reconcilePGBoundAtBoot aligns the .pg-bound marker with Postgres reality at
+// startup: present when PG holds sessions, absent when it does not. This clears
+// a stale marker left behind after a previous run's escrows fully drained.
+func (h *HybridStorage) reconcilePGBoundAtBoot() error {
+	h.mu.RLock()
+	pg := h.pg
+	h.mu.RUnlock()
+	return h.reconcilePGBoundFor(pg)
+}
+
+func (h *HybridStorage) reconcilePGBoundFor(pg Storage) error {
+	if pg == nil || h.storeDir == "" {
+		return nil
+	}
+	h.markerMu.Lock()
+	defer h.markerMu.Unlock()
+	present, err := ReadPGBound(h.storeDir)
+	if err != nil {
+		return err
+	}
+	h.pgBoundSet = present
+	// At boot and promotion time the Postgres in-memory index was just rebuilt
+	// from devshard_session_index, so it is authoritative for marker reconcile.
+	if pgHasSessions(pg) {
+		return h.ensurePGBoundLocked()
+	}
+	if present {
+		if err := os.Remove(PGBoundPath(h.storeDir)); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("clear stale pg-bound: %w", err)
+		}
+		h.pgBoundSet = false
+	}
+	return nil
+}
+
+// pgHasSessions reports whether the Postgres backend still holds any session.
+// When the backend cannot report presence it is treated as non-empty so the
+// marker is retained conservatively.
+func pgHasSessions(b Storage) bool {
+	c, ok := b.(sessionPresence)
+	if !ok {
+		return true
+	}
+	return c.HasAnySessions()
+}
+
+func (h *HybridStorage) logConflictedEscrows(phase string) {
+	escrowIDs := h.conflictedEscrowIDs()
+	if len(escrowIDs) == 0 {
+		return
+	}
+	slog.Error(
+		"devshard storage: escrow exists in both sqlite and postgres; quarantining conflicted escrows",
+		"dir", h.storeDir,
+		"phase", phase,
+		"escrow_ids", escrowIDs,
+		"remediation", "inspect both backends and remove the stale fork before continuing the escrow",
+	)
+}
+
+func (h *HybridStorage) conflictedEscrowIDs() []string {
+	h.mu.RLock()
+	sqlite := h.sqlite
+	pg := h.pg
+	h.mu.RUnlock()
+	return intersectEscrowIDs(sqlite, pg)
+}
+
+func intersectEscrowIDs(a, b Storage) []string {
+	if a == nil || b == nil {
+		return nil
+	}
+	aIDs, ok := escrowIDs(a)
+	if !ok || len(aIDs) == 0 {
+		return nil
+	}
+	bIDs, ok := escrowIDs(b)
+	if !ok || len(bIDs) == 0 {
+		return nil
+	}
+	bSet := make(map[string]struct{}, len(bIDs))
+	for _, id := range bIDs {
+		bSet[id] = struct{}{}
+	}
+	var conflicts []string
+	for _, id := range aIDs {
+		if _, ok := bSet[id]; ok {
+			conflicts = append(conflicts, id)
+		}
+	}
+	sort.Strings(conflicts)
+	return conflicts
+}
+
+func escrowIDs(b Storage) ([]string, bool) {
+	l, ok := b.(escrowIDLister)
+	if !ok {
+		return nil, false
+	}
+	return l.EscrowIDs(), true
 }
 
 func (h *HybridStorage) MarkSettled(escrowID string) error {
-	return h.backend.MarkSettled(escrowID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.MarkSettled(escrowID)
 }
 
+// ListActiveSessions unions active sessions across both backends so recovery
+// replays SQLite and Postgres escrows together. If both backends list the same
+// escrow, keep one entry; follow-up reads will quarantine the conflict.
 func (h *HybridStorage) ListActiveSessions() ([]ActiveSession, error) {
-	return h.backend.ListActiveSessions()
+	var out []ActiveSession
+	seen := make(map[string]struct{})
+	for _, b := range h.backends() {
+		sessions, err := b.ListActiveSessions()
+		if err != nil {
+			return nil, err
+		}
+		for _, sess := range sessions {
+			if _, ok := seen[sess.EscrowID]; ok {
+				continue
+			}
+			seen[sess.EscrowID] = struct{}{}
+			out = append(out, sess)
+		}
+	}
+	return out, nil
 }
 
 func (h *HybridStorage) AppendDiff(escrowID string, rec types.DiffRecord) error {
-	return h.backend.AppendDiff(escrowID, rec)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.AppendDiff(escrowID, rec)
 }
 
 func (h *HybridStorage) GetDiffs(escrowID string, fromNonce, toNonce uint64) ([]types.DiffRecord, error) {
-	return h.backend.GetDiffs(escrowID, fromNonce, toNonce)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return nil, err
+	}
+	return b.GetDiffs(escrowID, fromNonce, toNonce)
 }
 
 func (h *HybridStorage) AddSignature(escrowID string, nonce uint64, slotID uint32, sig []byte) error {
-	return h.backend.AddSignature(escrowID, nonce, slotID, sig)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.AddSignature(escrowID, nonce, slotID, sig)
 }
 
 func (h *HybridStorage) GetSignatures(escrowID string, nonce uint64) (map[uint32][]byte, error) {
-	return h.backend.GetSignatures(escrowID, nonce)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return nil, err
+	}
+	return b.GetSignatures(escrowID, nonce)
 }
 
 func (h *HybridStorage) GetSessionMeta(escrowID string) (*SessionMeta, error) {
-	return h.backend.GetSessionMeta(escrowID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return nil, err
+	}
+	return b.GetSessionMeta(escrowID)
 }
 
 func (h *HybridStorage) MarkFinalized(escrowID string, nonce uint64) error {
-	return h.backend.MarkFinalized(escrowID, nonce)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.MarkFinalized(escrowID, nonce)
 }
 
 func (h *HybridStorage) LastFinalized(escrowID string) (uint64, error) {
-	return h.backend.LastFinalized(escrowID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return 0, err
+	}
+	return b.LastFinalized(escrowID)
 }
 
 func (h *HybridStorage) SaveSnapshot(escrowID string, nonce uint64, data []byte) error {
-	return h.backend.SaveSnapshot(escrowID, nonce, data)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.SaveSnapshot(escrowID, nonce, data)
 }
 
 func (h *HybridStorage) LoadSnapshot(escrowID string) (uint64, []byte, error) {
-	return h.backend.LoadSnapshot(escrowID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return 0, nil, err
+	}
+	return b.LoadSnapshot(escrowID)
 }
 
 func (h *HybridStorage) InsertSealedInference(escrowID string, row InferenceRow) error {
-	return h.backend.InsertSealedInference(escrowID, row)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.InsertSealedInference(escrowID, row)
 }
 
 func (h *HybridStorage) GetSealedInference(escrowID string, inferenceID uint64) (InferenceRow, bool, error) {
-	return h.backend.GetSealedInference(escrowID, inferenceID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return InferenceRow{}, false, err
+	}
+	return b.GetSealedInference(escrowID, inferenceID)
 }
 
 func (h *HybridStorage) DeleteSealedInferences(escrowID string) error {
-	return h.backend.DeleteSealedInferences(escrowID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.DeleteSealedInferences(escrowID)
 }
 
 func (h *HybridStorage) RecordValidationsAppliedOnce(escrowID string, entries []ValidationObsEntry) error {
-	return h.backend.RecordValidationsAppliedOnce(escrowID, entries)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.RecordValidationsAppliedOnce(escrowID, entries)
 }
 
 func (h *HybridStorage) DrainInferenceValidationObs(escrowID string, inferenceID uint64) error {
-	return h.backend.DrainInferenceValidationObs(escrowID, inferenceID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return err
+	}
+	return b.DrainInferenceValidationObs(escrowID, inferenceID)
 }
 
 func (h *HybridStorage) GetValidationObservability(escrowID string) ([]SlotValidationObs, error) {
-	return h.backend.GetValidationObservability(escrowID)
+	b, err := h.routed(escrowID)
+	if err != nil {
+		return nil, err
+	}
+	return b.GetValidationObservability(escrowID)
 }
 
+// PruneEpoch drops the epoch partition in every backend.
 func (h *HybridStorage) PruneEpoch(epochID uint64) error {
-	return h.backend.PruneEpoch(epochID)
+	for _, b := range h.backends() {
+		if err := b.PruneEpoch(epochID); err != nil {
+			return err
+		}
+	}
+	h.maybeClearPGBound("prune_epoch", "epoch_id", epochID)
+	return nil
 }
 
 func (h *HybridStorage) pruneBefore(cutoff uint64) error {
-	rp, ok := h.backend.(rangePruner)
-	if !ok {
-		return fmt.Errorf("storage backend does not support range prune")
+	for _, b := range h.backends() {
+		rp, ok := b.(rangePruner)
+		if !ok {
+			return fmt.Errorf("storage backend does not support range prune")
+		}
+		if err := rp.pruneBefore(cutoff); err != nil {
+			return err
+		}
 	}
-	return rp.pruneBefore(cutoff)
+	h.maybeClearPGBound("range_prune", "cutoff", cutoff)
+	return nil
 }
 
 func (h *HybridStorage) Close() error {
-	return h.backend.Close()
+	h.mu.Lock()
+	stop := h.reconnectStop
+	done := h.reconnectDone
+	if stop != nil {
+		select {
+		case <-stop:
+		default:
+			close(stop)
+		}
+		h.reconnectStop = nil
+	}
+	h.mu.Unlock()
+	if done != nil {
+		<-done
+	}
+
+	var firstErr error
+	for _, b := range h.backends() {
+		if err := b.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
 }
 
 var _ Storage = (*HybridStorage)(nil)
diff --git a/devshard/storage/hybrid_test.go b/devshard/storage/hybrid_test.go
index 12ceaa9451..d79b699ed8 100644
--- a/devshard/storage/hybrid_test.go
+++ b/devshard/storage/hybrid_test.go
@@ -1,7 +1,10 @@
 package storage
 
 import (
+	"context"
+	"errors"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
@@ -9,7 +12,8 @@ import (
 )
 
 type recordingStorage struct {
-	lastMethod string
+	lastMethod     string
+	activeSessions []ActiveSession
 }
 
 func (r *recordingStorage) CreateSession(params CreateSessionParams) error {
@@ -22,7 +26,7 @@ func (r *recordingStorage) MarkSettled(escrowID string) error {
 }
 func (r *recordingStorage) ListActiveSessions() ([]ActiveSession, error) {
 	r.lastMethod = "ListActiveSessions"
-	return nil, nil
+	return r.activeSessions, nil
 }
 func (r *recordingStorage) AppendDiff(escrowID string, rec types.DiffRecord) error {
 	r.lastMethod = "AppendDiff"
@@ -97,9 +101,73 @@ func (r *recordingStorage) Close() error {
 	return nil
 }
 
+type failingPGStorage struct {
+	recordingStorage
+	err            error
+	hasSessions    bool
+	liveHasRows    bool
+	liveErr        error
+	liveCheckCalls int
+}
+
+func (f *failingPGStorage) CreateSession(params CreateSessionParams) error {
+	f.lastMethod = "CreateSession"
+	return f.err
+}
+
+func (f *failingPGStorage) HasAnySessions() bool {
+	return f.hasSessions
+}
+
+func (f *failingPGStorage) HasAnySessionsLive() (bool, error) {
+	f.liveCheckCalls++
+	return f.liveHasRows, f.liveErr
+}
+
+// failingPGStorageNoLive fails creates but cannot prove emptiness against the
+// database. The router must keep .pg-bound conservatively.
+type failingPGStorageNoLive struct {
+	recordingStorage
+	err error
+}
+
+func (f *failingPGStorageNoLive) CreateSession(params CreateSessionParams) error {
+	f.lastMethod = "CreateSession"
+	return f.err
+}
+
+func (f *failingPGStorageNoLive) HasAnySessions() bool { return false }
+
+type owningRecordingStorage struct {
+	recordingStorage
+	owned map[string]struct{}
+}
+
+func (o *owningRecordingStorage) HasEscrow(escrowID string) bool {
+	_, ok := o.owned[escrowID]
+	return ok
+}
+
+func (o *owningRecordingStorage) EscrowIDs() []string {
+	ids := make([]string, 0, len(o.owned))
+	for id := range o.owned {
+		ids = append(ids, id)
+	}
+	return ids
+}
+
+func (o *owningRecordingStorage) CreateSession(params CreateSessionParams) error {
+	o.lastMethod = "CreateSession"
+	if o.owned == nil {
+		o.owned = make(map[string]struct{})
+	}
+	o.owned[params.EscrowID] = struct{}{}
+	return nil
+}
+
 func TestHybridStorage_forwardsStorageMethods(t *testing.T) {
 	rec := &recordingStorage{}
-	h := NewHybridStorage(rec)
+	h := newHybridRouter(rec, nil, false, "")
 
 	require.NoError(t, h.CreateSession(CreateSessionParams{EscrowID: "e"}))
 	require.Equal(t, "CreateSession", rec.lastMethod)
@@ -162,3 +230,225 @@ func TestHybridStorage_forwardsStorageMethods(t *testing.T) {
 	require.NoError(t, h.Close())
 	require.Equal(t, "Close", rec.lastMethod)
 }
+
+func TestHybridStorage_ReconnectPromotesDegradedRouter(t *testing.T) {
+	sqlite := &owningRecordingStorage{owned: map[string]struct{}{"sqlite-owned": {}}}
+	h := newDegradedSQLiteRouter(sqlite, t.TempDir(), ErrStoragePostgresUnavailable)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	pg := &recordingStorage{}
+	attempts := 0
+	h.startPostgresReconnect(ctx, func(context.Context) (Storage, error) {
+		attempts++
+		if attempts == 1 {
+			return nil, errors.New("pg down")
+		}
+		return pg, nil
+	}, 5*time.Millisecond)
+
+	require.Eventually(t, func() bool {
+		h.mu.RLock()
+		degraded := h.degradedOwnerOnly
+		attached := h.pg == pg
+		h.mu.RUnlock()
+		return attached && !degraded
+	}, time.Second, 10*time.Millisecond)
+
+	require.NoError(t, h.CreateSession(CreateSessionParams{EscrowID: "new-pg"}))
+	require.Equal(t, "CreateSession", pg.lastMethod, "new sessions must use PG after promotion")
+}
+
+func TestHybridStorage_PromoteClosesIncomingBackendWhenAlreadyPromoted(t *testing.T) {
+	existing := &recordingStorage{}
+	incoming := &recordingStorage{}
+	h := newHybridRouter(nil, existing, true, "")
+
+	require.NoError(t, h.promotePostgres(incoming))
+	require.Same(t, existing, h.pg)
+	require.Equal(t, "Close", incoming.lastMethod)
+}
+
+func TestHybridStorage_PromotionHookFiresAfterReconnectAndImmediatelyAfterPromotion(t *testing.T) {
+	h := newDegradedSQLiteRouter(nil, t.TempDir(), ErrStoragePostgresUnavailable)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	first := make(chan struct{}, 1)
+	h.OnPostgresPromoted(func() { first <- struct{}{} })
+	h.startPostgresReconnect(ctx, func(context.Context) (Storage, error) {
+		return &recordingStorage{}, nil
+	}, 5*time.Millisecond)
+
+	require.Eventually(t, func() bool {
+		select {
+		case <-first:
+			return true
+		default:
+			return false
+		}
+	}, time.Second, 10*time.Millisecond)
+
+	second := make(chan struct{}, 1)
+	h.OnPostgresPromoted(func() { second <- struct{}{} })
+	require.Eventually(t, func() bool {
+		select {
+		case <-second:
+			return true
+		default:
+			return false
+		}
+	}, time.Second, 10*time.Millisecond)
+}
+
+func TestHybridStorage_ClearsPGBoundAfterFailedPGCreateWhenProvablyEmpty(t *testing.T) {
+	createErr := errors.New("pg insert failed")
+	pg := &failingPGStorage{err: createErr}
+	storeDir := t.TempDir()
+	h := newHybridRouter(nil, pg, true, storeDir)
+
+	err := h.CreateSession(CreateSessionParams{EscrowID: "pg-fail"})
+	require.ErrorIs(t, err, createErr)
+	require.Equal(t, "CreateSession", pg.lastMethod)
+	require.Equal(t, 1, pg.liveCheckCalls, "cleanup must verify emptiness against the DB")
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.False(t, pgBound, "stale .pg-bound must be cleared when PG is provably empty")
+	require.False(t, h.pgBoundSet)
+}
+
+func TestHybridStorage_KeepsPGBoundAfterFailedPGCreateWhenPGHasSessions(t *testing.T) {
+	createErr := errors.New("pg insert failed")
+	pg := &failingPGStorage{err: createErr, hasSessions: true}
+	storeDir := t.TempDir()
+	h := newHybridRouter(nil, pg, true, storeDir)
+
+	err := h.CreateSession(CreateSessionParams{EscrowID: "pg-fail"})
+	require.ErrorIs(t, err, createErr)
+	require.Equal(t, 0, pg.liveCheckCalls, "in-memory sessions already retain the marker")
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound, ".pg-bound must remain while PG reports sessions")
+	require.True(t, h.pgBoundSet)
+}
+
+func TestHybridStorage_KeepsPGBoundWhenLiveCheckFailsDuringOutage(t *testing.T) {
+	// A create that times out during a PG outage is ambiguous: the insert may
+	// have committed server-side. With the live emptiness check also failing,
+	// the marker must be kept.
+	createErr := errors.New("pg insert timed out")
+	pg := &failingPGStorage{err: createErr, liveErr: errors.New("pg unreachable")}
+	storeDir := t.TempDir()
+	h := newHybridRouter(nil, pg, true, storeDir)
+
+	err := h.CreateSession(CreateSessionParams{EscrowID: "pg-fail"})
+	require.ErrorIs(t, err, createErr)
+	require.Equal(t, 1, pg.liveCheckCalls)
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound, ".pg-bound must survive an outage where emptiness cannot be proven")
+	require.True(t, h.pgBoundSet)
+}
+
+func TestHybridStorage_KeepsPGBoundWhenFailedCreateActuallyCommitted(t *testing.T) {
+	// Ack-lost commit: the client saw an error but the DB has the row. The
+	// live check sees it and the marker must be kept.
+	createErr := errors.New("pg commit ack lost")
+	pg := &failingPGStorage{err: createErr, liveHasRows: true}
+	storeDir := t.TempDir()
+	h := newHybridRouter(nil, pg, true, storeDir)
+
+	err := h.CreateSession(CreateSessionParams{EscrowID: "pg-fail"})
+	require.ErrorIs(t, err, createErr)
+	require.Equal(t, 1, pg.liveCheckCalls)
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound, ".pg-bound must remain when the DB actually holds rows")
+	require.True(t, h.pgBoundSet)
+}
+
+func TestHybridStorage_KeepsPGBoundWhenBackendLacksLiveCheck(t *testing.T) {
+	createErr := errors.New("pg insert failed")
+	pg := &failingPGStorageNoLive{err: createErr}
+	storeDir := t.TempDir()
+	h := newHybridRouter(nil, pg, true, storeDir)
+
+	err := h.CreateSession(CreateSessionParams{EscrowID: "pg-fail"})
+	require.ErrorIs(t, err, createErr)
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound, "without a live check the marker must be kept conservatively")
+	require.True(t, h.pgBoundSet)
+}
+
+func TestHybridStorage_PruneKeepsPGBoundWhenLiveCheckFindsRows(t *testing.T) {
+	pg := &failingPGStorage{liveHasRows: true}
+	storeDir := t.TempDir()
+	require.NoError(t, WritePGBound(storeDir))
+	h := newHybridRouter(nil, pg, true, storeDir)
+	h.pgBoundSet = true
+
+	require.NoError(t, h.PruneEpoch(10))
+	require.Equal(t, 1, pg.liveCheckCalls, "prune cleanup must verify emptiness against the DB")
+
+	pgBound, err := ReadPGBound(storeDir)
+	require.NoError(t, err)
+	require.True(t, pgBound, ".pg-bound must remain when live PG rows exist")
+	require.True(t, h.pgBoundSet)
+}
+
+func TestHybridStorage_QuarantinesDuplicateBackendOwnership(t *testing.T) {
+	sqlite := &owningRecordingStorage{owned: map[string]struct{}{
+		"dupe":        {},
+		"sqlite-only": {},
+	}}
+	pg := &owningRecordingStorage{owned: map[string]struct{}{
+		"dupe":    {},
+		"pg-only": {},
+	}}
+	h := newHybridRouter(sqlite, pg, true, "")
+
+	require.ElementsMatch(t, []string{"dupe"}, h.conflictedEscrowIDs())
+	logs := captureStorageLogs(t)
+	h.logConflictedEscrows("test")
+	entry := requireStorageLogEntry(t, readStorageLogEntries(t, logs),
+		"devshard storage: escrow exists in both sqlite and postgres; quarantining conflicted escrows")
+	require.Equal(t, "test", entry["phase"])
+
+	err := h.CreateSession(CreateSessionParams{EscrowID: "dupe"})
+	require.ErrorIs(t, err, ErrEscrowBackendConflict)
+	_, err = h.GetSessionMeta("dupe")
+	require.ErrorIs(t, err, ErrEscrowBackendConflict)
+
+	require.NoError(t, h.MarkSettled("sqlite-only"))
+	require.Equal(t, "MarkSettled", sqlite.lastMethod)
+	require.Empty(t, pg.lastMethod)
+
+	require.NoError(t, h.MarkSettled("pg-only"))
+	require.Equal(t, "MarkSettled", pg.lastMethod)
+}
+
+func TestHybridStorage_ListActiveSessionsDedupesEscrowIDs(t *testing.T) {
+	sqlite := &recordingStorage{activeSessions: []ActiveSession{
+		{EscrowID: "dupe", EpochID: 9},
+		{EscrowID: "sqlite-only", EpochID: 9},
+	}}
+	pg := &recordingStorage{activeSessions: []ActiveSession{
+		{EscrowID: "dupe", EpochID: 10},
+		{EscrowID: "pg-only", EpochID: 10},
+	}}
+	h := newHybridRouter(sqlite, pg, true, "")
+
+	sessions, err := h.ListActiveSessions()
+	require.NoError(t, err)
+	require.Equal(t, []ActiveSession{
+		{EscrowID: "dupe", EpochID: 9},
+		{EscrowID: "sqlite-only", EpochID: 9},
+		{EscrowID: "pg-only", EpochID: 10},
+	}, sessions)
+}
diff --git a/devshard/storage/interface.go b/devshard/storage/interface.go
index 6b078c56bf..9d637074d6 100644
--- a/devshard/storage/interface.go
+++ b/devshard/storage/interface.go
@@ -25,6 +25,10 @@ var ErrSessionVersionRequired = errors.New("session version required")
 // state-root composition from attaching to live state mid-session.
 var ErrSessionVersionConflict = errors.New("session version conflict")
 
+// ErrEscrowBackendConflict is returned when both SQLite and Postgres claim the
+// same escrow. The router refuses to choose a fork silently.
+var ErrEscrowBackendConflict = errors.New("escrow exists in multiple storage backends")
+
 // ErrSnapshotNotFound is returned when no snapshot exists for a session.
 var ErrSnapshotNotFound = errors.New("snapshot not found")
 
@@ -127,8 +131,8 @@ type ActiveSession struct {
 // state root) for GET /v1/state after RAM prune. Late MsgValidation on
 // sealed ids still returns ErrInferenceSealed and does not read this snapshot.
 type InferenceRow struct {
-	InferenceID uint64
-	SealedNonce uint64
+	InferenceID        uint64
+	SealedNonce        uint64
 	ObsPresent         bool
 	SealedStatus       uint32
 	SealedExecutorSlot uint32
diff --git a/devshard/storage/managed.go b/devshard/storage/managed.go
index 7c4ce69e16..926ad78a9c 100644
--- a/devshard/storage/managed.go
+++ b/devshard/storage/managed.go
@@ -84,6 +84,17 @@ func (m *ManagedStorage) CurrentEpochID() uint64 {
 	return m.maxObservedEpoch.Load()
 }
 
+func (m *ManagedStorage) PruneCutoff() uint64 {
+	if m.epochs != nil {
+		m.observe(m.epochs.CurrentEpochID())
+	}
+	maxE := m.maxObservedEpoch.Load()
+	if maxE+1 <= m.retain {
+		return 0
+	}
+	return maxE + 1 - m.retain
+}
+
 // Start runs a single catch-up prune after recovery. Epoch transitions must
 // trigger additional PruneOnce calls via the host's epoch-change hook.
 func (m *ManagedStorage) Start() {
@@ -110,10 +121,10 @@ func (m *ManagedStorage) PruneOnce(_ context.Context) {
 		m.observe(m.epochs.CurrentEpochID())
 	}
 	maxE := m.maxObservedEpoch.Load()
-	if maxE+1 <= m.retain {
+	cutoff := m.PruneCutoff()
+	if cutoff == 0 {
 		return // not enough epochs yet
 	}
-	cutoff := maxE + 1 - m.retain // every epoch < cutoff is pruneable
 
 	m.mu.Lock()
 	defer m.mu.Unlock()
diff --git a/devshard/storage/migrate.go b/devshard/storage/migrate.go
index ee073462a3..0cd5596784 100644
--- a/devshard/storage/migrate.go
+++ b/devshard/storage/migrate.go
@@ -140,8 +140,7 @@ func MigrateLegacySQLite(legacyPath string, dest Storage, resolveEpoch EpochReso
 
 		version := ls.version
 		if version == "" {
-			// Empty legacy version → embedded dapi runtime bind ("v1"), not protocol tag ("v2").
-			version = types.LegacyRouteSessionVersion
+			version = types.SessionVersionV1
 		}
 		if err := dest.CreateSession(CreateSessionParams{
 			EscrowID:       ls.escrowID,
diff --git a/devshard/storage/migrate_test.go b/devshard/storage/migrate_test.go
index 424fbe600f..6beffbccc5 100644
--- a/devshard/storage/migrate_test.go
+++ b/devshard/storage/migrate_test.go
@@ -180,9 +180,8 @@ func TestMigrateLegacy_RoundTrip(t *testing.T) {
 	require.NoError(t, err)
 }
 
-// TestMigrateLegacy_NormalizesEmptyVersion exercises legacy migration: a SQLite
-// row with an empty version column is stamped with LegacyRouteSessionVersion
-// before CreateSession so the destination store carries an explicit tag.
+// TestMigrateLegacy_NormalizesEmptyVersion exercises migration for older rows
+// whose version column was empty.
 func TestMigrateLegacy_NormalizesEmptyVersion(t *testing.T) {
 	legacyPath := writeLegacyDB(t, []legacyTestSession{
 		{escrowID: "no-ver", version: "", status: "active", balance: 1000, latestNonce: 2, lastFinalized: 1},
@@ -197,8 +196,8 @@ func TestMigrateLegacy_NormalizesEmptyVersion(t *testing.T) {
 
 	meta, err := dest.GetSessionMeta("no-ver")
 	require.NoError(t, err)
-	require.Equal(t, types.LegacyRouteSessionVersion, meta.Version,
-		"legacy empty version must be stamped with LegacyRouteSessionVersion")
+	require.Equal(t, types.SessionVersionV1, meta.Version,
+		"empty migrated version must be stamped with SessionVersionV1")
 	require.Equal(t, uint64(9), meta.EpochID)
 	require.Equal(t, uint64(2), meta.LatestNonce)
 	require.Equal(t, uint64(1), meta.LastFinalized)
diff --git a/devshard/storage/postgres.go b/devshard/storage/postgres.go
index b0241b3b8c..6e12b460d8 100644
--- a/devshard/storage/postgres.go
+++ b/devshard/storage/postgres.go
@@ -48,6 +48,11 @@ const (
 	// statement_timeout it also covers the time spent acquiring a pooled
 	// connection (pool exhaustion), which the server-side timeout cannot.
 	postgresOpTimeout = 8 * time.Second
+	// postgresLivePresenceTimeout bounds the HasAnySessionsLive query. It is
+	// deliberately short: the check runs under HybridStorage.markerMu right
+	// after a failed (often timed-out) create, so it must not extend the lock
+	// hold time by another full op timeout during an outage.
+	postgresLivePresenceTimeout = 2 * time.Second
 )
 
 const (
@@ -271,6 +276,49 @@ func (s *Postgres) lookupEpoch(escrowID string) (uint64, error) {
 	return epochID, nil
 }
 
+// HasEscrow reports whether escrowID is present in the in-memory routing index
+// (rebuilt at boot from devshard_session_index). It lets the hybrid router
+// resolve which backend owns an escrow.
+func (s *Postgres) HasEscrow(escrowID string) bool {
+	_, err := s.lookupEpoch(escrowID)
+	return err == nil
+}
+
+// HasAnySessions reports whether any escrow is still held in Postgres. The
+// in-memory index is kept in sync with devshard_session_index by CreateSession
+// and by prune, so this is an accurate emptiness check without a round trip.
+// The hybrid router uses it to clear the .pg-bound marker once PG is drained.
+func (s *Postgres) HasAnySessions() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.escrowIdx) > 0
+}
+
+// EscrowIDs returns a snapshot of escrows in the in-memory routing index.
+func (s *Postgres) EscrowIDs() []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	ids := make([]string, 0, len(s.escrowIdx))
+	for id := range s.escrowIdx {
+		ids = append(ids, id)
+	}
+	return ids
+}
+
+// HasAnySessionsLive checks devshard_session_index in the database itself.
+// The hybrid router uses it before clearing .pg-bound after a failed create:
+// a timed-out CreateSession may have committed server-side without updating
+// the in-memory index, so emptiness must be proven against the DB, not RAM.
+func (s *Postgres) HasAnySessionsLive() (bool, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), postgresLivePresenceTimeout)
+	defer cancel()
+	var exists bool
+	if err := s.pool.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM devshard_session_index)`).Scan(&exists); err != nil {
+		return false, err
+	}
+	return exists, nil
+}
+
 // opCtx returns a context bounding a single storage operation. It caps both the
 // pooled-connection acquire wait and total query time Go-side; statement_timeout
 // and lock_timeout provide the matching server-side bounds. Callers must defer
diff --git a/devshard/storage/postgres_test.go b/devshard/storage/postgres_test.go
index a693eab5b1..11cb02ee1d 100644
--- a/devshard/storage/postgres_test.go
+++ b/devshard/storage/postgres_test.go
@@ -301,7 +301,7 @@ func TestMigrateLegacy_IntoPostgresStorage(t *testing.T) {
 	store, err := NewStorage(context.Background(), t.TempDir())
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = store.Close() })
-	pg, ok := store.(*HybridStorage).backend.(*Postgres)
+	pg, ok := store.(*HybridStorage).pg.(*Postgres)
 	require.True(t, ok)
 
 	n, err := MigrateLegacySQLite(legacyPath, store, func(escrowID string) (uint64, error) {
diff --git a/devshard/storage/postgres_timeout_test.go b/devshard/storage/postgres_timeout_test.go
index c28ea117b9..a8397048ad 100644
--- a/devshard/storage/postgres_timeout_test.go
+++ b/devshard/storage/postgres_timeout_test.go
@@ -41,6 +41,35 @@ func TestPostgres_TimeoutsConfigured(t *testing.T) {
 	require.Equal(t, "3s", lockTimeout)
 }
 
+// TestPostgres_HasAnySessionsLive proves the live emptiness check reflects the
+// database state, not the in-memory index. It backs the .pg-bound cleanup path
+// where a timed-out create may have committed server-side.
+func TestPostgres_HasAnySessionsLive(t *testing.T) {
+	pg := newTestPostgres(t)
+
+	has, err := pg.HasAnySessionsLive()
+	require.NoError(t, err)
+	require.False(t, has, "fresh store must be provably empty")
+
+	require.NoError(t, pg.CreateSession(paramsForEpoch("live-check", 11)))
+
+	// Wipe the in-memory index to simulate a session this process never
+	// learned about (ack-lost commit); the live check must still see it.
+	pg.mu.Lock()
+	pg.escrowIdx = make(map[string]uint64)
+	pg.mu.Unlock()
+	require.False(t, pg.HasAnySessions(), "in-memory index is blind")
+
+	has, err = pg.HasAnySessionsLive()
+	require.NoError(t, err)
+	require.True(t, has, "live check must see the committed session")
+
+	require.NoError(t, pg.PruneEpoch(11))
+	has, err = pg.HasAnySessionsLive()
+	require.NoError(t, err)
+	require.False(t, has, "pruned store must be provably empty again")
+}
+
 // TestPostgres_StatementTimeoutAborts proves a stuck query is aborted server-side
 // rather than hanging. pg_sleep(30) far exceeds statement_timeout (5s); the call
 // must return an error well before the sleep would complete.
diff --git a/devshard/storage/sqlite.go b/devshard/storage/sqlite.go
index 82e71748ce..97eda6f08e 100644
--- a/devshard/storage/sqlite.go
+++ b/devshard/storage/sqlite.go
@@ -249,6 +249,36 @@ func (s *SQLite) openOrLoadPool(epochID uint64) (*epochPool, error) {
 	return p, nil
 }
 
+// HasEscrow reports whether escrowID is present in the in-memory routing index
+// (rebuilt at boot from _meta.db). It lets the hybrid router resolve which
+// backend owns an escrow without a disk round trip.
+func (s *SQLite) HasEscrow(escrowID string) bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	_, ok := s.escrowIdx[escrowID]
+	return ok
+}
+
+// HasAnySessions reports whether SQLite still holds any session after startup
+// reconciliation. HybridStorage uses it to decide whether SQLite must stay
+// attached while Postgres handles new escrows.
+func (s *SQLite) HasAnySessions() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.escrowIdx) > 0
+}
+
+// EscrowIDs returns a snapshot of escrows in the in-memory routing index.
+func (s *SQLite) EscrowIDs() []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	ids := make([]string, 0, len(s.escrowIdx))
+	for id := range s.escrowIdx {
+		ids = append(ids, id)
+	}
+	return ids
+}
+
 // poolFor returns the pool for the epoch this escrow belongs to, opening it
 // lazily on first access. The escrow_id -> epoch_id lookup is in-memory
 // (rebuilt at boot from _meta.db); the pool itself is opened on demand so a
@@ -1019,7 +1049,7 @@ func (s *SQLite) DrainInferenceValidationObs(escrowID string, inferenceID uint64
 		return fmt.Errorf("drain inference validation obs select: %w", err)
 	}
 	type row struct {
-		slotID               uint32
+		slotID              uint32
 		required, completed uint32
 	}
 	var live []row
diff --git a/devshard/storage/storage_mode.go b/devshard/storage/storage_mode.go
index 7f5083842e..9adead6168 100644
--- a/devshard/storage/storage_mode.go
+++ b/devshard/storage/storage_mode.go
@@ -46,6 +46,35 @@ func HasSQLiteSessions(storeDir string) (bool, error) {
 	return count > 0, nil
 }
 
+// HasSQLiteArtifacts reports whether storeDir contains files that could belong
+// to a SQLite-backed store. Unlike NewSQLite, it never creates _meta.db.
+func HasSQLiteArtifacts(storeDir string) (bool, error) {
+	if _, err := os.Stat(MetaDBPath(storeDir)); err != nil {
+		if !os.IsNotExist(err) {
+			return false, err
+		}
+	} else {
+		return true, nil
+	}
+
+	entries, err := os.ReadDir(storeDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+	for _, ent := range entries {
+		if ent.IsDir() {
+			continue
+		}
+		if epochFileRegex.MatchString(ent.Name()) {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
 // ReadPGBound reports whether the Postgres-mode marker file exists.
 func ReadPGBound(storeDir string) (bool, error) {
 	_, err := os.Stat(PGBoundPath(storeDir))
@@ -65,12 +94,38 @@ func WritePGBound(storeDir string) error {
 	}
 	target := PGBoundPath(storeDir)
 	tmp := target + ".tmp"
-	if err := os.WriteFile(tmp, []byte("1\n"), 0o644); err != nil {
+	f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
+	if err != nil {
+		return fmt.Errorf("open pg-bound tmp: %w", err)
+	}
+	if _, err := f.Write([]byte("1\n")); err != nil {
+		_ = f.Close()
+		_ = os.Remove(tmp)
 		return fmt.Errorf("write pg-bound tmp: %w", err)
 	}
+	if err := f.Sync(); err != nil {
+		_ = f.Close()
+		_ = os.Remove(tmp)
+		return fmt.Errorf("sync pg-bound tmp: %w", err)
+	}
+	if err := f.Close(); err != nil {
+		_ = os.Remove(tmp)
+		return fmt.Errorf("close pg-bound tmp: %w", err)
+	}
 	if err := os.Rename(tmp, target); err != nil {
 		_ = os.Remove(tmp)
 		return fmt.Errorf("rename pg-bound: %w", err)
 	}
+	dir, err := os.Open(storeDir)
+	if err != nil {
+		return fmt.Errorf("open store dir for sync: %w", err)
+	}
+	if err := dir.Sync(); err != nil {
+		_ = dir.Close()
+		return fmt.Errorf("sync store dir: %w", err)
+	}
+	if err := dir.Close(); err != nil {
+		return fmt.Errorf("close store dir: %w", err)
+	}
 	return nil
 }
diff --git a/devshard/storage/storage_mode_test.go b/devshard/storage/storage_mode_test.go
index fe3612cb22..497d813239 100644
--- a/devshard/storage/storage_mode_test.go
+++ b/devshard/storage/storage_mode_test.go
@@ -2,6 +2,7 @@ package storage
 
 import (
 	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -44,6 +45,33 @@ func TestHasSQLiteSessions_corruptMeta(t *testing.T) {
 	require.Error(t, err)
 }
 
+func TestHasSQLiteArtifacts_missingStore(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "missing")
+	ok, err := HasSQLiteArtifacts(dir)
+	require.NoError(t, err)
+	require.False(t, ok)
+}
+
+func TestHasSQLiteArtifacts_metaDB(t *testing.T) {
+	dir := t.TempDir()
+	db, err := openMetaDB(MetaDBPath(dir))
+	require.NoError(t, err)
+	require.NoError(t, db.Close())
+
+	ok, err := HasSQLiteArtifacts(dir)
+	require.NoError(t, err)
+	require.True(t, ok)
+}
+
+func TestHasSQLiteArtifacts_epochDB(t *testing.T) {
+	dir := t.TempDir()
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "epoch_7.db"), []byte{}, 0o644))
+
+	ok, err := HasSQLiteArtifacts(dir)
+	require.NoError(t, err)
+	require.True(t, ok)
+}
+
 func TestReadPGBound_absent(t *testing.T) {
 	dir := t.TempDir()
 	ok, err := ReadPGBound(dir)
diff --git a/devshard/transport/client.go b/devshard/transport/client.go
index bf61d98831..6ce5e39734 100644
--- a/devshard/transport/client.go
+++ b/devshard/transport/client.go
@@ -18,7 +18,6 @@ import (
 
 	json "github.com/goccy/go-json"
 
-	devshardpkg "devshard"
 	"devshard/host"
 	"devshard/logging"
 	"devshard/signing"
@@ -46,10 +45,6 @@ func getTransport(baseURL string) *http.Transport {
 	return actual.(*http.Transport)
 }
 
-// DefaultRoutePrefix is the legacy URL prefix dapi mounts the in-process
-// HostManager under. Versioned binaries use devshard.VersionedRoutePrefix(...).
-const DefaultRoutePrefix = devshardpkg.LegacyRoutePrefix
-
 func transportAddress(baseURL string) string {
 	parsed, err := url.Parse(strings.TrimSpace(baseURL))
 	if err == nil && parsed != nil && parsed.Host != "" {
@@ -65,7 +60,7 @@ type ClientConfig struct {
 	VerifyTimeout    time.Duration                   // verify-timeout, default 3m
 	QueryTimeout     time.Duration                   // diffs, mempool GETs, default 30s
 	StreamCallback   func(nonce uint64, line string) // if set, receives raw SSE data lines during inference
-	RoutePrefix      string                          // path prefix for all session routes; default /v1/devshard
+	RoutePrefix      string                          // path prefix for all session routes; callers should pass /devshard/{version}
 	ProtocolVersion  types.ProtocolVersion           // runtime protocol version configured for the escrow
 	// ParticipantKey is the canonical participant identifier passed to
 	// the admission controller for both AllowRequest and ObserveResult.
@@ -140,7 +135,6 @@ func DefaultClientConfig() ClientConfig {
 		GossipTimeout:    10 * time.Second,
 		VerifyTimeout:    3 * time.Minute,
 		QueryTimeout:     30 * time.Second,
-		RoutePrefix:      DefaultRoutePrefix,
 	}
 }
 
@@ -161,7 +155,6 @@ func NewHTTPClient(baseURL, escrowID string, signer signing.Signer, cfgs ...Clie
 	if len(cfgs) > 0 {
 		cfg = cfgs[0]
 	}
-	cfg.RoutePrefix = devshardpkg.NormalizeRoutePrefix(cfg.RoutePrefix)
 	return &HTTPClient{
 		baseURL:     baseURL,
 		routePrefix: cfg.RoutePrefix,
@@ -258,7 +251,7 @@ func (c *HTTPClient) Send(ctx context.Context, req host.HostRequest, stream io.W
 	contentType := resp.Header.Get("Content-Type")
 	if strings.HasPrefix(contentType, "text/event-stream") {
 		cr := &countingReader{r: resp.Body}
-		result, err := c.parseSSEResponse(cr, stream, receiptHandler)
+		result, err := c.parseSSEResponse(ctx, cr, stream, receiptHandler)
 		if result != nil {
 			result.StreamBytesRead = cr.n
 		}
@@ -292,7 +285,7 @@ func (c *HTTPClient) Send(ctx context.Context, req host.HostRequest, stream io.W
 //     ([DONE] or devshard_receipt) from a clean EOF that arrives *before* one.
 //     bufio.Scanner squashes io.EOF into a nil error, so the caller cannot tell
 //     a successful completion from a peer / middlebox closing the body early.
-func (c *HTTPClient) parseSSEResponse(r io.Reader, stream io.Writer, receiptHandler func()) (*host.HostResponse, error) {
+func (c *HTTPClient) parseSSEResponse(ctx context.Context, r io.Reader, stream io.Writer, receiptHandler func()) (*host.HostResponse, error) {
 	br := bufio.NewReaderSize(r, 64<<10)
 	var result host.HostResponse
 	var writeErrLogged bool
@@ -307,6 +300,16 @@ func (c *HTTPClient) parseSSEResponse(r io.Reader, stream io.Writer, receiptHand
 		}
 		if readErr != nil {
 			if readErr == io.EOF {
+				// A cancelled context (client disconnect, race resolved, drain)
+				// can surface as a clean EOF once the peer closes the body after
+				// we abort the request. The receipt event sets sawTerminator
+				// early, so without this check a cancelled stream that never
+				// carried content would be reported as a successful empty
+				// response and wrongly scored against the host. Report the
+				// cancellation as the error it is.
+				if ctxErr := ctx.Err(); ctxErr != nil {
+					return &result, fmt.Errorf("read SSE stream: %w", ctxErr)
+				}
 				if !sawTerminator {
 					return &result, ErrSSEStreamTruncated
 				}
@@ -709,5 +712,11 @@ func (c *HTTPClient) observeTransportFailure(path string, err error) {
 	if c == nil || c.config.Admission == nil || strings.TrimSpace(c.config.ParticipantKey) == "" {
 		return
 	}
+	// A cancelled request context is our own signal (client disconnect, race
+	// resolved, drain), not a fault of the host. Attributing it as a transport
+	// failure would quarantine a healthy host, so skip it.
+	if errors.Is(err, context.Canceled) {
+		return
+	}
 	c.config.Admission.ObserveTransportFailure(c.config.ParticipantKey, path, err)
 }
diff --git a/devshard/transport/client_test.go b/devshard/transport/client_test.go
index 7f3bedc97a..f77f3fe92d 100644
--- a/devshard/transport/client_test.go
+++ b/devshard/transport/client_test.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 	"time"
 
@@ -48,13 +49,15 @@ func setupClientTestEnv(t *testing.T) (*HTTPClient, *httptest.Server, *signing.S
 	require.NoError(t, err)
 
 	e := echo.New()
-	g := e.Group("/v1/devshard")
+	g := e.Group(testRoutePrefix)
 	srv.Register(g)
 
 	ts := httptest.NewServer(e)
 	t.Cleanup(ts.Close)
 
-	client := NewHTTPClient(ts.URL, "escrow-1", userSigner)
+	cfg := DefaultClientConfig()
+	cfg.RoutePrefix = testRoutePrefix
+	client := NewHTTPClient(ts.URL, "escrow-1", userSigner, cfg)
 	return client, ts, userSigner, group
 }
 
@@ -98,7 +101,9 @@ func TestHTTPClient_Send_ReturnsUpstreamStatusError(t *testing.T) {
 	}))
 	t.Cleanup(ts.Close)
 
-	client := NewHTTPClient(ts.URL, "escrow-1", userSigner)
+	cfg := DefaultClientConfig()
+	cfg.RoutePrefix = testRoutePrefix
+	client := NewHTTPClient(ts.URL, "escrow-1", userSigner, cfg)
 	_, err := client.Send(context.Background(), host.HostRequest{Nonce: 1}, nil, nil)
 	require.Error(t, err)
 
@@ -118,6 +123,7 @@ func TestHTTPClient_Send_NoPayloadUsesQueryTimeout(t *testing.T) {
 	t.Cleanup(srv.Close)
 
 	cfg := DefaultClientConfig()
+	cfg.RoutePrefix = testRoutePrefix
 	cfg.InferenceTimeout = time.Second
 	cfg.QueryTimeout = 25 * time.Millisecond
 	client := NewHTTPClient(srv.URL, "escrow-1", signer, cfg)
@@ -189,7 +195,7 @@ func TestParseSSE_PartialResult(t *testing.T) {
 	// Use a reader that returns the data then an error (simulating connection drop).
 	r := &truncatedReader{data: []byte(sseData)}
 
-	result, err := client.parseSSEResponse(r, nil, nil)
+	result, err := client.parseSSEResponse(context.Background(), r, nil, nil)
 	require.Error(t, err, "should return error from broken stream")
 	require.NotNil(t, result, "should return partial result")
 	require.Equal(t, uint64(1), result.Nonce)
@@ -315,6 +321,7 @@ func TestHTTPClient_Send_ObservesUpstream503(t *testing.T) {
 		GossipTimeout:    DefaultClientConfig().GossipTimeout,
 		VerifyTimeout:    DefaultClientConfig().VerifyTimeout,
 		QueryTimeout:     DefaultClientConfig().QueryTimeout,
+		RoutePrefix:      testRoutePrefix,
 		ParticipantKey:   "shared-host",
 		Admission:        admission,
 	})
@@ -344,3 +351,57 @@ func (c lineCollector) Write(p []byte) (int, error) {
 	c(string(p))
 	return len(p), nil
 }
+
+const receiptOnlySSE = "data: {\"devshard_receipt\":{\"state_sig\":\"c2ln\",\"state_hash\":\"aGFzaA==\",\"nonce\":1,\"receipt\":\"cmVjZWlwdA==\",\"confirmed_at\":1000}}\n\n"
+
+func TestParseSSE_CancelledContextReportsCancellation(t *testing.T) {
+	// A cancelled attempt (client disconnect, race resolved, drain) can see the
+	// peer close with a clean EOF after the receipt already arrived. The receipt
+	// sets the terminator, so without a context check this would read as a
+	// successful empty response and be scored against the host. It must instead
+	// surface as the cancellation it is.
+	client := &HTTPClient{config: DefaultClientConfig()}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	result, err := client.parseSSEResponse(ctx, strings.NewReader(receiptOnlySSE), nil, nil)
+	require.Error(t, err)
+	require.ErrorIs(t, err, context.Canceled)
+	require.NotNil(t, result)
+	require.NotNil(t, result.Receipt, "receipt should still be extracted from the partial stream")
+}
+
+func TestParseSSE_ReceiptThenCleanEOFSucceeds(t *testing.T) {
+	// Without cancellation, a receipt-terminated stream that closes cleanly is a
+	// successful completion, even when it carried no content. This guards against
+	// the context check regressing the normal empty-but-complete path.
+	client := &HTTPClient{config: DefaultClientConfig()}
+
+	result, err := client.parseSSEResponse(context.Background(), strings.NewReader(receiptOnlySSE), nil, nil)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Equal(t, uint64(1), result.Nonce)
+	require.NotNil(t, result.Receipt)
+}
+
+func TestObserveTransportFailure_IgnoresContextCancellation(t *testing.T) {
+	admission := &stubAdmissionController{}
+	client := &HTTPClient{config: DefaultClientConfig()}
+	client.config.ParticipantKey = "shared-host"
+	client.config.Admission = admission
+
+	const path = "/sessions/escrow-1/chat/completions"
+
+	// Our own cancellation must never quarantine the host, whether it arrives
+	// bare or wrapped.
+	client.observeTransportFailure(path, context.Canceled)
+	client.observeTransportFailure(path, fmt.Errorf("POST %s: %w", path, context.Canceled))
+	require.Empty(t, admission.observed, "cancellation must not be reported as a transport failure")
+
+	// A genuine transport error is still reported.
+	client.observeTransportFailure(path, errors.New("connection refused"))
+	require.Len(t, admission.observed, 1)
+	require.Contains(t, admission.observed[0], "shared-host")
+	require.Contains(t, admission.observed[0], "transport")
+}
diff --git a/devshard/transport/server.go b/devshard/transport/server.go
index 672fdcb6db..323fcd7a39 100644
--- a/devshard/transport/server.go
+++ b/devshard/transport/server.go
@@ -101,7 +101,7 @@ func (s *Server) Host() *host.Host { return s.host }
 func (s *Server) SetGossip(g *gossip.Gossip) { s.gossip = g }
 
 // Register mounts all devshard routes on the given echo group.
-// The caller typically mounts this under /v1/devshard.
+// Public callers should mount this under a versioned /devshard/{version} prefix.
 func (s *Server) Register(g *echo.Group) {
 	g.Use(observability.EchoMiddleware())
 	g.Use(observability.RequestIDMiddleware)
diff --git a/devshard/transport/server_terminal_test.go b/devshard/transport/server_terminal_test.go
index c355c5d234..639bc894c0 100644
--- a/devshard/transport/server_terminal_test.go
+++ b/devshard/transport/server_terminal_test.go
@@ -19,7 +19,7 @@ func TestServer_Inference_OwnerErr_RecordsTerminal(t *testing.T) {
 	before := testutil.ToFloat64(counter)
 
 	body := []byte(`{}`)
-	rec := env.doPostAs(t, "/v1/devshard/sessions/escrow-1/chat/completions", body, env.hostSigner)
+	rec := env.doPostAs(t, testSessionPath("/chat/completions"), body, env.hostSigner)
 	if rec.Code != 403 {
 		t.Fatalf("status = %d, want 403", rec.Code)
 	}
diff --git a/devshard/transport/server_test.go b/devshard/transport/server_test.go
index 1f35eed369..2d049dcd37 100644
--- a/devshard/transport/server_test.go
+++ b/devshard/transport/server_test.go
@@ -34,6 +34,12 @@ type serverTestEnv struct {
 	config     types.SessionConfig
 }
 
+const testRoutePrefix = "/devshard/test"
+
+func testSessionPath(path string) string {
+	return testRoutePrefix + "/sessions/escrow-1" + path
+}
+
 func setupServerEnv(t *testing.T) *serverTestEnv {
 	t.Helper()
 	hostSigner := testutil.MustGenerateKey(t)
@@ -61,7 +67,7 @@ func setupServerEnv(t *testing.T) *serverTestEnv {
 	require.NoError(t, err)
 
 	e := echo.New()
-	g := e.Group("/v1/devshard")
+	g := e.Group(testRoutePrefix)
 	srv.Register(g)
 
 	return &serverTestEnv{
@@ -121,7 +127,7 @@ func TestServer_Inference_ValidAuth(t *testing.T) {
 	body, err := json.Marshal(ir)
 	require.NoError(t, err)
 
-	rec := env.doPost(t, "/v1/devshard/sessions/escrow-1/chat/completions", body)
+	rec := env.doPost(t, testSessionPath("/chat/completions"), body)
 	require.Equal(t, http.StatusOK, rec.Code, "body: %s", rec.Body.String())
 	require.Equal(t, "text/event-stream", rec.Header().Get("Content-Type"))
 
@@ -159,7 +165,7 @@ func TestServer_Inference_NoAuth(t *testing.T) {
 	env := setupServerEnv(t)
 
 	body := []byte(`{}`)
-	req := httptest.NewRequest(http.MethodPost, "/v1/devshard/sessions/escrow-1/chat/completions",
+	req := httptest.NewRequest(http.MethodPost, testSessionPath("/chat/completions"),
 		strings.NewReader(string(body)))
 	req.Header.Set("Content-Type", "application/json")
 	rec := httptest.NewRecorder()
@@ -176,7 +182,7 @@ func TestServer_Inference_NotInGroup(t *testing.T) {
 	sig, err := SignRequest(outsider, "escrow-1", body, ts)
 	require.NoError(t, err)
 
-	req := httptest.NewRequest(http.MethodPost, "/v1/devshard/sessions/escrow-1/chat/completions",
+	req := httptest.NewRequest(http.MethodPost, testSessionPath("/chat/completions"),
 		strings.NewReader(string(body)))
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set(HeaderSignature, hex.EncodeToString(sig))
@@ -199,11 +205,11 @@ func TestServer_GetDiffs(t *testing.T) {
 		Payload: &PayloadJSON{Prompt: testutil.TestPrompt, Model: "llama", InputLength: 100, MaxTokens: 50, StartedAt: 1000},
 	}
 	body, _ := json.Marshal(ir)
-	rec := env.doPost(t, "/v1/devshard/sessions/escrow-1/chat/completions", body)
+	rec := env.doPost(t, testSessionPath("/chat/completions"), body)
 	require.Equal(t, http.StatusOK, rec.Code)
 
 	// Now GET diffs.
-	rec = env.doGet(t, "/v1/devshard/sessions/escrow-1/diffs?from=1&to=1")
+	rec = env.doGet(t, testSessionPath("/diffs?from=1&to=1"))
 	require.Equal(t, http.StatusOK, rec.Code)
 
 	var diffs []json.RawMessage
@@ -224,11 +230,11 @@ func TestServer_GetMempool(t *testing.T) {
 		Payload: &PayloadJSON{Prompt: testutil.TestPrompt, Model: "llama", InputLength: 100, MaxTokens: 50, StartedAt: 1000},
 	}
 	body, _ := json.Marshal(ir)
-	rec := env.doPost(t, "/v1/devshard/sessions/escrow-1/chat/completions", body)
+	rec := env.doPost(t, testSessionPath("/chat/completions"), body)
 	require.Equal(t, http.StatusOK, rec.Code)
 
 	// GET mempool.
-	rec = env.doGet(t, "/v1/devshard/sessions/escrow-1/mempool")
+	rec = env.doGet(t, testSessionPath("/mempool"))
 	require.Equal(t, http.StatusOK, rec.Code)
 
 	var result struct {
@@ -248,14 +254,14 @@ func TestServer_RateLimit(t *testing.T) {
 	require.NoError(t, err)
 
 	e := echo.New()
-	g := e.Group("/v1/devshard")
+	g := e.Group(testRoutePrefix)
 	srv.Register(g)
 
 	body := []byte(`{}`)
 	doReq := func() int {
 		ts := time.Now().Unix()
 		sig, _ := SignRequest(env.userSigner, "escrow-1", body, ts)
-		req := httptest.NewRequest(http.MethodPost, "/v1/devshard/sessions/escrow-1/chat/completions",
+		req := httptest.NewRequest(http.MethodPost, testSessionPath("/chat/completions"),
 			strings.NewReader(string(body)))
 		req.Header.Set("Content-Type", "application/json")
 		req.Header.Set(HeaderSignature, hex.EncodeToString(sig))
@@ -325,7 +331,7 @@ func TestHandleGossipNonce_WarmKey(t *testing.T) {
 	require.NoError(t, err)
 
 	e := echo.New()
-	g := e.Group("/v1/devshard")
+	g := e.Group(testRoutePrefix)
 	srv.Register(g)
 
 	// Apply diffs through the host to populate storage.
@@ -362,7 +368,7 @@ func TestHandleGossipNonce_WarmKey(t *testing.T) {
 	sig, err := SignRequest(warmSigner, "escrow-1", body, ts)
 	require.NoError(t, err)
 
-	req := httptest.NewRequest(http.MethodPost, "/v1/devshard/sessions/escrow-1/gossip/nonce", strings.NewReader(string(body)))
+	req := httptest.NewRequest(http.MethodPost, testSessionPath("/gossip/nonce"), strings.NewReader(string(body)))
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set(HeaderSignature, hex.EncodeToString(sig))
 	req.Header.Set(HeaderTimestamp, fmt.Sprintf("%d", ts))
@@ -394,7 +400,7 @@ func TestServer_StreamingInference(t *testing.T) {
 	body, err := json.Marshal(ir)
 	require.NoError(t, err)
 
-	rec := env.doPost(t, "/v1/devshard/sessions/escrow-1/chat/completions", body)
+	rec := env.doPost(t, testSessionPath("/chat/completions"), body)
 	require.Equal(t, http.StatusOK, rec.Code)
 	require.Equal(t, "text/event-stream", rec.Header().Get("Content-Type"))
 
@@ -446,14 +452,14 @@ func (env *serverTestEnv) doPostAs(t *testing.T, path string, body []byte, signe
 func TestServer_Inference_GroupMemberRejected(t *testing.T) {
 	env := setupServerEnv(t)
 	body := []byte(`{}`)
-	rec := env.doPostAs(t, "/v1/devshard/sessions/escrow-1/chat/completions", body, env.hostSigner)
+	rec := env.doPostAs(t, testSessionPath("/chat/completions"), body, env.hostSigner)
 	require.Equal(t, http.StatusForbidden, rec.Code)
 }
 
 func TestServer_VerifyTimeout_GroupMemberRejected(t *testing.T) {
 	env := setupServerEnv(t)
 	body := []byte(`{}`)
-	rec := env.doPostAs(t, "/v1/devshard/sessions/escrow-1/verify-timeout", body, env.hostSigner)
+	rec := env.doPostAs(t, testSessionPath("/verify-timeout"), body, env.hostSigner)
 	require.Equal(t, http.StatusForbidden, rec.Code)
 }
 
@@ -462,7 +468,7 @@ func TestServer_ChallengeReceipt_GroupMemberAllowed(t *testing.T) {
 	// Group members (peer hosts) must be allowed to call ChallengeReceipt
 	// during timeout verification. Empty diffs + no matching inference = 200 with empty receipt.
 	body := []byte(`{"inference_id":999,"diffs":[],"payload":null}`)
-	rec := env.doPostAs(t, "/v1/devshard/sessions/escrow-1/challenge-receipt", body, env.hostSigner)
+	rec := env.doPostAs(t, testSessionPath("/challenge-receipt"), body, env.hostSigner)
 	require.Equal(t, http.StatusOK, rec.Code)
 }
 
@@ -494,7 +500,7 @@ func TestServer_NonExecutor_SSE(t *testing.T) {
 	require.NoError(t, err)
 
 	e := echo.New()
-	g := e.Group("/v1/devshard")
+	g := e.Group(testRoutePrefix)
 	srv.Register(g)
 
 	diff := testutil.SignDiff(t, userSigner, "escrow-1", 1, []*types.DevshardTx{testutil.StartTx(1)})
@@ -512,7 +518,7 @@ func TestServer_NonExecutor_SSE(t *testing.T) {
 	sig, sigErr := SignRequest(userSigner, "escrow-1", body, reqTime)
 	ts.NoError(sigErr)
 
-	req := httptest.NewRequest(http.MethodPost, "/v1/devshard/sessions/escrow-1/chat/completions", strings.NewReader(string(body)))
+	req := httptest.NewRequest(http.MethodPost, testSessionPath("/chat/completions"), strings.NewReader(string(body)))
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set(HeaderSignature, hex.EncodeToString(sig))
 	req.Header.Set(HeaderTimestamp, fmt.Sprintf("%d", reqTime))
diff --git a/devshard/types/config.go b/devshard/types/config.go
index f2bdb5c44b..12279ca7ca 100644
--- a/devshard/types/config.go
+++ b/devshard/types/config.go
@@ -10,6 +10,9 @@ const (
 	// DefaultAutoSealEveryNNonces is how often auto-seal runs during Active phase.
 	// Must match inference-chain DefaultDevshardAutoSealEveryNNonces.
 	DefaultAutoSealEveryNNonces uint32 = 150
+	// DefaultValidationRate matches inference-chain DefaultDevshardValidationRate.
+	// Used when the escrow row omits validation_rate (older chain / dapi).
+	DefaultValidationRate uint32 = 1000
 )
 
 // DefaultInferenceSealGraceNonces returns the canonical seal grace for a session group.
@@ -51,7 +54,7 @@ func DefaultSessionConfig(groupSize int) SessionConfig {
 		CreateDevshardFee: 10_000,
 		FeePerNonce:       1_000,
 		VoteThreshold:     uint32(groupSize) / 2,
-		ValidationRate:    5000,
+		ValidationRate:    DefaultValidationRate,
 	}, groupSize)
 }
 
@@ -65,14 +68,17 @@ type EscrowSessionFields struct {
 	InferenceSealGraceNonces  uint32
 	InferenceSealGraceSeconds uint32
 	AutoSealEveryNNonces      uint32
+	ValidationRate            uint32
 }
 
 // LiveSessionBindParams carries governance fields read from the long-poll
 // snapshot once at session bind. Zero means "not provided" for that field.
+// ValidationRate is not applied here — it is lane A and comes only from the
+// escrow row via SessionConfigFromEscrow.
 type LiveSessionBindParams struct {
 	RefusalTimeout      int64
 	ExecutionTimeout    int64
-	ValidationRate      uint32
+	ValidationRate      uint32 // retained for wire/cache observability; ignored at bind
 	VoteThresholdFactor uint32 // percent, e.g. 50 == 50%
 }
 
@@ -88,10 +94,9 @@ func ComputeVoteThreshold(groupSize int, factor uint32) uint32 {
 
 // ApplyLiveSessionParams overlays live governance fields onto cfg and applies
 // NormalizeSessionConfig. Call after SessionConfigFromEscrow at bind time.
+// ValidationRate is not overlaid — it is lane A and must already be set from
+// the escrow row (zero there means DefaultValidationRate).
 func ApplyLiveSessionParams(cfg SessionConfig, groupSize int, live LiveSessionBindParams) SessionConfig {
-	if live.ValidationRate > 0 {
-		cfg.ValidationRate = live.ValidationRate
-	}
 	cfg.VoteThreshold = ComputeVoteThreshold(groupSize, live.VoteThresholdFactor)
 	if live.RefusalTimeout > 0 {
 		cfg.RefusalTimeout = live.RefusalTimeout
@@ -103,10 +108,11 @@ func ApplyLiveSessionParams(cfg SessionConfig, groupSize int, live LiveSessionBi
 }
 
 // ApplyChainSessionBindParams overlays lane-B fields from a chain Params query
-// at session bind. Unlike ApplyLiveSessionParams, validation_rate=0 from chain
-// is honored (disables validation sampling).
+// at session bind. ValidationRate is not overlaid — it is lane A and must
+// already be set from the escrow row (zero there means DefaultValidationRate).
+// Older chain/dapi builds that omit validation_rate therefore keep the default
+// instead of disabling validation sampling.
 func ApplyChainSessionBindParams(cfg SessionConfig, groupSize int, live LiveSessionBindParams) SessionConfig {
-	cfg.ValidationRate = live.ValidationRate
 	cfg.VoteThreshold = ComputeVoteThreshold(groupSize, live.VoteThresholdFactor)
 	if live.RefusalTimeout > 0 {
 		cfg.RefusalTimeout = live.RefusalTimeout
@@ -144,6 +150,9 @@ func SessionConfigFromEscrow(groupSize int, fields EscrowSessionFields) SessionC
 	if fields.AutoSealEveryNNonces > 0 {
 		cfg.AutoSealEveryNNonces = fields.AutoSealEveryNNonces
 	}
+	if fields.ValidationRate > 0 {
+		cfg.ValidationRate = fields.ValidationRate
+	}
 	return NormalizeSessionConfig(cfg, groupSize)
 }
 
diff --git a/devshard/types/config_test.go b/devshard/types/config_test.go
index 24a96bbe04..f74d34ab68 100644
--- a/devshard/types/config_test.go
+++ b/devshard/types/config_test.go
@@ -109,12 +109,13 @@ func TestApplyLiveSessionParams_FreezesLiveFields(t *testing.T) {
 		SessionConfigFromEscrow(groupSize, EscrowSessionFields{
 			InferenceSealGraceNonces:  55,
 			InferenceSealGraceSeconds: 99,
+			ValidationRate:            6000,
 		}),
 		groupSize,
 		LiveSessionBindParams{
 			RefusalTimeout:      90,
 			ExecutionTimeout:    1800,
-			ValidationRate:        6000,
+			ValidationRate:      9999, // lane B must not override lane A
 			VoteThresholdFactor: 67,
 		},
 	)
@@ -126,21 +127,48 @@ func TestApplyLiveSessionParams_FreezesLiveFields(t *testing.T) {
 	require.Equal(t, uint32(4), cfg.VoteThreshold)
 }
 
-func TestApplyChainSessionBindParams_HonorsZeroValidationRate(t *testing.T) {
+func TestSessionConfigFromEscrow_PreservesDefaultValidationRateWhenZero(t *testing.T) {
+	const groupSize = 16
+	cfg := SessionConfigFromEscrow(groupSize, EscrowSessionFields{
+		InferenceSealGraceNonces:  1,
+		InferenceSealGraceSeconds: 10,
+	})
+	require.Equal(t, DefaultValidationRate, cfg.ValidationRate)
+	require.Equal(t, uint32(1), cfg.InferenceSealGraceNonces)
+	require.Equal(t, uint32(10), cfg.InferenceSealGraceSeconds)
+}
+
+func TestSessionConfigFromEscrow_ValidationRateOverride(t *testing.T) {
+	const groupSize = 6
+	cfg := SessionConfigFromEscrow(groupSize, EscrowSessionFields{
+		ValidationRate: 6000,
+	})
+	require.Equal(t, uint32(6000), cfg.ValidationRate)
+}
+
+func TestApplyChainSessionBindParams_DoesNotOverrideValidationRate(t *testing.T) {
 	const groupSize = 16
 	cfg := ApplyChainSessionBindParams(
 		SessionConfigFromEscrow(groupSize, EscrowSessionFields{
 			InferenceSealGraceNonces:  1,
 			InferenceSealGraceSeconds: 10,
+			ValidationRate:            6000,
 		}),
 		groupSize,
 		LiveSessionBindParams{
-			ValidationRate: 0,
+			ValidationRate: 0, // older chain/dapi omit the field
 		},
 	)
-	require.Equal(t, uint32(0), cfg.ValidationRate)
+	require.Equal(t, uint32(6000), cfg.ValidationRate)
 	require.Equal(t, uint32(1), cfg.InferenceSealGraceNonces)
 	require.Equal(t, uint32(10), cfg.InferenceSealGraceSeconds)
+
+	cfgDefault := ApplyChainSessionBindParams(
+		SessionConfigFromEscrow(groupSize, EscrowSessionFields{}),
+		groupSize,
+		LiveSessionBindParams{ValidationRate: 0},
+	)
+	require.Equal(t, DefaultValidationRate, cfgDefault.ValidationRate)
 }
 
 func TestSessionConfigWithPrice_WrapsBuilder(t *testing.T) {
diff --git a/devshard/types/domain.go b/devshard/types/domain.go
index 7827dc6cca..37993cf2b8 100644
--- a/devshard/types/domain.go
+++ b/devshard/types/domain.go
@@ -18,7 +18,7 @@ const DevshardStateRootAndProtocolVersion = "v2"
 const DefaultStateRootVersion = DevshardStateRootAndProtocolVersion
 
 // NormalizeVersion returns the state-root / settlement protocol tag, defaulting when empty.
-// It is not used for storage session bind (CreateSessionParams.Version); see LegacyRouteSessionVersion.
+// It is not used for storage session bind (CreateSessionParams.Version).
 func NormalizeVersion(version string) string {
 	if strings.TrimSpace(version) == "" {
 		return DefaultStateRootVersion
@@ -26,10 +26,7 @@ func NormalizeVersion(version string) string {
 	return version
 }
 
-// LegacyRouteSessionVersion is the session/storage bind tag for the historical
-// /v1/devshard HTTP mount and embedded dapi hosts (HostManager boundVersion).
-// It is not DevshardStateRootAndProtocolVersion.
-const LegacyRouteSessionVersion = "v1"
+const SessionVersionV1 = "v1"
 
 // SessionPhase represents the phase of a devshard session.
 type SessionPhase uint8
@@ -87,6 +84,8 @@ type ProtocolVersion string
 
 const (
 	ProtocolV1 ProtocolVersion = "1"
+	ProtocolV2 ProtocolVersion = "2"
+	ProtocolV3 ProtocolVersion = "3"
 )
 
 // ParseProtocolVersion parses a string into a ProtocolVersion.
@@ -95,6 +94,10 @@ func ParseProtocolVersion(s string) (ProtocolVersion, error) {
 	switch strings.TrimSpace(s) {
 	case "", string(ProtocolV1), "v1":
 		return ProtocolV1, nil
+	case string(ProtocolV2), "v2":
+		return ProtocolV2, nil
+	case string(ProtocolV3), "v3":
+		return ProtocolV3, nil
 	default:
 		return "", fmt.Errorf("unknown protocol version %q", s)
 	}
@@ -102,19 +105,19 @@ func ParseProtocolVersion(s string) (ProtocolVersion, error) {
 
 // SessionConfig holds session-level parameters.
 type SessionConfig struct {
-	RefusalTimeout             int64  // seconds before reason=refused timeout
-	ExecutionTimeout           int64  // seconds before reason=execution timeout
-	TokenPrice                 uint64 // price per input / output token (flat per session)
-	CreateDevshardFee          uint64 // one-time fee charged when creating a devshard session
-	FeePerNonce                uint64 // fee charged per applied nonce (diff)
+	RefusalTimeout    int64  // seconds before reason=refused timeout
+	ExecutionTimeout  int64  // seconds before reason=execution timeout
+	TokenPrice        uint64 // price per input / output token (flat per session)
+	CreateDevshardFee uint64 // one-time fee charged when creating a devshard session
+	FeePerNonce       uint64 // fee charged per applied nonce (diff)
 	// VoteThreshold is frozen at session bind (see ApplyLiveSessionParams).
 	// Consensus logic must read it only via state.StateMachine (applyValidationVote,
 	// applyTimeout); external packages use StateMachine.VoteThreshold() for display.
-	VoteThreshold              uint32
-	ValidationRate             uint32 // basis points (10000 = 100%, 1000 = 10%)
-	InferenceSealGraceNonces   uint32
-	InferenceSealGraceSeconds  uint32
-	AutoSealEveryNNonces       uint32
+	VoteThreshold             uint32
+	ValidationRate            uint32 // basis points (10000 = 100%, 1000 = 10%)
+	InferenceSealGraceNonces  uint32
+	InferenceSealGraceSeconds uint32
+	AutoSealEveryNNonces      uint32
 }
 
 // EscrowState is the full state of a devshard session.
@@ -126,16 +129,16 @@ type EscrowState struct {
 	// session must use the same tag. Storage CreateSessionParams.Version is the
 	// separate runtime/bind version for versiond routing, not this field.
 	StateRootAndProtocolVersion string
-	Config        SessionConfig
-	Group         []SlotAssignment
-	Balance       uint64
-	Fees          uint64 // total fees collected (devshard create + per-nonce)
-	Phase         SessionPhase
-	FinalizeNonce uint64
-	Inferences    map[uint64]*InferenceRecord
-	HostStats     map[uint32]*HostStats
-	WarmKeys      map[uint32]string // slot ID -> warm key address, lazily populated
-	LatestNonce   uint64
+	Config                      SessionConfig
+	Group                       []SlotAssignment
+	Balance                     uint64
+	Fees                        uint64 // total fees collected (devshard create + per-nonce)
+	Phase                       SessionPhase
+	FinalizeNonce               uint64
+	Inferences                  map[uint64]*InferenceRecord
+	HostStats                   map[uint32]*HostStats
+	WarmKeys                    map[uint32]string // slot ID -> warm key address, lazily populated
+	LatestNonce                 uint64
 	// SealedAcc is the Phase 1 incremental accumulator over sealed inference
 	// commitments (32 bytes). Updated on each SealInference and settlement drain.
 	SealedAcc []byte `json:"sealed_acc,omitempty"`
diff --git a/devshard/types/domain_test.go b/devshard/types/domain_test.go
index 895effb3f7..8af1c3824f 100644
--- a/devshard/types/domain_test.go
+++ b/devshard/types/domain_test.go
@@ -25,6 +25,26 @@ func TestParseProtocolVersion_AcceptsRouteStyleV1(t *testing.T) {
 	}
 }
 
+func TestParseProtocolVersion_AcceptsRouteStyleV2(t *testing.T) {
+	got, err := ParseProtocolVersion("v2")
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if got != ProtocolV2 {
+		t.Fatalf("expected v2 to normalize to %s, got %s", ProtocolV2, got)
+	}
+}
+
+func TestParseProtocolVersion_AcceptsRouteStyleV3(t *testing.T) {
+	got, err := ParseProtocolVersion("v3")
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if got != ProtocolV3 {
+		t.Fatalf("expected v3 to normalize to %s, got %s", ProtocolV3, got)
+	}
+}
+
 func TestParseProtocolVersion_RejectsOldProtocol(t *testing.T) {
 	if _, err := ParseProtocolVersion("0.2.11"); err == nil {
 		t.Fatal("expected old protocol to be rejected")
diff --git a/devshard/types/snapshot_codec_test.go b/devshard/types/snapshot_codec_test.go
index 806e553ca6..10871b6799 100644
--- a/devshard/types/snapshot_codec_test.go
+++ b/devshard/types/snapshot_codec_test.go
@@ -11,14 +11,14 @@ func TestEscrowStateProtoRoundTrip(t *testing.T) {
 		EscrowID:                    "escrow-1",
 		StateRootAndProtocolVersion: DevshardStateRootAndProtocolVersion,
 		Config: SessionConfig{
-			RefusalTimeout:             60,
-			ExecutionTimeout:           1200,
-			TokenPrice:                 1,
-			CreateDevshardFee:          10_000,
-			FeePerNonce:                1_000,
-			VoteThreshold:              1,
-			ValidationRate:             5000,
-			InferenceSealGraceNonces:            20,
+			RefusalTimeout:            60,
+			ExecutionTimeout:          1200,
+			TokenPrice:                1,
+			CreateDevshardFee:         10_000,
+			FeePerNonce:               1_000,
+			VoteThreshold:             1,
+			ValidationRate:            DefaultValidationRate,
+			InferenceSealGraceNonces:  20,
 			InferenceSealGraceSeconds: 120,
 		},
 		Group: []SlotAssignment{
diff --git a/devshard/user/bind_config.go b/devshard/user/bind_config.go
index 4e2238b6e6..6c02ba7a67 100644
--- a/devshard/user/bind_config.go
+++ b/devshard/user/bind_config.go
@@ -8,14 +8,7 @@ import (
 )
 
 func sessionConfigAtBind(groupSize int, escrow *bridge.EscrowInfo, b bridge.MainnetBridge) (types.SessionConfig, error) {
-	config := types.SessionConfigFromEscrow(groupSize, types.EscrowSessionFields{
-		TokenPrice:                escrow.TokenPrice,
-		CreateDevshardFee:         escrow.CreateDevshardFee,
-		FeePerNonce:               escrow.FeePerNonce,
-		InferenceSealGraceNonces:  escrow.InferenceSealGraceNonces,
-		InferenceSealGraceSeconds: escrow.InferenceSealGraceSeconds,
-		AutoSealEveryNNonces:      escrow.AutoSealEveryNNonces,
-	})
+	config := bridge.SessionConfigAtBind(groupSize, escrow)
 	sb, ok := b.(bridge.SessionBindParamsBridge)
 	if !ok {
 		return types.NormalizeSessionConfig(config, groupSize), nil
diff --git a/devshard/user/bind_config_test.go b/devshard/user/bind_config_test.go
index 940f796e49..92ef365552 100644
--- a/devshard/user/bind_config_test.go
+++ b/devshard/user/bind_config_test.go
@@ -45,10 +45,11 @@ func TestSessionConfigAtBind_AppliesChainParams(t *testing.T) {
 		InferenceSealGraceNonces:  55,
 		InferenceSealGraceSeconds: 77,
 		AutoSealEveryNNonces:      16,
+		ValidationRate:            6000,
 	}
 	b := &bindParamsBridge{
 		live: types.LiveSessionBindParams{
-			ValidationRate: 0,
+			ValidationRate: 0, // older chain/dapi omit the field; must not wipe escrow rate
 		},
 	}
 
@@ -57,7 +58,19 @@ func TestSessionConfigAtBind_AppliesChainParams(t *testing.T) {
 	assert.Equal(t, uint32(55), cfg.InferenceSealGraceNonces, "grace nonces come from escrow")
 	assert.Equal(t, uint32(77), cfg.InferenceSealGraceSeconds, "grace seconds come from escrow")
 	assert.Equal(t, uint32(16), cfg.AutoSealEveryNNonces, "auto-seal interval comes from escrow")
-	assert.Equal(t, uint32(0), cfg.ValidationRate)
+	assert.Equal(t, uint32(6000), cfg.ValidationRate, "validation_rate comes from escrow (lane A)")
+}
+
+func TestSessionConfigAtBind_ZeroValidationRateUsesDefault(t *testing.T) {
+	const groupSize = 16
+	escrow := &bridge.EscrowInfo{TokenPrice: 1}
+	b := &bindParamsBridge{
+		live: types.LiveSessionBindParams{ValidationRate: 0},
+	}
+
+	cfg, err := sessionConfigAtBind(groupSize, escrow, b)
+	require.NoError(t, err)
+	assert.Equal(t, types.DefaultValidationRate, cfg.ValidationRate)
 }
 
 func TestSessionConfigAtBind_FallsBackWithoutParamsBridge(t *testing.T) {
@@ -69,4 +82,5 @@ func TestSessionConfigAtBind_FallsBackWithoutParamsBridge(t *testing.T) {
 	assert.Equal(t, types.DefaultInferenceSealGraceNonces(groupSize), cfg.InferenceSealGraceNonces)
 	assert.Equal(t, uint32(types.DefaultInferenceSealGraceSeconds), cfg.InferenceSealGraceSeconds)
 	assert.Equal(t, types.DefaultAutoSealEveryNNonces, cfg.AutoSealEveryNNonces)
+	assert.Equal(t, types.DefaultValidationRate, cfg.ValidationRate)
 }
diff --git a/devshard/user/fault_test.go b/devshard/user/fault_test.go
index 46cd14661a..6ed1ed7fdc 100644
--- a/devshard/user/fault_test.go
+++ b/devshard/user/fault_test.go
@@ -71,7 +71,7 @@ func runFault(t *testing.T, failPct int) {
 		ExecutionTimeout: 1200,
 		TokenPrice:       1,
 		VoteThreshold:    uint32(faultNumHosts) / 2,
-		ValidationRate:   5000,
+		ValidationRate:   types.DefaultValidationRate,
 	}
 	verifier := signing.NewSecp256k1Verifier()
 
@@ -279,8 +279,12 @@ func runFault(t *testing.T, failPct int) {
 	}
 
 	// --- Post-finalize status counts ---
+	// Terminal records seal once the nonce grace clears, and settlement drains
+	// every remaining live record into SealedAcc, so status accounting must
+	// read the merged live + sealed view rather than st.Inferences.
+	allRecords := session.StateMachine().ExportAllInferenceRecords()
 	statusCounts := make(map[types.InferenceStatus]int)
-	for _, rec := range st.Inferences {
+	for _, rec := range allRecords {
 		statusCounts[rec.Status]++
 	}
 
@@ -293,7 +297,10 @@ func runFault(t *testing.T, failPct int) {
 	// Dead executor slots with pending inferences should have missed > 0.
 	deadSlotsWithMissed := make(map[uint32]bool)
 	for _, infID := range pendingDeadIDs {
-		rec := st.Inferences[infID]
+		rec, ok := allRecords[infID]
+		require.True(t, ok, "inference %d missing from live and sealed records", infID)
+		require.Equal(t, types.StatusTimedOut, rec.Status,
+			"inference %d should be timed out, got %d", infID, rec.Status)
 		deadSlotsWithMissed[rec.ExecutorSlot] = true
 	}
 	totalMissed := 0
@@ -352,8 +359,6 @@ func runFault(t *testing.T, failPct int) {
 	} else {
 		t.Logf("  finalize: failed as expected (%d/%d alive < threshold %d)", aliveHosts, faultNumHosts, threshold)
 	}
-	t.Logf("  alive hosts with req_val>0: %d", aliveWithReqVal)
-	t.Logf("  dead hosts penalized (req_val>0, comp_val=0): %d", numDead)
 	t.Logf("")
 	t.Logf("signatures: %d/%d alive hosts signed", len(signedAlive), faultNumHosts-numDead)
 	t.Logf("")
diff --git a/devshard/user/flush_snapshot_test.go b/devshard/user/flush_snapshot_test.go
new file mode 100644
index 0000000000..dd08fc1df1
--- /dev/null
+++ b/devshard/user/flush_snapshot_test.go
@@ -0,0 +1,180 @@
+package user
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"devshard/host"
+	"devshard/internal/testutil"
+	"devshard/signing"
+	"devshard/state"
+	"devshard/storage"
+	"devshard/stub"
+	"devshard/types"
+)
+
+// replaySpyStore wraps a storage.Storage and records every GetDiffs range so a
+// test can distinguish diff replay from catch-up backfill. During recovery,
+// replayed diffs (fed through ApplyLocal to rebuild SM state) come from a
+// GetDiffs call whose range starts after the snapshot nonce; backfill calls
+// end at the snapshot nonce.
+type replaySpyStore struct {
+	storage.Storage
+	mu    sync.Mutex
+	calls []spyGetDiffs
+}
+
+type spyGetDiffs struct {
+	from, to uint64
+	count    int
+}
+
+func (s *replaySpyStore) GetDiffs(escrowID string, from, to uint64) ([]types.DiffRecord, error) {
+	recs, err := s.Storage.GetDiffs(escrowID, from, to)
+	s.mu.Lock()
+	s.calls = append(s.calls, spyGetDiffs{from: from, to: to, count: len(recs)})
+	s.mu.Unlock()
+	return recs, err
+}
+
+// replayedRecords sums records returned for calls whose range starts strictly
+// after snapNonce -- exactly the post-snapshot diffs RecoverSession replays.
+func (s *replaySpyStore) replayedRecords(snapNonce uint64) int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	total := 0
+	for _, c := range s.calls {
+		if c.from > snapNonce {
+			total += c.count
+		}
+	}
+	return total
+}
+
+// buildLiveSession builds a storage-backed session and its state machine,
+// mirroring setupRecoverableSession but returning the live session so a test
+// can drive it and then flush a snapshot.
+func buildLiveSession(
+	t *testing.T, numHosts int, store storage.Storage,
+) (*Session, *state.StateMachine, []types.SlotAssignment, []*signing.Secp256k1Signer, *signing.Secp256k1Signer) {
+	t.Helper()
+	hosts := make([]*signing.Secp256k1Signer, numHosts)
+	for i := range hosts {
+		hosts[i] = testutil.MustGenerateKey(t)
+	}
+	user := testutil.MustGenerateKey(t)
+	group := testutil.MakeGroup(hosts)
+	config := testutil.DefaultConfig(numHosts)
+	verifier := signing.NewSecp256k1Verifier()
+
+	require.NoError(t, store.CreateSession(storage.CreateSessionParams{
+		EscrowID:       "escrow-1",
+		Version:        types.SessionVersionV1,
+		CreatorAddr:    user.Address(),
+		Config:         config,
+		Group:          group,
+		InitialBalance: 100000,
+	}))
+
+	clients := make([]HostClient, numHosts)
+	for i := range hosts {
+		hostStore := testutil.MustMemoryStore(t, "escrow-1", user.Address(), config, group, 100000)
+		sm, err := state.NewStateMachine("escrow-1", config, group, 100000, user.Address(), verifier, hostStore)
+		require.NoError(t, err)
+		h, err := host.NewHost(sm, hosts[i], stub.NewInferenceEngine(), "escrow-1", group, nil, host.WithGrace(10))
+		require.NoError(t, err)
+		clients[i] = &InProcessClient{Host: h}
+	}
+
+	userSM, err := state.NewStateMachine("escrow-1", config, group, 100000, user.Address(), verifier, store)
+	require.NoError(t, err)
+	session, err := NewSession(userSM, user, "escrow-1", group, clients, verifier, WithStorage(store))
+	require.NoError(t, err)
+
+	return session, userSM, group, hosts, user
+}
+
+// TestFlushSnapshot_RetiredEscrowRebuildsWithoutReplay is the core guarantee of
+// the retire-time snapshot flush: an escrow whose nonce advanced past the last
+// periodic snapshot (here: none, since numInferences < snapshotInterval) must,
+// after FlushSnapshot, rebuild via RecoverSession with zero diff replay.
+func TestFlushSnapshot_RetiredEscrowRebuildsWithoutReplay(t *testing.T) {
+	store := newTestStore(t)
+	numHosts := 3
+	numInferences := 5 // < snapshotInterval, so no periodic snapshot is taken
+
+	session, liveSM, group, hosts, user := buildLiveSession(t, numHosts, store)
+
+	ctx := context.Background()
+	params := InferenceParams{
+		Model: "llama", Prompt: testutil.TestPrompt,
+		InputLength: 100, MaxTokens: 50, StartedAt: 1000,
+	}
+	for i := 0; i < numInferences; i++ {
+		_, err := session.SendInference(ctx, params)
+		require.NoError(t, err)
+	}
+	require.Equal(t, uint64(numInferences), session.Nonce())
+
+	// No periodic snapshot exists yet: a plain rebuild here would replay all
+	// numInferences diffs.
+	_, _, err := store.LoadSnapshot("escrow-1")
+	require.ErrorIs(t, err, storage.ErrSnapshotNotFound)
+
+	// Retire: flush a final snapshot at the current (frozen) nonce.
+	require.NoError(t, session.FlushSnapshot())
+
+	snapNonce, _, err := store.LoadSnapshot("escrow-1")
+	require.NoError(t, err)
+	require.Equal(t, uint64(numInferences), snapNonce, "flush must snapshot at the frozen nonce")
+
+	// Rebuild through a spy to observe replay. With a snapshot at LatestNonce,
+	// RecoverSession must take the early-return path and never fetch (let alone
+	// replay) any post-snapshot diff.
+	verifier := signing.NewSecp256k1Verifier()
+	spy := &replaySpyStore{Storage: store}
+	rec, recSM, err := RecoverSession(spy, user, verifier, "escrow-1", types.SessionVersionV1, group, buildRecoveryClients(t, hosts, group, user))
+	require.NoError(t, err)
+	require.Equal(t, uint64(numInferences), rec.Nonce())
+	require.Zero(t, spy.replayedRecords(snapNonce), "retired escrow must rebuild with zero diff replay")
+
+	// The rebuilt state must be identical to the live session's state.
+	recRoot, err := recSM.ComputeStateRoot()
+	require.NoError(t, err)
+	liveRoot, err := liveSM.ComputeStateRoot()
+	require.NoError(t, err)
+	require.Equal(t, liveRoot, recRoot, "flushed snapshot must reproduce the live state root")
+}
+
+// TestFlushSnapshot_NoStoreOrEmptyIsNoop verifies FlushSnapshot is safe on
+// sessions with nothing to persist: no store configured, or nonce still 0.
+func TestFlushSnapshot_NoStoreOrEmptyIsNoop(t *testing.T) {
+	// nonce == 0 (no inferences) with a store: must not write a snapshot.
+	store := newTestStore(t)
+	session, _, _, _, _ := buildLiveSession(t, 3, store)
+	require.Equal(t, uint64(0), session.Nonce())
+	require.NoError(t, session.FlushSnapshot())
+	_, _, err := store.LoadSnapshot("escrow-1")
+	require.ErrorIs(t, err, storage.ErrSnapshotNotFound, "flush at nonce 0 must not write a snapshot")
+
+	// No store configured: flush is a no-op that returns nil.
+	verifier := signing.NewSecp256k1Verifier()
+	hostSigner := testutil.MustGenerateKey(t)
+	user := testutil.MustGenerateKey(t)
+	group := testutil.MakeGroup([]*signing.Secp256k1Signer{hostSigner})
+	config := testutil.DefaultConfig(1)
+	hostStore := testutil.MustMemoryStore(t, "escrow-1", user.Address(), config, group, 100000)
+	hostSM, err := state.NewStateMachine("escrow-1", config, group, 100000, user.Address(), verifier, hostStore)
+	require.NoError(t, err)
+	h, err := host.NewHost(hostSM, hostSigner, stub.NewInferenceEngine(), "escrow-1", group, nil, host.WithGrace(10))
+	require.NoError(t, err)
+	userStore := testutil.MustMemoryStore(t, "escrow-1", user.Address(), config, group, 100000)
+	sm, err := state.NewStateMachine("escrow-1", config, group, 100000, user.Address(), verifier, userStore)
+	require.NoError(t, err)
+	noStore, err := NewSession(sm, user, "escrow-1", group, []HostClient{&InProcessClient{Host: h}}, verifier)
+	require.NoError(t, err)
+	require.NoError(t, noStore.FlushSnapshot())
+}
diff --git a/devshard/user/httpsession.go b/devshard/user/httpsession.go
index 9fd77a4322..182606ca43 100644
--- a/devshard/user/httpsession.go
+++ b/devshard/user/httpsession.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	devshardpkg "devshard"
 	"devshard/bridge"
@@ -22,7 +23,7 @@ type HTTPSessionConfig struct {
 	Bridge           bridge.MainnetBridge
 	StoragePath      string                          // SQLite path for session persistence; default ~/.cache/gonka/devshard-<escrowID>
 	StreamCallback   func(nonce uint64, line string) // optional: receives raw SSE data lines during inference
-	RoutePrefix      string                          // optional: HTTP path prefix used to reach hosts; default devshard.LegacyRoutePrefix. Versioned binaries use devshard.VersionedRoutePrefix(...).
+	RoutePrefix      string                          // required: HTTP path prefix used to reach hosts, e.g. devshard.VersionedRoutePrefix(...).
 	RequestAdmission transport.RequestAdmissionController
 	ProtocolVersion  types.ProtocolVersion // optional: defaults to ProtocolV1
 }
@@ -38,10 +39,70 @@ func resolveHTTPSessionStoragePath(escrowID, configured string) string {
 	return filepath.Join(home, ".cache", "gonka", fmt.Sprintf("devshard-%s", escrowID))
 }
 
+// LocalSessionConfig holds the parameters needed to rehydrate a user Session
+// entirely from local storage, with no chain access and no host clients.
+type LocalSessionConfig struct {
+	PrivateKeyHex   string
+	EscrowID        string
+	StoragePath     string
+	ProtocolVersion types.ProtocolVersion
+}
+
+// NewLocalSession rehydrates a Session from local SQLite storage without
+// contacting the chain and without wiring any host clients. The returned
+// session can answer read-only queries (state, status, debug, settlement
+// build) but cannot dispatch new inferences. Callers own the returned
+// Session and must Close it when done, which also closes the underlying
+// storage handle.
+//
+// Warm-key verification is intentionally omitted (nil resolver): stored
+// diffs carry their warm-key deltas, which RecoverSession injects before
+// replay, so no chain-backed resolver is needed to rebuild state.
+func NewLocalSession(cfg LocalSessionConfig) (*Session, *state.StateMachine, error) {
+	if strings.TrimSpace(cfg.StoragePath) == "" {
+		return nil, nil, fmt.Errorf("local session requires a storage path")
+	}
+	signer, err := signing.SignerFromHex(cfg.PrivateKeyHex)
+	if err != nil {
+		return nil, nil, fmt.Errorf("create signer: %w", err)
+	}
+	pv := cfg.ProtocolVersion
+	if pv == "" {
+		pv = types.ProtocolV1
+	}
+	verifier := signing.NewSecp256k1Verifier()
+
+	store, err := storage.NewSQLite(cfg.StoragePath)
+	if err != nil {
+		return nil, nil, fmt.Errorf("open storage: %w", err)
+	}
+	meta, err := store.GetSessionMeta(cfg.EscrowID)
+	if err != nil {
+		store.Close()
+		return nil, nil, fmt.Errorf("get session meta: %w", err)
+	}
+	// No host clients: read-only sessions never dispatch inferences. The
+	// slice length must match the group so NewSession's invariant holds.
+	clients := make([]HostClient, len(meta.Group))
+	session, sm, err := RecoverSession(store, signer, verifier, cfg.EscrowID, meta.Version, meta.Group, clients,
+		state.WithProtocolVersion(pv),
+	)
+	if err != nil {
+		store.Close()
+		return nil, nil, fmt.Errorf("recover session: %w", err)
+	}
+	return session, sm, nil
+}
+
 // NewHTTPSession creates a user Session wired with HTTP clients to real dapi hosts.
 // It queries the bridge for escrow and group info, then creates transport clients
 // for each slot.
 func NewHTTPSession(cfg HTTPSessionConfig) (*Session, *state.StateMachine, error) {
+	cfg.RoutePrefix = strings.TrimSpace(cfg.RoutePrefix)
+	if cfg.RoutePrefix == "" {
+		return nil, nil, fmt.Errorf("RoutePrefix is required; use /devshard/{version}")
+	}
+
 	signer, err := signing.SignerFromHex(cfg.PrivateKeyHex)
 	if err != nil {
 		return nil, nil, fmt.Errorf("create signer: %w", err)
@@ -52,14 +113,9 @@ func NewHTTPSession(cfg HTTPSessionConfig) (*Session, *state.StateMachine, error
 	if pv == "" {
 		pv = types.ProtocolV1
 	}
-	routePrefix := devshardpkg.ResolveHostRoutePrefix(pv, cfg.RoutePrefix)
-	sessionVersion := devshardpkg.ProtocolSessionVersion(pv)
-	if cfg.ProtocolVersion == "" && cfg.RoutePrefix != "" {
-		var versionErr error
-		sessionVersion, versionErr = devshardpkg.VersionForRoutePrefix(cfg.RoutePrefix)
-		if versionErr != nil {
-			return nil, nil, fmt.Errorf("resolve route version: %w", versionErr)
-		}
+	routePrefix, sessionVersion, versionErr := devshardpkg.ResolveRoutePrefix(cfg.RoutePrefix)
+	if versionErr != nil {
+		return nil, nil, fmt.Errorf("resolve route version: %w", versionErr)
 	}
 
 	group, err := bridge.BuildGroup(cfg.EscrowID, cfg.Bridge)
@@ -100,23 +156,17 @@ func NewHTTPSession(cfg HTTPSessionConfig) (*Session, *state.StateMachine, error
 			sqlStore.Close()
 			return nil, nil, fmt.Errorf("get host info for %s: %w", slot.ValidatorAddress, err)
 		}
-		var clientCfgs []transport.ClientConfig
-		if cfg.StreamCallback != nil || routePrefix != "" || cfg.RequestAdmission != nil {
-			cc := transport.DefaultClientConfig()
-			cc.ProtocolVersion = pv
-			if cfg.StreamCallback != nil {
-				cc.StreamCallback = cfg.StreamCallback
-			}
-			if routePrefix != "" {
-				cc.RoutePrefix = routePrefix
-			}
-			if cfg.RequestAdmission != nil {
-				cc.ParticipantKey = slot.ValidatorAddress
-				cc.Admission = cfg.RequestAdmission
-			}
-			clientCfgs = append(clientCfgs, cc)
+		cc := transport.DefaultClientConfig()
+		cc.ProtocolVersion = pv
+		cc.RoutePrefix = routePrefix
+		if cfg.StreamCallback != nil {
+			cc.StreamCallback = cfg.StreamCallback
+		}
+		if cfg.RequestAdmission != nil {
+			cc.ParticipantKey = slot.ValidatorAddress
+			cc.Admission = cfg.RequestAdmission
 		}
-		c := transport.NewHTTPClient(info.URL, cfg.EscrowID, signer, clientCfgs...)
+		c := transport.NewHTTPClient(info.URL, cfg.EscrowID, signer, cc)
 		clientCache[slot.ValidatorAddress] = c
 		clients[i] = c
 	}
diff --git a/devshard/user/httpsession_test.go b/devshard/user/httpsession_test.go
new file mode 100644
index 0000000000..c1aae010b7
--- /dev/null
+++ b/devshard/user/httpsession_test.go
@@ -0,0 +1,73 @@
+package user
+
+import (
+	"testing"
+
+	"devshard/bridge"
+	"devshard/storage"
+	"devshard/types"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewHTTPSessionRequiresRoutePrefix(t *testing.T) {
+	_, _, err := NewHTTPSession(HTTPSessionConfig{})
+	require.ErrorContains(t, err, "RoutePrefix is required")
+	require.ErrorContains(t, err, "/devshard/{version}")
+}
+
+func TestNewHTTPSessionUsesRouteVersionForStorageBind(t *testing.T) {
+	const privateKeyHex = "0000000000000000000000000000000000000000000000000000000000000001"
+	storagePath := t.TempDir() + "/session.db"
+
+	session, _, err := NewHTTPSession(HTTPSessionConfig{
+		PrivateKeyHex:   privateKeyHex,
+		EscrowID:        "escrow-1",
+		Bridge:          httpsessionTestBridge{},
+		StoragePath:     storagePath,
+		RoutePrefix:     " /devshard/dev/ ",
+		ProtocolVersion: types.ProtocolV1,
+	})
+	require.NoError(t, err)
+	require.NoError(t, session.Close())
+
+	store, err := storage.NewSQLite(storagePath)
+	require.NoError(t, err)
+	defer store.Close()
+
+	meta, err := store.GetSessionMeta("escrow-1")
+	require.NoError(t, err)
+	require.Equal(t, "dev", meta.Version)
+}
+
+type httpsessionTestBridge struct{}
+
+func (httpsessionTestBridge) OnEscrowCreated(bridge.EscrowInfo) error { return nil }
+func (httpsessionTestBridge) OnSettlementProposed(string, []byte, uint64) error {
+	return nil
+}
+func (httpsessionTestBridge) OnSettlementFinalized(string) error { return nil }
+
+func (httpsessionTestBridge) GetEscrow(string) (*bridge.EscrowInfo, error) {
+	return &bridge.EscrowInfo{
+		EscrowID:       "escrow-1",
+		Amount:         1_000_000,
+		CreatorAddress: "creator",
+		Slots:          []string{"host-1"},
+		TokenPrice:     1,
+		EpochID:        7,
+	}, nil
+}
+
+func (httpsessionTestBridge) GetHostInfo(address string) (*bridge.HostInfo, error) {
+	return &bridge.HostInfo{Address: address, URL: "http://host.test"}, nil
+}
+
+func (httpsessionTestBridge) GetValidationThreshold(uint64, string) (*bridge.Decimal, error) {
+	return nil, nil
+}
+
+func (httpsessionTestBridge) VerifyWarmKey(string, string) (bool, error) { return true, nil }
+func (httpsessionTestBridge) SubmitDisputeState(string, []byte, uint64, map[uint32][]byte) error {
+	return nil
+}
diff --git a/devshard/user/recover.go b/devshard/user/recover.go
index 66fda0df0f..037c432dcd 100644
--- a/devshard/user/recover.go
+++ b/devshard/user/recover.go
@@ -293,16 +293,24 @@ func saveSnapshot(store storage.Storage, sm *state.StateMachine, escrowID string
 // or state-machine locks held -- this is what enables async background
 // snapshots from the runtime hot path).
 func writeSnapshot(store storage.Storage, escrowID string, nonce uint64, state *types.EscrowState, cursor map[int]uint64) {
+	_ = writeSnapshotErr(store, escrowID, nonce, state, cursor)
+}
+
+// writeSnapshotErr is writeSnapshot with an error return, for synchronous
+// callers (e.g. Session.FlushSnapshot on retire) that want to know whether the
+// snapshot landed. It logs on failure exactly like writeSnapshot.
+func writeSnapshotErr(store storage.Storage, escrowID string, nonce uint64, state *types.EscrowState, cursor map[int]uint64) error {
 	blob := sessionSnapshot{State: state, HostSyncNonce: cursor}
 	data, err := json.Marshal(blob)
 	if err != nil {
 		log.Printf("recover_session escrow=%s snapshot_marshal_failed=%v", escrowID, err)
-		return
+		return err
 	}
 	if err := store.SaveSnapshot(escrowID, nonce, data); err != nil {
 		log.Printf("recover_session escrow=%s snapshot_save_failed=%v", escrowID, err)
-		return
+		return err
 	}
 	log.Printf("recover_session escrow=%s snapshot_saved nonce=%d size_bytes=%d host_cursors=%d",
 		escrowID, nonce, len(data), len(cursor))
+	return nil
 }
diff --git a/devshard/user/recover_test.go b/devshard/user/recover_test.go
index 19c69c70a8..70fc021494 100644
--- a/devshard/user/recover_test.go
+++ b/devshard/user/recover_test.go
@@ -536,7 +536,7 @@ func TestRecoveredProtocolVersion_ExplicitOnly(t *testing.T) {
 	require.True(t, ok)
 	require.Equal(t, types.ProtocolV1, pv)
 
-	pv, ok = recoveredProtocolVersion(types.LegacyRouteSessionVersion)
+	pv, ok = recoveredProtocolVersion(types.SessionVersionV1)
 	require.True(t, ok)
 	require.Equal(t, types.ProtocolV1, pv)
 
diff --git a/devshard/user/session.go b/devshard/user/session.go
index 9b1a00a69d..14a8eb0ec1 100644
--- a/devshard/user/session.go
+++ b/devshard/user/session.go
@@ -672,6 +672,61 @@ func (s *Session) maybeSaveSnapshotLocked() {
 	}()
 }
 
+// FlushSnapshot synchronously persists a state snapshot at the current nonce.
+// It is called when a runtime is retired from memory (deactivate, settle,
+// rotation) so the now-frozen escrow can later be rebuilt -- for a read-only
+// debug/state request or a reactivation -- without replaying the diff tail
+// accumulated since the last periodic (every snapshotInterval) snapshot.
+//
+// Periodic snapshots are only taken on snapshotInterval boundaries, so a
+// retired escrow otherwise carries up to snapshotInterval-1 un-snapshotted
+// diffs that every rebuild would replay. This flush captures the final nonce
+// once, at the lifecycle transition, making all later rebuilds replay-free.
+//
+// It serializes against the async periodic writer via snapshotInFlight so a
+// slow in-flight periodic save cannot land after (and overwrite) this final
+// snapshot with a staler nonce. Safe to call once, at retire; a no-op when
+// no diffs have been applied (nonce == 0) or no store is configured.
+func (s *Session) FlushSnapshot() error {
+	if s.store == nil {
+		return nil
+	}
+	// Acquire the snapshot slot, waiting briefly for any in-flight async
+	// save to finish. Bounded so retire never blocks indefinitely; if the
+	// async writer is still busy after the wait we proceed anyway (SQLite
+	// serializes the writes, and retire runs after drain so this is rare).
+	acquired := false
+	for i := 0; i < 200; i++ {
+		if s.snapshotInFlight.CompareAndSwap(false, true) {
+			acquired = true
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	if acquired {
+		defer s.snapshotInFlight.Store(false)
+	}
+
+	s.mu.Lock()
+	if s.nonce == 0 {
+		s.mu.Unlock()
+		return nil
+	}
+	// Deep-copy state and cursor under the session lock, mirroring
+	// maybeSaveSnapshotLocked, then release before the disk write.
+	stateCopy := s.sm.ExportState()
+	cursor := make(map[int]uint64, len(s.hostSyncNonce))
+	for k, v := range s.hostSyncNonce {
+		cursor[k] = v
+	}
+	nonce := s.nonce
+	store := s.store
+	escrowID := s.escrowID
+	s.mu.Unlock()
+
+	return writeSnapshotErr(store, escrowID, nonce, stateCopy, cursor)
+}
+
 // PrepareInference composes a diff, applies it locally, advances nonce,
 // and returns everything needed for the HTTP send. Thread-safe.
 //
@@ -1692,7 +1747,7 @@ func (s *Session) IsNonceFinished(nonce uint64) bool {
 // sendTime is when the nonce's network call started.
 func (s *Session) HandleTimeout(ctx context.Context, nonce uint64, sendTime time.Time, payload *host.InferencePayload) (TimeoutResult, error) {
 	s.mu.Lock()
-	cfg := s.sm.SnapshotState().Config
+	cfg := s.sm.Config()
 	confirmedAt := int64(0)
 	if o, ok := s.nonceStates[nonce]; ok {
 		confirmedAt = o.confirmedAt
diff --git a/devshard/user/session_close_test.go b/devshard/user/session_close_test.go
new file mode 100644
index 0000000000..b46330e81e
--- /dev/null
+++ b/devshard/user/session_close_test.go
@@ -0,0 +1,70 @@
+package user
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"devshard/storage"
+	"devshard/types"
+)
+
+// closeCountingStore is a storage.Storage that records how many times Close is
+// called. Every other method is an inert stub: this fake exists only to prove
+// that Session.Close releases the underlying store, which is the resource the
+// per-runtime memory leak was failing to free.
+type closeCountingStore struct {
+	closeCalls int
+}
+
+func (s *closeCountingStore) CreateSession(storage.CreateSessionParams) error { return nil }
+func (s *closeCountingStore) MarkSettled(string) error                        { return nil }
+func (s *closeCountingStore) ListActiveSessions() ([]storage.ActiveSession, error) {
+	return nil, nil
+}
+func (s *closeCountingStore) AppendDiff(string, types.DiffRecord) error { return nil }
+func (s *closeCountingStore) GetDiffs(string, uint64, uint64) ([]types.DiffRecord, error) {
+	return nil, nil
+}
+func (s *closeCountingStore) AddSignature(string, uint64, uint32, []byte) error { return nil }
+func (s *closeCountingStore) GetSignatures(string, uint64) (map[uint32][]byte, error) {
+	return nil, nil
+}
+func (s *closeCountingStore) GetSessionMeta(string) (*storage.SessionMeta, error) {
+	return nil, storage.ErrSessionNotFound
+}
+func (s *closeCountingStore) MarkFinalized(string, uint64) error        { return nil }
+func (s *closeCountingStore) LastFinalized(string) (uint64, error)      { return 0, nil }
+func (s *closeCountingStore) SaveSnapshot(string, uint64, []byte) error { return nil }
+func (s *closeCountingStore) LoadSnapshot(string) (uint64, []byte, error) {
+	return 0, nil, storage.ErrSnapshotNotFound
+}
+func (s *closeCountingStore) InsertSealedInference(string, storage.InferenceRow) error { return nil }
+func (s *closeCountingStore) GetSealedInference(string, uint64) (storage.InferenceRow, bool, error) {
+	return storage.InferenceRow{}, false, nil
+}
+func (s *closeCountingStore) DeleteSealedInferences(string) error { return nil }
+func (s *closeCountingStore) RecordValidationsAppliedOnce(string, []storage.ValidationObsEntry) error {
+	return nil
+}
+func (s *closeCountingStore) DrainInferenceValidationObs(string, uint64) error { return nil }
+func (s *closeCountingStore) GetValidationObservability(string) ([]storage.SlotValidationObs, error) {
+	return nil, nil
+}
+func (s *closeCountingStore) PruneEpoch(uint64) error { return nil }
+func (s *closeCountingStore) Close() error {
+	s.closeCalls++
+	return nil
+}
+
+// TestSession_Close_ClosesUnderlyingStore proves the resource-release leg of the
+// leak fix: closing a Session must close the storage it owns. The gateway-side
+// tests prove rt.close() is now invoked on every automatic deactivation path;
+// this proves that invocation actually frees the SQLite store the session holds.
+func TestSession_Close_ClosesUnderlyingStore(t *testing.T) {
+	store := &closeCountingStore{}
+	session, _, _ := setupSessionWithOptions(t, 1, 1_000_000, 0, WithStorage(store))
+
+	require.NoError(t, session.Close())
+	require.Equal(t, 1, store.closeCalls, "Session.Close must close the injected storage exactly once")
+}
diff --git a/devshard/user/stress_test.go b/devshard/user/stress_test.go
index fbdf91e737..08bcc91104 100644
--- a/devshard/user/stress_test.go
+++ b/devshard/user/stress_test.go
@@ -188,7 +188,7 @@ func runStress(t *testing.T, numHosts, rounds int) {
 		ExecutionTimeout: 1200,
 		TokenPrice:       1,
 		VoteThreshold:    uint32(numHosts) / 2,
-		ValidationRate:   5000, // 50%
+		ValidationRate:   types.DefaultValidationRate,
 	}
 	verifier := signing.NewSecp256k1Verifier()
 
diff --git a/devshard/user/validation_test.go b/devshard/user/validation_test.go
index bebea74f39..c0f1f6649e 100644
--- a/devshard/user/validation_test.go
+++ b/devshard/user/validation_test.go
@@ -96,6 +96,8 @@ func TestSession_Validation_InvalidationConverges(t *testing.T) {
 			host.WithGrace(grace), host.WithValidator(validators[i]),
 		)
 		require.NoError(t, err)
+		h.Start()
+		t.Cleanup(h.Close)
 		clients[i] = &InProcessClient{Host: h}
 	}
 
@@ -225,6 +227,8 @@ func TestSession_Validation_MultiSlotValidatorCountedOnce(t *testing.T) {
 			host.WithGrace(grace), host.WithValidator(validators[i]),
 		)
 		require.NoError(t, err)
+		h.Start()
+		t.Cleanup(h.Close)
 		hostBySigner[i] = h
 	}
 	clients := make([]HostClient, len(group))
diff --git a/docs/chat-api/README.md b/docs/chat-api/README.md
index 0bbeaffc28..7387b417cd 100644
--- a/docs/chat-api/README.md
+++ b/docs/chat-api/README.md
@@ -1,10 +1,11 @@
 # Gonka Chat Completions API
 
-OpenAI-compatible chat completions, routed to Kimi-K2.6 / Qwen3-235B via vLLM. This doc covers universal parameter behavior. For per-model overrides see [Kimi-K2.6](kimi-k2.6.md) / [Qwen3-235B](qwen3-235b-a22b-instruct-2507.md).
+OpenAI-compatible chat completions, routed to Kimi-K2.6 / Qwen3-235B / MiniMax-M2.7 via vLLM. This doc covers universal parameter behavior. For per-model overrides see [Kimi-K2.6](kimi-k2.6.md) / [Qwen3-235B](qwen3-235b-a22b-instruct-2507.md) / [MiniMax-M2.7](minimax-m2.7.md).
 
 ## Quick navigation
 - [Per-model overrides: Kimi-K2.6](kimi-k2.6.md)
 - [Per-model overrides: Qwen3-235B-A22B-Instruct-2507](qwen3-235b-a22b-instruct-2507.md)
+- [Per-model overrides: MiniMax-M2.7](minimax-m2.7.md)
 - [Why was my param stripped/rejected?](troubleshooting.md)
 - [Client agents compatibility](agents.md)
 - [Source citations](references.md)
@@ -27,29 +28,29 @@ OpenAI-compatible chat completions, routed to Kimi-K2.6 / Qwen3-235B via vLLM. T
 |-------|------|---------|----------|--------|
 | `model` | string | — | Required; route key | [[OpenAI-1]](references.md#openai) |
 | `messages` | array | — | Required; OpenAI shape (see [Messages contract](#messages-contract)); ≤2048 entries | [[OpenAI-1]](references.md#openai) |
-| `temperature` | float | 1.0 | cap ≤ 2.0; sanitize (NaN/Inf strip) | [[OpenAI-1]](references.md#openai) |
-| `top_p` | float | 1.0 | sanitize (NaN/Inf strip) | [[OpenAI-1]](references.md#openai) |
-| `top_k` | int | — | sanitize float; vLLM extension | [[vLLM-1]](references.md#vllm) |
-| `min_p` | float | — | sanitize; vLLM extension | [[vLLM-1]](references.md#vllm) |
+| `temperature` | float | 1.0 | clamp to `[0, 2]`; sanitize (NaN/Inf strip) | [[OpenAI-1]](references.md#openai) |
+| `top_p` | float | 1.0 | clamp `>1` → `1`; reject `≤0` (must be in `(0, 1]` — [why](troubleshooting.md#reject-out-of-range-sampling)); sanitize (NaN/Inf strip) | [[OpenAI-1]](references.md#openai) |
+| `top_k` | int | — | must be `-1` (disabled) or `≥1`, else reject ([why](troubleshooting.md#reject-out-of-range-sampling)); sanitize float; vLLM extension | [[vLLM-1]](references.md#vllm) |
+| `min_p` | float | — | clamp to `[0, 1]`; sanitize; vLLM extension | [[vLLM-1]](references.md#vllm) |
 | `frequency_penalty` | float | 0.0 | clamp `[-2, 2]`; see [Kimi override](kimi-k2.6.md#parameter-overrides) for force-rewrite | [[OpenAI-1]](references.md#openai) |
 | `presence_penalty` | float | 0.0 | clamp `[-2, 2]`; see [Kimi override](kimi-k2.6.md#parameter-overrides) for force-rewrite | [[OpenAI-1]](references.md#openai) |
-| `repetition_penalty` | float | 1.0 | cap ≤ 2.0; vLLM extension | [[vLLM-1]](references.md#vllm) |
+| `repetition_penalty` | float | 1.0 | clamp `>2` → `2`; reject `≤0` (must be `>0` — [why](troubleshooting.md#reject-out-of-range-sampling)); vLLM extension | [[vLLM-1]](references.md#vllm) |
 | `logit_bias` | object | — | ≤1024 entries; value range `[-100, 100]` | [[OpenAI-1]](references.md#openai) |
-| `max_tokens` | int | — | clamp | [[OpenAI-1]](references.md#openai) |
-| `max_completion_tokens` | int | — | alias for max_tokens | [[OpenAI-1]](references.md#openai) |
-| `stream` | bool | false | pass-through | [[OpenAI-1]](references.md#openai) |
+| `max_tokens` | int | — | must be `≥1` (reject `0` — [why](troubleshooting.md#reject-nonpositive-max-tokens)); capped to model max; Kimi-K2.6 floors small values to 16 ([why](troubleshooting.md#kimi-empty-content-think-burn)) | [[OpenAI-1]](references.md#openai) |
+| `max_completion_tokens` | int | — | alias for max_tokens (same `≥1` reject / cap / Kimi-floor handling) | [[OpenAI-1]](references.md#openai) |
+| `stream` | bool | false | must be a boolean (else reject — [why](troubleshooting.md#reject-malformed-param-types)); pass-through | [[OpenAI-1]](references.md#openai) |
 | `stream_options` | object | — | strip when stream≠true; whitelist `include_usage`; strip `continuous_usage_stats` | [[OpenAI-1]](references.md#openai) |
-| `stop` | str\|array | — | pass-through; ≤16 entries × 256 B each | [[OpenAI-1]](references.md#openai) |
+| `stop` | str\|array | — | array entries must be strings (else reject — [why](troubleshooting.md#reject-malformed-param-types)); ≤16 entries × 256 B each | [[OpenAI-1]](references.md#openai) |
 | `n` | int | 1 | hard cap ≤5; coerce to 1 when temperature==0 ([why](troubleshooting.md#coerce-n-when-temperature-zero)) | [[OpenAI-1]](references.md#openai), [[CVE-9]](references.md#security-advisories) |
-| `seed` | uint64 | — | pass-through | [[OpenAI-1]](references.md#openai) |
+| `seed` | uint64 | — | must be a non-negative integer (else reject — [why](troubleshooting.md#reject-malformed-param-types)); pass-through | [[OpenAI-1]](references.md#openai) |
 | `logprobs` | bool | — | force `true`; observability pipeline | — |
 | `top_logprobs` | int | — | force `5`; observability pipeline | — |
 | `return_token_ids` | bool | — | force `true`; required for stream-derived `enforced_tokens` reconstruction on Kimi-K2.6 reasoning routes (without it, `<think>`/`</think>` are silently dropped from SSE while still counted in `usage.completion_tokens`). Resulting `prompt_token_ids` / `choices[].token_ids` are stripped from the client-facing response | [[vLLM-19]](references.md#vllm), [[vLLM-20]](references.md#vllm) |
 | `response_format` | object | — | shape-bounded (depth ≤16, nodes ≤128, branch arms ≤16, enum ≤256, size ≤16 KiB); `$ref`/`$defs`/`definitions` forbidden; `pattern` ≤512 B + must compile as regex; `json_schema.name` non-empty ≤64 chars matching `^[A-Za-z0-9_.-]+$`; schema must be an object | [[OpenAI-1]](references.md#openai), [[CVE-2]](references.md#security-advisories) |
-| `structured_outputs` | object | — | validated against vLLM envelope (`json`/`regex`/`choice`/`grammar`/`json_object`/`structural_tag`); CVE-driven caps per sub-field — see [Qwen native extensions](qwen3-235b-a22b-instruct-2507.md#native-extensions); **rejected on Kimi-K2.6 route** ([why](troubleshooting.md#reject-structured_outputs-kimi)); **rejected if combined with `response_format`** ([why](troubleshooting.md#reject-structured_outputs-with-response_format)) | [[vLLM-16]](references.md#vllm), [[vLLM-18]](references.md#vllm), [[CVE-3]](references.md#security-advisories), [[CVE-4]](references.md#security-advisories), [[CVE-8]](references.md#security-advisories) |
+| `structured_outputs` | object | — | validated against vLLM envelope (`json`/`regex`/`choice`/`grammar`/`json_object`/`structural_tag`); CVE-driven caps per sub-field — see [Qwen native extensions](qwen3-235b-a22b-instruct-2507.md#native-extensions); **rejected on Kimi-K2.6 route** ([why](troubleshooting.md#reject-structured_outputs-kimi)); **accepted on MiniMax-M2.7 route** — vLLM enforces it ([details](troubleshooting.md#accept-structured_outputs-minimax)); `structural_tag` must be the object form (string form is rejected — crashes the engine); **rejected if combined with `response_format`** ([why](troubleshooting.md#reject-structured_outputs-with-response_format)) | [[vLLM-16]](references.md#vllm), [[vLLM-18]](references.md#vllm), [[CVE-3]](references.md#security-advisories), [[CVE-4]](references.md#security-advisories), [[CVE-8]](references.md#security-advisories) |
 | `tools` | array | — | shape-bounded: function schema depth ≤16, nodes ≤256, branch arms ≤16, enum ≤256, size ≤16 KiB; `$ref`/`$defs`/`definitions` forbidden; `pattern` ≤512 B + regex compile; `function.name` ≤64 B; `tools[].function.strict` silent-stripped (vLLM parsers ignore) | [[OpenAI-1]](references.md#openai), [[CVE-2]](references.md#security-advisories) |
 | `tool_choice` | string\|object | "auto" if tools | shape-strict; `function.name` ≤64 B; `"required"` coerced ([why](troubleshooting.md#coerce-tool-choice-required)) | [[OpenAI-1]](references.md#openai) |
-| `parallel_tool_calls` | bool | — | pass-through | [[OpenAI-1]](references.md#openai) |
+| `parallel_tool_calls` | bool | — | must be a boolean (else reject — [why](troubleshooting.md#reject-malformed-param-types)); pass-through | [[OpenAI-1]](references.md#openai) |
 | `user` | string | — | byte-length ≤512 | [[OpenAI-1]](references.md#openai) |
 | `safety_identifier` | string | — | silent-strip; see [Kimi override](kimi-k2.6.md#parameter-overrides) for pass-through ([why](troubleshooting.md#strip-safety_identifier)) | [[OpenAI-6]](references.md#openai) |
 | `metadata` | object | — | OpenAI bounds: ≤16 keys × 64-char × 512-char vals | [[OpenAI-1]](references.md#openai) |
@@ -66,11 +67,11 @@ OpenAI-compatible chat completions, routed to Kimi-K2.6 / Qwen3-235B via vLLM. T
 | `enable_thinking` | bool | — | translate to chat_template_kwargs ([why](troubleshooting.md#translate-enable_thinking)) | [[Qwen-3]](references.md#qwen) |
 | `thinking_config` | object | — | silent-strip ([why](troubleshooting.md#strip-thinking_config)) | — |
 | `think` | bool | — | silent-strip ([why](troubleshooting.md#strip-think)) | — |
-| `min_tokens` | int | — | vLLM extension; clamp to ≤max_tokens; conditional strip when stop_token_ids set | [[vLLM-1]](references.md#vllm) |
-| `bad_words` | string array | — | vLLM extension; ≤64 entries × 128 B per entry | [[vLLM-1]](references.md#vllm) |
-| `stop_token_ids` | int array | — | vLLM extension; ≤64 | [[vLLM-1]](references.md#vllm) |
-| `skip_special_tokens` | bool | — | vLLM extension; pass-through | [[vLLM-1]](references.md#vllm) |
-| `detokenize` | bool | — | vLLM extension; pass-through | [[vLLM-1]](references.md#vllm) |
+| `min_tokens` | int | — | vLLM extension; must be a non-negative integer (else reject — [why](troubleshooting.md#reject-malformed-param-types)); clamp to ≤max_tokens; conditional strip when stop_token_ids set | [[vLLM-1]](references.md#vllm) |
+| `bad_words` | string array | — | vLLM extension; entries must be strings (else reject — [why](troubleshooting.md#reject-malformed-param-types)); ≤64 entries × 128 B per entry | [[vLLM-1]](references.md#vllm) |
+| `stop_token_ids` | int array | — | vLLM extension; entries must be non-negative integers (else reject — [why](troubleshooting.md#reject-malformed-param-types)); ≤64 | [[vLLM-1]](references.md#vllm) |
+| `skip_special_tokens` | bool | — | vLLM extension; must be a boolean (else reject — [why](troubleshooting.md#reject-malformed-param-types)) | [[vLLM-1]](references.md#vllm) |
+| `detokenize` | bool | — | vLLM extension; must be a boolean (else reject — [why](troubleshooting.md#reject-malformed-param-types)) | [[vLLM-1]](references.md#vllm) |
 | `chat_template_kwargs` | object | — | depth ≤16, nodes ≤128, size ≤16 KiB; key denylist (`chat_template`, `tokenize`, `tools`, `documents`, `conversation`, `continue_final_message`, `padding`, `truncation`, `max_length`, `return_tensors`, `return_dict`) — CVE-2025-61620 / CVE-2025-62426 mitigation | [[vLLM-1]](references.md#vllm), [[CVE-5]](references.md#security-advisories), [[CVE-6]](references.md#security-advisories) |
 
 *Parameters with truly model-exclusive behavior (`thinking`, `thinking_token_budget`, `messages[].reasoning_content`) are documented in the per-model docs — see [Kimi-K2.6](kimi-k2.6.md) and [Qwen3-235B-A22B-Instruct-2507](qwen3-235b-a22b-instruct-2507.md). For params with universal baseline behavior plus per-model adjustments (`frequency_penalty`, `presence_penalty`, `safety_identifier`), the baseline appears above and the per-model override is linked from the row.*
@@ -103,6 +104,7 @@ Enforced by the gateway's message validator:
 - **Lenient SDK compat:** orphan `role: "tool"` messages — those whose `tool_call_id` was never emitted by a prior `assistant.tool_calls[].id` — are silently dropped before validation. Long agent conversations sometimes lose part of a multi-tool fan-out during client-side history compaction.
 - **Lenient SDK compat:** empty `role: "assistant"` turns — no `content` AND no `tool_calls` AND no `function_call` — are silently dropped. The model can't observe an informationless turn; the drop is a semantic no-op.
 - **Strict (no lenient compat):** duplicate `tool_calls[].id` within a single assistant message is rejected per OpenAI spec — see [troubleshooting](troubleshooting.md#reject-duplicate-tool-call-id).
+- **Route-specific shape:** the `MiniMaxAI/MiniMax-M2.7` route uses a different `role:"tool"` contract — `content` is a `{name,type,text}[]` array, `tool_call_id` is absent (silently stripped if present), and the orphan-drop policy is "no preceding assistant.tool_calls[] block" rather than "no matching tool_call_id". See [accept-tool-message-minimax-shape](troubleshooting.md#accept-tool-message-minimax-shape) and the [MiniMax-M2.7 per-model doc](minimax-m2.7.md).
 
 ## Errors
 
diff --git a/docs/chat-api/agents.md b/docs/chat-api/agents.md
index e082dda91f..c98d99706c 100644
--- a/docs/chat-api/agents.md
+++ b/docs/chat-api/agents.md
@@ -28,6 +28,14 @@ Cause: model (typically Kimi-K2.6) emitted duplicate symbolic ids in one assista
 
 Cause: Kimi-K2.6 reads from `chat_template_kwargs.thinking` only — the gateway mirrors automatically from top-level `thinking.type`. The top-level field is dropped after mirroring. To override the mirrored value, pre-set `chat_template_kwargs.thinking` directly in your request body.
 
+### "My tool message is rejected on MiniMax-M2.7"
+
+Cause: MiniMax-M2.7 uses a different `role:"tool"` contract from OpenAI — `content` must be an array of `{name, type:"text", text}` entries, with no `tool_call_id`. Bare-string `content` or OpenAI-style `tool_call_id`-correlated messages are rejected with HTTP 400. See [accept-tool-message-minimax-shape](troubleshooting.md#accept-tool-message-minimax-shape) and the [MiniMax-M2.7 per-model doc](minimax-m2.7.md). Clients dual-emitting `tool_call_id` for portability across routes are fine — the gateway silently strips it.
+
+### "My `<think>` blocks disappeared on MiniMax-M2.7"
+
+They shouldn't. MiniMax-M2.7 emits reasoning inline as `<think>...</think>` in `content`, and the gateway preserves these byte-identical across multi-turn history. If you're seeing them stripped, you're probably running them through a client-side reasoning filter — keep them in conversation history for chain-of-thought continuity ([[MiniMax-5]](references.md#minimax)).
+
 ### "My cache key disappeared"
 
 Cause: `cache_key` / `prompt_cache_key` silently stripped. vLLM uses a different field (`cache_salt`) for cache isolation, and the aliasing PR is unmerged — see [troubleshooting](troubleshooting.md#strip-cache_key) for the full chain of upstream gaps.
diff --git a/docs/chat-api/kimi-k2.6.md b/docs/chat-api/kimi-k2.6.md
index e88ce80774..89b378f348 100644
--- a/docs/chat-api/kimi-k2.6.md
+++ b/docs/chat-api/kimi-k2.6.md
@@ -29,6 +29,7 @@ Infrastructure-level constraints that must hold BEFORE this route is served —
 | `safety_identifier` | strip | **pass-through** (string, ≤512 B) | Moonshot consumes the field for abuse tracking on their hosted backend [[Moonshot-1]](references.md#moonshot) |
 | `frequency_penalty` | clamp [-2, 2] | **force-rewrite to `0.0`** | Moonshot's K2.6 wire accepts only `0.0`; model-side constraint [[Moonshot-1]](references.md#moonshot) |
 | `presence_penalty` | clamp [-2, 2] | **force-rewrite to `0.0`** | same as above [[Moonshot-1]](references.md#moonshot) |
+| `max_tokens` / `max_completion_tokens` | pass-through (capped) | **floor to 16** | Below 16 the model emits only `</think>` (vLLM strips it as a special token) — see [troubleshooting](troubleshooting.md#kimi-empty-content-think-burn). PR [#1227](https://github.com/gonka-ai/gonka/pull/1227). |
 | `tools[].function.strict` | (silent-strip in universal via `ToolsValidator`) | silent-strip — vLLM `kimi_k2` parser ignores | [[vLLM-1]](references.md#vllm) |
 
 ## Native extensions
@@ -38,7 +39,7 @@ Infrastructure-level constraints that must hold BEFORE this route is served —
 | Param | Type | Behavior | Source |
 |-------|------|----------|--------|
 | `thinking` | object | `{type: "enabled"\|"disabled"\|"adaptive"\|"auto"}`. `adaptive`/`auto` are client-side opt-in (Claude Code CLI / Kimi clients) and resolve to enabled. Validator mirrors the resolved boolean into `chat_template_kwargs.thinking` and **drops top-level `thinking`** — the chat template only reads from kwargs. Sibling `display` field is silent-stripped ([why](troubleshooting.md#strip-display-thinking-sibling)). | [[Anthropic-1]](references.md#anthropic), [[Moonshot-1]](references.md#moonshot) |
-| `thinking_token_budget` | int | Injects `max_tokens / 2` default; clamp ≤ 96 000 and ≤ `max_tokens` (96k matches Moonshot's HLE/AIME reasoning budget) | [[Moonshot-3]](references.md#moonshot) |
+| `thinking_token_budget` | int | Resolution order: (1) if `max_tokens < 256`, force `0` to bypass thinking entirely; (2) else if absent, default to `max_tokens / 2`; (3) cap at 96 000 (Moonshot HLE/AIME budget); (4) clamp to `max_tokens − 64` so visible content always has headroom after `</think>`. See [troubleshooting](troubleshooting.md#kimi-empty-content-think-burn). | [[Moonshot-3]](references.md#moonshot), [[OpenAI-4]](references.md#openai) |
 | `messages[].reasoning_content` | string | Pass-through on assistant turns (Kimi multi-turn replay convention) | [[Moonshot-1]](references.md#moonshot) |
 
 <details>
@@ -53,6 +54,8 @@ Accepted values for `thinking.type`:
 Sibling `display` field (Claude Code UI hint, e.g. `"summarized"`) is silent-stripped because it has no vLLM semantics — the value never reaches the chat template.
 
 Pre-existing `chat_template_kwargs.thinking` wins on conflict (no overwrite of explicit caller intent).
+
+**`thinking:disabled` does NOT zero out `thinking_token_budget`.** Kimi-K2.6 empirically ignores the disable hint on hard prompts (math, code) and still emits a `<think>` block ([PR #1202 live measurements](https://github.com/gonka-ai/gonka/pull/1202)), so the validator keeps `ttb = max_tokens / 2` as a safety net — without it, the model burns the entire `max_tokens` on hidden reasoning and the client gets empty content. If the model ever honors the disable hint cleanly, the unused budget has no downside. To genuinely opt out of thinking, send `thinking_token_budget: 0` explicitly — the validator preserves client-set zero. Sending `max_tokens < 256` also force-zeroes ttb (see [troubleshooting](troubleshooting.md#kimi-empty-content-think-burn)).
 </details>
 
 ## Structured outputs
@@ -65,7 +68,9 @@ Pre-existing `chat_template_kwargs.thinking` wins on conflict (no overwrite of e
 ## Known model-side bugs we work around
 
 - **Duplicate `tool_calls[].id` emission**: vLLM `kimi_k2` parser has a confirmed counter-collision bug when running with `n>1` — `history_tool_call_cnt` recomputed inside the per-choice loop produces colliding `functions.<name>:<idx>` ids. See [vLLM PR #21259](https://github.com/vllm-project/vllm/pull/21259) review thread. The gateway rejects duplicate ids per OpenAI spec — see [troubleshooting](troubleshooting.md#reject-duplicate-tool-call-id). Clients must rewrite ids client-side per Moonshot's official guidance [[Moonshot-3]](references.md#moonshot).
-- **Empty content + `finish_reason=length` when thinking eats the budget**: at small `max_tokens` Kimi-K2.6 routinely consumes the entire budget inside `<think>...</think>` and returns visible content as empty. Mitigated by `thinking_token_budget` default injection (see Native extensions above) — gateway injects `max_tokens / 2` when the field is absent, leaving half the budget for visible content.
+- **Empty content + `finish_reason=length` when thinking eats the budget**: at small `max_tokens` Kimi-K2.6 burns the entire budget inside `<think>...</think>` and vLLM strips `</think>` as a special token, leaving `content=null`. Mitigated on **two layers**:
+  - **Request side**: `thinking_token_budget` resolver (above) — force-zero below 256, default `max_tokens / 2`, content-headroom clamp.
+  - **Response side**: hosts that empty-stream while `usage.completion_tokens > 0` are classified as model burn ([[OpenAI-4]](references.md#openai)) — telemetry-only, no quarantine. See [troubleshooting](troubleshooting.md#kimi-empty-content-think-burn).
 
 ## See also
 - [Troubleshooting](troubleshooting.md)
diff --git a/docs/chat-api/minimax-m2.7.md b/docs/chat-api/minimax-m2.7.md
new file mode 100644
index 0000000000..25b524cec2
--- /dev/null
+++ b/docs/chat-api/minimax-m2.7.md
@@ -0,0 +1,88 @@
+# MiniMax-M2.7 (`MiniMaxAI/MiniMax-M2.7`) — overrides & extensions
+
+Provider: MiniMax AI. This doc documents how MiniMax-M2.7 deviates from the [universal contract](README.md). For params that behave the same as universal, see the universal contract directly.
+
+Mirrors the structure of [Kimi-K2.6](kimi-k2.6.md) and [Qwen3-235B](qwen3-235b-a22b-instruct-2507.md). Chain-side wiring (HfCommit pin, ModelArgs, PoC params) lives in `inference-chain/app/upgrades/v0_2_13/upgrades.go`.
+
+## Model facts
+
+| Property | Value | Source |
+|----------|-------|--------|
+| Provider | MiniMax AI | [[MiniMax-1]](references.md#minimax) |
+| vLLM route id | `MiniMaxAI/MiniMax-M2.7` | — |
+| Total params | 229 B (sparse MoE; ~10 B activated, inherited from M2 base) | [[MiniMax-2]](references.md#minimax) |
+| Tensor types | F32 / BF16 / F8_E4M3 (FP8) | [[MiniMax-2]](references.md#minimax) |
+| Max context per sequence | 196 K tokens (180 K served) | [[MiniMax-3]](references.md#minimax) |
+| Tool-call parser (vLLM) | `minimax_m2` | [[MiniMax-3]](references.md#minimax), [[vLLM-21]](references.md#vllm) |
+| Reasoning parser (vLLM) | `minimax_m2_append_think` (per MiniMax guide); see [parser caveat](#deployment-requirements) | [[MiniMax-3]](references.md#minimax) |
+| Native thinking | yes — **interleaved** `<think>...</think>` tags embedded in `content` | [[MiniMax-2]](references.md#minimax), [[MiniMax-4]](references.md#minimax) |
+| Recommended sampling | `temperature=1.0, top_p=0.95, top_k=40` | [[MiniMax-2]](references.md#minimax) |
+
+## Deployment requirements
+
+Infrastructure-level constraints that must hold BEFORE this route is served — these are enforced by vLLM engine configuration / flags, NOT by the gateway:
+
+- **HfCommit pinned** — `--trust-remote-code` is required by the model card ([[MiniMax-3]](references.md#minimax)), which puts the deployment inside the blast radius of [[CVE-12]](references.md#security-advisories) (vLLM hardcoded trust_remote_code bypass via malicious model repositories). Mitigation: pin the HuggingFace `revision=<commit-sha>` to a verified weights checkpoint. Never serve `revision=main`.
+- **Tool-call parser MUST be `minimax_m2`** ([[vLLM-21]](references.md#vllm)). Drives the wire-format the model emits (`<minimax:tool_call>` XML, converted to OpenAI `tool_calls[]` on the response by vLLM).
+- **Reasoning parser caveat** — official MiniMax recommendation is `--reasoning-parser minimax_m2_append_think` ([[MiniMax-3]](references.md#minimax)). vLLM upstream has known bugs on M2.5+ with this parser ([[vLLM-23]](references.md#vllm), [[vLLM-24]](references.md#vllm), [[vLLM-27]](references.md#vllm)): `extract_reasoning_streaming` assumes no opening `<think>` tag (M2.5+ emits one), and reasoning can be missing from SSE deltas. The visible-content stream still includes the reasoning, just not separated into `reasoning_content`. For the gateway this means `<think>...</think>` blocks land **inline in `content`** on responses — the pass-through design already handles this.
+- **Pure TP8 is NOT supported** — vLLM recipe forbids it; H100 TP4+EP4 is the supported topology ([[vLLM-21]](references.md#vllm)).
+- **AMD path (MI300X/MI325X/MI350X/MI355X)** requires `VLLM_ROCM_USE_AITER=1 VLLM_ROCM_SHUFFLE_KV_CACHE_LAYOUT=1`; first AITER launch JITs for several minutes ([[vLLM-21]](references.md#vllm)).
+- **Avoid Ampere (A100) FP8** — M2.7 FP8 loads on vLLM v0.19.0 but crashes on nightly ([[vLLM-22]](references.md#vllm)). Either stay on a pinned tagged release or use BF16 on Ampere.
+- **Disable `pythonic` and `qwen3_coder` tool-call parsers** — same vendor-agnostic CVE history that applies to Kimi/Qwen routes ([[CVE-1]](references.md#security-advisories), [[CVE-7]](references.md#security-advisories)).
+
+## Parameter overrides
+
+*Delta from [universal contract](README.md#supported-parameters-universal-behavior). Listed params behave differently on this route; everything else matches universal.*
+
+| Param | Universal | On MiniMax-M2.7 | Why |
+|-------|-----------|-----------------|-----|
+| `tools[].function.strict` | (silent-strip in universal via `ToolsValidator`) | silent-strip — vLLM `minimax_m2` parser ignores | [[vLLM-21]](references.md#vllm) |
+| `thinking` (top-level Anthropic-style object) | mirrored to `chat_template_kwargs.thinking` on Kimi route | **silent-strip on this route** — MiniMax has no `chat_template_kwargs` toggle for thinking; thinking is always on and emitted inline as `<think>...</think>` in `content`. Clients wanting to suppress thinking display must parse + filter client-side. | [[MiniMax-2]](references.md#minimax), [why](troubleshooting.md#strip-thinking-minimax) |
+| `thinking_token_budget` | injected/clamped on Kimi; silent-strip on Qwen | **silent-strip** — no equivalent knob in MiniMax chat template | [[MiniMax-2]](references.md#minimax) |
+| `enable_thinking` (top-level) | translated to `chat_template_kwargs.enable_thinking` on Qwen | **silent-strip on this route** — MiniMax does not honor; thinking is structural to the chat template, not configurable per request ([[vLLM-25]](references.md#vllm)). | [why](troubleshooting.md#strip-enable_thinking-minimax) |
+| `safety_identifier` | strip (universal); pass-through on Kimi | strip (no MiniMax abuse-tracking API contract) | [[MiniMax-1]](references.md#minimax) |
+| Content of `role:"tool"` messages | universal: string or text-part array, flattened to string; `tool_call_id` required | **MiniMax shape**: `content: [{name, type:"text", text}]` array; no `tool_call_id` (silently stripped if dual-emitted). Per-entry caps: ≤16 entries × `name` ≤64 B × `text` ≤64 KiB; closed allow-list of keys. | [[MiniMax-4]](references.md#minimax), [why](troubleshooting.md#accept-tool-message-minimax-shape) |
+
+## Native extensions
+
+*Params unique to this route — no equivalent in the universal contract.*
+
+| Param | Type | Behavior | Source |
+|-------|------|----------|--------|
+| `extra_body.reasoning_split` | bool | If `true`, vLLM/MiniMax emit reasoning as a separate `reasoning_details[]` array on the response instead of inline `<think>...</think>` blocks in `content`. Gateway unwraps `extra_body` per universal contract; the lifted key passes through to vLLM. Document client responsibility: round-trip `reasoning_details` (or `<think>` blocks) verbatim into history. | [[MiniMax-5]](references.md#minimax) |
+| `messages[].reasoning_details` | array | Assistant-turn reasoning history when client uses `reasoning_split=true`. **Pass-through** — assistant-side validator does not strip. **Critical:** stripping these breaks M2.7 interleaved-thinking continuity. | [[MiniMax-5]](references.md#minimax) |
+| `<think>...</think>` blocks in assistant `content` | inline tags | **Pass-through verbatim** when round-tripped in history. The gateway message validator MUST NOT strip these from prior assistant turns or rewrite their internals. | [[MiniMax-2]](references.md#minimax), [[MiniMax-5]](references.md#minimax) |
+| Tool-call output XML (`<minimax:tool_call><invoke name=…><parameter name=…>`) | tag stream | Emitted by the model verbatim; the vLLM `minimax_m2` tool-call parser converts to OpenAI `tool_calls[]` format on the response. Gateway pass-through — no special handling required on the response path. | [[MiniMax-4]](references.md#minimax), [[vLLM-21]](references.md#vllm) |
+| MiniMax-only response fields (`base_resp`, `output_sensitive`, `input_sensitive`) | object / bool | **Pass-through** on the response. Document existence; clients may ignore. | [[MiniMax-5]](references.md#minimax) |
+
+## Rejected MiniMax-platform-only keys
+
+*Fields the MiniMax direct API (platform.minimax.io) accepts that the gateway rejects with HTTP 400 via the closed top-level allowlist. Listed so clients porting from the MiniMax platform see why their request fails.*
+
+| Param | Why rejected |
+|-------|--------------|
+| `partial` | Assistant-prefill / continuation flag on the MiniMax platform. Rejected because it bypasses the gateway's per-role message validation (which treats the trailing turn as a new prompt, not a forced model continuation) and would expose vLLM to a chat-template integrity hazard that the OpenAI Chat Completions contract does not anticipate. Clients wanting equivalent behavior must shape the request through the normal `messages[]` array. [[MiniMax-5]](references.md#minimax) |
+| `web_search` / `enable_search` / `search_kwargs` | MiniMax platform-side network-search features; vLLM does not implement them. Silent-stripping would mislead clients into thinking search ran. Fail-loud is the safer default. [[MiniMax-1]](references.md#minimax) |
+| `mask_sensitive_info` | MiniMax platform-side content masking; not implemented in vLLM. Same fail-loud rationale. [[MiniMax-1]](references.md#minimax) |
+
+## Structured outputs
+
+| Field | Status | Note |
+|-------|--------|------|
+| `response_format` | ✅ supported (see universal) | xgrammar via vLLM; full schema bounds enforced. Compatible with thinking models since xgrammar runs on the `content`-emission phase, after thinking. |
+| `structured_outputs` | ✅ **accepted on this route** | vLLM enforces the constraint on M2.7 (verified with discriminating/control requests across `json`/`regex`/`choice`/`grammar`/`json_object`). `structural_tag` must be the object form — the JSON-encoded string form is rejected (crashes the engine). See [accept-structured_outputs-minimax](troubleshooting.md#accept-structured_outputs-minimax). |
+
+## Known model-side bugs we work around
+
+- **Streaming tool_calls malformation** ([[vLLM-26]](references.md#vllm), [[SGLang-1]](references.md#sglang)): under SSE streaming a single tool call is sometimes emitted as two `tool_calls[]` entries — one with `name=null` and duplicated `arguments`. PR #35895 fixed the `stream_interval > 1` case; the `name=null` malformation may still occur with concurrent calls. Documented as a known client-responsibility issue.
+- **Tool-call parser fails on `str | null` param types** ([[SGLang-2]](references.md#sglang)): `minimax_m2_tool_parser._convert_param_value` errors on union-with-null param values; clients should avoid `["string","null"]` in tool parameter schemas.
+- **Reasoning missing in stream mode** ([[vLLM-27]](references.md#vllm)): when serving with `--reasoning-parser minimax_m2_append_think` and `stream=true`, reasoning_content is sometimes absent from delta chunks. Upstream bug; no gateway mitigation.
+- **`thinking` cannot be disabled** ([[vLLM-25]](references.md#vllm)): even with `chat_template_kwargs.enable_thinking=false`, M2.5+ still emits `<think>` blocks. Confirms the strip-`enable_thinking` policy.
+- **A100 / Ampere FP8 regression** ([[vLLM-22]](references.md#vllm)): M2.7 FP8 fails on Ampere with vLLM nightly. Mitigated by deployment-side version pin; no gateway responsibility.
+
+## See also
+- [Troubleshooting](troubleshooting.md)
+- [References](references.md)
+- [Universal contract](README.md)
+- [Kimi-K2.6 overrides](kimi-k2.6.md)
+- [Qwen3-235B overrides](qwen3-235b-a22b-instruct-2507.md)
diff --git a/docs/chat-api/references.md b/docs/chat-api/references.md
index 760fe75914..d040c855a1 100644
--- a/docs/chat-api/references.md
+++ b/docs/chat-api/references.md
@@ -8,10 +8,12 @@ Namespaces:
 - `[vLLM-N]` vLLM
 - `[Moonshot-N]` Moonshot (includes Kimi model line)
 - `[Qwen-N]` Qwen
+- `[MiniMax-N]` MiniMax AI (MiniMax-M2 line)
+- `[SGLang-N]` SGLang (cross-engine parser bug references)
 - `[OpenRouter-N]` OpenRouter
 - `[CVE-N]` security advisories
 
-Industry/community sources (Ollama blog, OpenAI community thread, arxiv papers) are inline links in `troubleshooting.md` and `agents.md`, not here. Captured-requests evidence is referenced inline by request-id.
+Industry/community sources (Ollama blog, OpenAI community thread, arxiv papers) are inline links in `troubleshooting.md` and `agents.md`, not here. Captured-requests evidence is referenced inline by request-id. Chain governance changes (model registration, ModelArgs pins) are cited inline by PR number under the appropriate per-model doc, not in this file.
 
 ## OpenAI
 
@@ -25,6 +27,7 @@ Industry/community sources (Ollama blog, OpenAI community thread, arxiv papers)
 ## Anthropic
 
 - **[Anthropic-1]** [Extended thinking docs](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) — wire enum for `thinking.type` (`enabled`/`disabled`); basis for rejecting `adaptive`/`auto` as non-wire values.
+- **[Anthropic-2]** [Handling stop reasons](https://docs.anthropic.com/en/docs/build-with-claude/handling-stop-reasons) — documents `stop_reason="max_tokens"` with empty/truncated content as an expected outcome when extended thinking consumes the budget; advises continuation rather than retry.
 
 ## vLLM
 
@@ -48,6 +51,14 @@ Industry/community sources (Ollama blog, OpenAI community thread, arxiv papers)
 - **[vLLM-18]** [Structured outputs feature docs](https://docs.vllm.ai/en/latest/features/structured_outputs.html) — `structured_outputs` supersedes `guided_json`/`guided_regex`/`guided_grammar`/`guided_choice`.
 - **[vLLM-19]** [PR #29074 — kimi_k2 reasoning parser: emit DeltaMessage when return_token_ids=true](https://github.com/vllm-project/vllm/pull/29074) — changes `extract_reasoning_streaming` to emit an empty `DeltaMessage()` (with the token id attached) instead of `None` for single-token deltas carrying `<think>`/`</think>`. Without `return_token_ids=true`, those tokens are silently dropped from the SSE stream while still counted in `usage.completion_tokens`, producing a hidden-token gap that breaks stream-derived `enforced_tokens` reconstruction.
 - **[vLLM-20]** [kimi_k2_reasoning_parser.py source](https://github.com/vllm-project/vllm/blob/main/vllm/reasoning/kimi_k2_reasoning_parser.py) — the parser whose `extract_reasoning_streaming` returns `None` (= suppresses event) when a delta is exactly `<think>` or `</think>`. Tokens still counted in usage; vLLM-19 added the `return_token_ids` escape valve.
+- **[vLLM-21]** [vLLM Recipes — MiniMax-M2 Series Usage Guide](https://docs.vllm.ai/projects/recipes/en/latest/MiniMax/MiniMax-M2.html) — official vLLM recipe covering M2/M2.1/M2.5/M2.7 deployment (parsers, topology, compilation-config, AMD AITER env vars).
+- **[vLLM-22]** [Issue #39610 — MiniMax-M2.7/Qwen3.5 FP8 fail on A100/Ampere with nightly](https://github.com/vllm-project/vllm/issues/39610) — regression confirmed vs v0.19.0.
+- **[vLLM-23]** [Issue #38212 — MiniMaxM2ReasoningParser broken for M2.5](https://github.com/vllm-project/vllm/issues/38212) — `extract_reasoning_streaming` assumes no opening `<think>` tag; M2.5/.7 do emit it.
+- **[vLLM-24]** [Issue #34625 — Reasoning Parser not working with MiniMax M2.5](https://github.com/vllm-project/vllm/issues/34625) — same parser class affects M2.5+ reasoning extraction.
+- **[vLLM-25]** [Issue #36778 — Thinking cannot be disabled on M2.5 via chat_template_kwargs](https://github.com/vllm-project/vllm/issues/36778) — drives strip-`enable_thinking` policy on the M2.7 route.
+- **[vLLM-26]** [PR #35895 — minimax_m2 tool parser fix for stream_interval > 1](https://github.com/vllm-project/vllm/pull/35895) — covers one streaming malformation class.
+- **[vLLM-27]** [Issue #36632 — MiniMax-M2.5 reasoning missing in chat completions stream](https://github.com/vllm-project/vllm/issues/36632) — `--reasoning-parser minimax_m2_append_think` skips reasoning content in SSE deltas.
+- **[vLLM-28]** [Issue #28963 — MiniMax tool parsing errors](https://github.com/vllm-project/vllm/issues/28963) — error in `_convert_param_value`.
 
 ## Moonshot
 
@@ -62,6 +73,19 @@ Industry/community sources (Ollama blog, OpenAI community thread, arxiv papers)
 - **[Qwen-2]** [Qwen3-235B-A22B-Instruct-2507-FP8 model card](https://huggingface.co/Qwen/Qwen3-235B-A22B-Instruct-2507-FP8) — FP8 quantised variant model card; same non-thinking confirmation.
 - **[Qwen-3]** [Qwen vLLM deployment docs](https://qwen.readthedocs.io/en/latest/deployment/vllm.html) — canonical placement for `enable_thinking` inside `chat_template_kwargs`; notes it is not OpenAI API compatible at the top level.
 
+## MiniMax
+
+- **[MiniMax-1]** [MiniMax platform docs index](https://platform.minimax.io/docs) — overview of MiniMax-hosted API surface.
+- **[MiniMax-2]** [MiniMax-M2.7 model card](https://huggingface.co/MiniMaxAI/MiniMax-M2.7) — architecture (229B params, F32/BF16/F8_E4M3 tensor types), sampling recommendations, interleaved `<think>...</think>` constraint.
+- **[MiniMax-3]** [MiniMax-M2.7 vLLM deployment guide](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/docs/vllm_deploy_guide.md) — exact CLI invocations, GPU sizing (220 GB weights + 240 GB/1M tokens), 196K max context per sequence, parser flags.
+- **[MiniMax-4]** [MiniMax-M2.7 tool calling guide](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/docs/tool_calling_guide.md) — `<minimax:tool_call><invoke><parameter>` output format; `role:"tool"` with `content:[{name,type,text}]` array (no `tool_call_id`).
+- **[MiniMax-5]** [MiniMax M2 Tool Use & Interleaved Thinking docs](https://platform.minimax.io/docs/guides/text-m2-function-call) — `extra_body.reasoning_split`, `reasoning_details[]` response field, multi-turn history rules.
+
+## SGLang
+
+- **[SGLang-1]** [Issue #23071 — MiniMax-M2 streaming tool_calls malformed](https://github.com/sgl-project/sglang/issues/23071) — under SSE streaming a single tool call sometimes splits into two entries (`name=null` + duplicated arguments).
+- **[SGLang-2]** [Issue #16057 — MiniMax M2 tool parser failure on `str | null` union param types](https://github.com/sgl-project/sglang/issues/16057) — parser crashes on union-with-null in tool parameter schema; potential DoS vector via crafted tool schema.
+
 ## OpenRouter
 
 - **[OpenRouter-1]** [Chat Completion API reference](https://openrouter.ai/docs/api/api-reference/chat/send-chat-completion-request) — OpenRouter wire schema for `/api/v1/chat/completions`.
@@ -84,4 +108,7 @@ Industry/community sources (Ollama blog, OpenAI community thread, arxiv papers)
 - **[CVE-9]** [CVE-2026-34756 / GHSA-3mwp-wvh9-7528 (vLLM)](https://github.com/vllm-project/vllm/security/advisories/GHSA-3mwp-wvh9-7528) — unbounded `n` causes OOM; `CapUintParameterHandler` clamps `n ≤ 5`.
 - **[CVE-10]** [CVE-2026-44222 / GHSA-hpv8-x276-m59f (vLLM)](https://github.com/vllm-project/vllm/security/advisories/GHSA-hpv8-x276-m59f) — special-token literals crash VL models; requires content sanitizer for Kimi-K2.6 multimodal path.
 - **[CVE-11]** [CVE-2026-44223 / GHSA-83vm-p52w-f9pw (vLLM)](https://github.com/vllm-project/vllm/security/advisories/GHSA-83vm-p52w-f9pw) — penalty fields crash EngineCore with `extract_hidden_states` spec decode; pin vLLM ≥ 0.20.0.
+- **[CVE-12]** [CVE-2026-27893 / RAXE-2026-044 (vLLM)](https://raxe.ai/labs/advisories/RAXE-2026-044) — vLLM hardcoded trust_remote_code bypass enables RCE via malicious model repositories; direct mitigation for the MiniMax-M2.7 route is the chain-pinned `HfCommit` SHA in the governance model config.
+- **[CVE-13]** [CVE-2026-22778 (vLLM)](https://www.ox.security/blog/cve-2026-22778-vllm-rce-vulnerability/) — RCE via crafted video link in multimodal content; gateway mitigates by rejecting non-text content parts on all text-only routes (M2.7 included).
+- **[CVE-14]** [CVE-2025-62164 / GHSA-mrw7-hf4f-83pf (vLLM)](https://github.com/advisories/GHSA-mrw7-hf4f-83pf) — tensor deserialization → DoS / potential RCE; pin vLLM ≥ patched release.
 
diff --git a/docs/chat-api/troubleshooting.md b/docs/chat-api/troubleshooting.md
index d0b5c22698..2ab36159dc 100644
--- a/docs/chat-api/troubleshooting.md
+++ b/docs/chat-api/troubleshooting.md
@@ -7,6 +7,7 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 | HTTP / behavior | Common cause | Anchor |
 |-----------------|--------------|--------|
 | 400 `"<param>" is currently rejected by the Gonka network` | non-allowlist parameter | [#reject-unknown-param](#reject-unknown-param) |
+| 400 `...name must be a non-empty string` on a whitespace-only name | names are trimmed before the non-empty check | [#reject-whitespace-names](#reject-whitespace-names) |
 | 400 `messages[N].tool_calls[M].id is duplicated` | Kimi-K2.6 model-side bug | [#reject-duplicate-tool-call-id](#reject-duplicate-tool-call-id) |
 | 400 on `tags` | undocumented field | [#reject-tags](#reject-tags) |
 | 400 on `guided_json` / `guided_regex` / etc. | vLLM-native structured decoding | [#reject-guided-decoding](#reject-guided-decoding) |
@@ -20,6 +21,11 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 | `extra_body` keys appear at top level | OpenAI Python SDK passthrough | [#unwrap-extra_body](#unwrap-extra_body) |
 | `enable_thinking` lifts into `chat_template_kwargs` | Qwen3 canonical placement | [#translate-enable_thinking](#translate-enable_thinking) |
 | `reasoning` object decomposed to top-level `reasoning_effort` | OpenRouter unified-reasoning convention | [#translate-reasoning](#translate-reasoning) |
+| 400 on out-of-range `top_p` / `repetition_penalty` / `top_k` | value outside backend-accepted range | [#reject-out-of-range-sampling](#reject-out-of-range-sampling) |
+| 400 on `max_tokens: 0` (non-Kimi route) | zero output budget | [#reject-nonpositive-max-tokens](#reject-nonpositive-max-tokens) |
+| 400 on wrong-typed param (bool / int / array element) | type mismatch caught at the gateway | [#reject-malformed-param-types](#reject-malformed-param-types) |
+| `thinking_token_budget` forced to `0` on Kimi-K2.6 with small `max_tokens` | content-headroom guard | [#kimi-empty-content-think-burn](#kimi-empty-content-think-burn) |
+| Empty `content` / `finish_reason=length` on Kimi-K2.6 | thinking ate the budget | [#kimi-empty-content-think-burn](#kimi-empty-content-think-burn) |
 
 ## Silent strips
 
@@ -33,8 +39,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field if not needed; the gateway provides no cache-key semantics today.
 
-**Captured-requests**: May 2026 batch — 159 captures from `kimi-cli` (e.g. `cache_key: "kimi-cli_f1c55293"`).
-
 <details>
 <summary>Sample request body fragment</summary>
 
@@ -58,8 +62,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field if not needed; no cache routing is performed on the gateway path.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-service_tier
@@ -72,8 +74,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field; it has no effect on this path.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-store
@@ -86,8 +86,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field; no retention guarantee is provided by the gateway.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-provider
@@ -100,8 +98,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field; backend selection is fixed by the `model` field.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-plugins
@@ -114,8 +110,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field; implement any equivalent tool behaviour in the client or as a separate sidecar.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-extra_headers
@@ -128,8 +122,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: pass `extra_headers` to the SDK's request options (where it writes HTTP headers), not into the body dict; if constructing raw HTTP, set headers directly on the request.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-thinking_config
@@ -142,8 +134,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the field; use `thinking: {"type": "enabled"}` (Kimi) or `enable_thinking: true` (Qwen) instead.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-think
@@ -156,8 +146,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: use `enable_thinking: true` (Qwen) or `thinking: {"type": "enabled"}` (Kimi) instead of the Ollama-specific flag.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #strip-display-thinking-sibling
@@ -170,8 +158,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: the SDK should resolve `display` client-side before sending the HTTP request; if you observe it on the wire, your client is leaking UI state into the body.
 
-**Captured-requests**: May 2026 batch — observed in 5 captures with `{"thinking": {"display": "summarized", "type": "adaptive"}}`.
-
 <details>
 <summary>Sample request body fragment</summary>
 
@@ -196,7 +182,41 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: send `user` instead if you need OpenAI-compatible attribution; the gateway uniformly validates that field with a 512 B cap.
 
-**Captured-requests**: n/a — no captures observed.
+---
+
+### #strip-thinking-minimax
+
+**What**: top-level `thinking: {...}` (Anthropic-style wrapper) silent-stripped on the MiniMax-M2.7 route before `ThinkingValidator` runs.
+
+**Why**: MiniMax-M2.7 has no `chat_template_kwargs` switch for thinking — interleaved reasoning is structural to the chat template and always-on. The model emits `<think>...</think>` blocks inline in `content` by design ([[MiniMax-2]](references.md#minimax)). Mirroring `thinking` into template kwargs (as on Kimi-K2.6) or normalizing it (as on Qwen-style routes) is a no-op on this route. Silent-strip is the closest behavior to the model's actual contract.
+
+**When to restore**: when MiniMax adds a documented per-request thinking toggle.
+
+**Fix (client-side)**: stop sending `thinking`; for clients that need to suppress the visible thinking display, parse + filter `<think>...</think>` blocks client-side from the response content.
+
+---
+
+### #strip-enable_thinking-minimax
+
+**What**: top-level `enable_thinking: bool` silent-stripped on the MiniMax-M2.7 route before `EnableThinkingValidator` runs (which would otherwise translate it into `chat_template_kwargs.enable_thinking`).
+
+**Why**: vLLM Issue [vLLM-25](references.md#vllm) ([#36778](https://github.com/vllm-project/vllm/issues/36778)) confirms `chat_template_kwargs.enable_thinking=false` does NOT disable thinking on M2.5+. Forwarding the translated kwarg would silently mislead clients into believing they'd disabled reasoning when in fact the model still emits `<think>` blocks. Strip avoids the misleading appearance of effect.
+
+**When to restore**: when the upstream Issue is fixed and the kwarg is honored on the M2 line.
+
+**Fix (client-side)**: stop sending `enable_thinking` on this route — see [strip-thinking-minimax](#strip-thinking-minimax) for the broader story.
+
+---
+
+### #strip-tool_call_id-minimax
+
+**What**: `tool_call_id` on `role:"tool"` messages silent-stripped on the MiniMax-M2.7 route during message normalization.
+
+**Why**: MiniMax-M2.7 tool messages correlate by `name` + positional order within a tool-result block, not by `tool_call_id` ([[MiniMax-4]](references.md#minimax)). Clients porting OpenAI code may dual-emit the field. Forwarding it is harmless (vLLM ignores) but rejecting it would force every OpenAI-compat client to fork their tool-message serializer per route. Silent-strip preserves compat without implying semantics we don't honor.
+
+**When to restore**: never — the field has no consumer on this route.
+
+**Fix (client-side)**: omit `tool_call_id` for cleanest payloads. If you must dual-emit (e.g. shared serializer across routes), it's a free pass-through to silent-strip.
 
 ---
 
@@ -212,8 +232,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: if you're sending `reasoning_effort` and need the behavior, you're on a route that doesn't support it. Either drop the field or wait for a reasoning-capable route to be added.
 
-**Captured-requests**: n/a — no captures observed.
-
 ## Translations / coercions
 
 ### #translate-enable_thinking
@@ -226,8 +244,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: send `chat_template_kwargs.enable_thinking` directly to skip the translation step.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #translate-reasoning
@@ -240,8 +256,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: send `reasoning_effort` directly; this skips both this translation and the subsequent `#strip-reasoning_effort` enum validation path.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #coerce-tool-choice-required
@@ -254,8 +268,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: if you need true `"required"` semantics, file a network request. The gateway currently provides best-effort `"auto"` instead.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #coerce-n-when-temperature-zero
@@ -268,8 +280,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: either set `temperature > 0` (typical) or accept `n: 1` — deterministic sampling produces one output anyway.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #unwrap-extra_body
@@ -282,8 +292,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: pre-flatten in your client (correct OpenAI SDK usage); or trust the unwrap.
 
-**Captured-requests**: n/a — no captures observed.
-
 ## Hard rejects (HTTP 400)
 
 ### #reject-unknown-param
@@ -296,22 +304,18 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop the unknown field from your request body; if you need it, file an issue at https://github.com/gonka-ai/gonka/issues.
 
-**Captured-requests**: n/a (this is the catch-all gate; specific captures are listed per individual rejected field below).
-
 ---
 
 ### #reject-duplicate-tool-call-id
 
 **What**: HTTP 400, `messages[N].tool_calls[M].id is duplicated`.
 
-**Why**: The OpenAI Chat Completions spec requires each `tool_calls[].id` within an assistant message to be unique [[OpenAI-1]](references.md#openai). The same constraint is enforced by the Anthropic Messages API — Bedrock-served Claude returns `ValidationException: messages.N.content contain duplicate Ids: tooluse_...` (see [LiteLLM issue #15178](https://github.com/BerriAI/litellm/issues/15178)). The confirmed upstream source is a bug in vLLM's Kimi-K2.6 tool-call parser: `history_tool_call_cnt` is recomputed inside the per-choice loop with `n>1`, producing colliding `functions.<name>:<idx>` ids [[vLLM-14]](references.md#vllm). Captured-requests evidence (e.g. req-1779369319274519506-325651) shows agents returning multiple distinct tool results for the same duplicated id — silent gateway-side dedup or rename would therefore risk information loss by discarding one of the real outputs.
+**Why**: The OpenAI Chat Completions spec requires each `tool_calls[].id` within an assistant message to be unique [[OpenAI-1]](references.md#openai). The same constraint is enforced by the Anthropic Messages API — Bedrock-served Claude returns `ValidationException: messages.N.content contain duplicate Ids: tooluse_...` (see [LiteLLM issue #15178](https://github.com/BerriAI/litellm/issues/15178)). The confirmed upstream source is a bug in vLLM's Kimi-K2.6 tool-call parser: `history_tool_call_cnt` is recomputed inside the per-choice loop with `n>1`, producing colliding `functions.<name>:<idx>` ids [[vLLM-14]](references.md#vllm). Captured-request evidence shows agents returning multiple distinct tool results for the same duplicated id — silent gateway-side dedup or rename would therefore risk information loss by discarding one of the real outputs.
 
 **When to restore**: when the upstream vLLM Kimi-K2 parser fixes the counter-collision bug AND the OpenAI spec relaxes its uniqueness requirement — neither is likely in the near term.
 
 **Fix (client-side)**: rewrite `tool_call.id` values to the canonical `functions.<name>:<global_idx>` form per Moonshot's official guidance [[Moonshot-3]](references.md#moonshot), OR rewrite to fresh UUIDs per the [OpenAI community workaround](https://community.openai.com/t/chatgpt-occasionally-reuses-tool-ids-in-the-same-session/577207). Do NOT deduplicate by ID lookup — both calls may have produced real distinct results.
 
-**Captured-requests**: May 2026 batch — 14 captures (e.g. req-1779369319274519506-325651).
-
 <details>
 <summary>Sample request body fragment (duplicate ids)</summary>
 
@@ -339,8 +343,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: use `metadata` for OpenAI-style tagging, or the `user` field for end-user tracking — both are accepted by the gateway.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #reject-guided-decoding
@@ -353,8 +355,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: use `response_format` with `type: "json_schema"` for the same structured-output intent — see the OpenAI Chat Completions reference [[OpenAI-1]](references.md#openai) for the schema.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #reject-enforced_tokens
@@ -367,8 +367,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: use `response_format`, `structured_outputs`, or system-prompt instructions for output control instead.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #reject-vllm-internals
@@ -381,8 +379,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: drop these fields; the gateway will not honor them.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #reject-structured_outputs-with-response_format
@@ -395,8 +391,6 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: send only one of the two. `response_format` is the OpenAI-standard route for JSON / json_schema outputs; `structured_outputs` is the vLLM-extension route for regex / grammar / choice / structural_tag. If you need both styles, pick the one the rest of your client toolchain understands.
 
-**Captured-requests**: n/a — no captures observed.
-
 ---
 
 ### #reject-structured_outputs-kimi
@@ -409,7 +403,99 @@ Every parameter that is stripped / rejected / normalized at the gateway is docum
 
 **Fix (client-side)**: use `response_format` with `type: "json_schema"` for Kimi-K2.6 (xgrammar-based, supported on this route); use `structured_outputs` only for non-Kimi routes.
 
-**Captured-requests**: n/a — no captures observed.
+### #accept-structured_outputs-minimax
+
+**What**: `structured_outputs` is accepted on the `MiniMaxAI/MiniMax-M2.7` route (not rejected). Only Kimi-K2.6 rejects the field.
+
+**Why**: The vLLM structured-output manager actively enforces the constraint on this route — verified end-to-end with paired discriminating/control requests: the `json`, `regex`, `choice`, `grammar`, and `json_object` kinds each steered output away from the natural answer the control produced. The engine holds the constraint, so there is no need to gate the field at the gateway.
+
+**Caveat — `structural_tag` must be the OBJECT form**: a JSON-encoded *string* `structural_tag` crashes vLLM with an HTTP 500 on the request handler, so the gateway rejects the string form with a 400 on every route. Send the object shape (`{"type":"structural_tag","structures":[...],"triggers":[...]}`).
+
+**Caveat — `response_format` conflict**: `structured_outputs` still cannot be combined with `response_format` (see [#reject-structured_outputs-with-response_format](#reject-structured_outputs-with-response_format)).
+
+---
+
+### #reject-whitespace-names
+
+**What**: HTTP 400 on a name field that is present but contains only whitespace — e.g. `tools[].function.name`, `tool_choice.function.name`, `response_format.json_schema.name`, or a MiniMax tool-result entry `name`. The error reads `...name must be a non-empty string`.
+
+**Why**: Every name validator trims with `strings.TrimSpace` *before* its non-empty check. Without the trim a whitespace-only name passes the gateway, reaches the engine as an effectively empty / nonexistent tool or schema name, and the request produces no usable output — it hangs until the deadline (0 bytes) and ties up a request slot/escrow. This is the same hang class as `max_tokens: 0` and `n: 0`. The engine is not crashed; the request just never completes.
+
+**Maintainer note**: when adding any new name/identifier field to a validator, check it with `strings.TrimSpace(value) == ""` (or `messagevalidators.RequiredNonEmptyString`), never a bare `== ""` — a bare empty-string check is a whitespace-bypass that re-opens this hang.
+
+**Fix (client-side)**: send a real (non-blank) name.
+
+---
+
+### #accept-tool-message-minimax-shape
+
+**What**: On the MiniMaxAI/MiniMax-M2.7 route, `role:"tool"` messages MUST carry `content` as an array of `{name, type:"text", text}` objects (the MiniMax-native shape per [[MiniMax-4]](references.md#minimax)) — not the OpenAI string + `tool_call_id` shape. Bare-string content is rejected with HTTP 400.
+
+**Why**: MiniMax's tool-calling contract correlates tool results by per-entry `name` + positional order inside a tool-result block; there is no `tool_call_id`. The MinimaxToolMessage content validator (registered in the per-model role policy override) enforces the entry shape and caps (≤16 entries, name ≤64 B, text ≤64 KiB, closed allow-list of keys to defend against [[SGLang-2]](references.md#sglang) union-with-null crash class). `tool_call_id`, if dual-emitted by a client porting from OpenAI, is silently stripped — see [strip-tool_call_id-minimax](#strip-tool_call_id-minimax).
+
+**When to restore**: when MiniMax adds OpenAI-compat tool-message handling to their parser.
+
+**Fix (client-side)**: emit the M2.7 shape:
+```json
+{"role": "tool",
+ "content": [
+    {"name": "<function_name>", "type": "text", "text": "<json-stringified result>"}
+ ]}
+```
+Multiple parallel tool results in one block: one array entry per call.
+
+---
+
+### #reject-out-of-range-sampling
+
+**What**: HTTP 400 on `top_p ≤ 0`, `repetition_penalty ≤ 0`, or a `top_k` that is neither `-1` nor `≥ 1`.
+
+**Why**: These sampling knobs have ranges the backend enforces: `top_p` must be in `(0, 1]` and `repetition_penalty` must be `> 0` per the OpenAI/vLLM wire schema [[OpenAI-1]](references.md#openai), [[vLLM-1]](references.md#vllm); `top_k` accepts `-1` (disabled) or any integer `≥ 1`. The low end is an *exclusive* bound, so clamping to it would itself be invalid (e.g. `top_p = 0` is not a legal value) — the gateway returns a clear, field-named 400 at the boundary instead of forwarding a value the engine rejects with an opaque error. Values above the *upper* bound are clamped instead (`top_p > 1 → 1`, `repetition_penalty > 2 → 2`), and `temperature` / `min_p` are clamped into `[0, 2]` / `[0, 1]`.
+
+**Fix (client-side)**: send `top_p` in `(0, 1]`, `repetition_penalty > 0`, and `top_k` as `-1` or a positive integer.
+
+---
+
+### #reject-nonpositive-max-tokens
+
+**What**: HTTP 400 on `max_tokens: 0` (or `max_completion_tokens: 0`) for non-Kimi routes.
+
+**Why**: A zero output budget is not a meaningful request — vLLM emits no content, and the gateway's redundancy layer then waits for a winner that can never arrive, so the request hangs to the deadline instead of failing fast. The gateway requires `max_tokens ≥ 1` [[OpenAI-1]](references.md#openai). Kimi-K2.6 instead floors small budgets to 16 as part of its think-burn mitigation (see [#kimi-empty-content-think-burn](#kimi-empty-content-think-burn)), so `0` becomes `16` on that route rather than a 400.
+
+**Fix (client-side)**: send `max_tokens ≥ 1`, or omit it to take the route default.
+
+---
+
+### #reject-malformed-param-types
+
+**What**: HTTP 400 when a parameter carries the wrong JSON type: non-boolean `stream` / `skip_special_tokens` / `detokenize` / `parallel_tool_calls`; non-integer `seed` / `min_tokens`; non-string elements in `stop` / `bad_words`; non-integer elements in `stop_token_ids`.
+
+**Why**: vLLM rejects these with type errors at the engine boundary, producing opaque upstream 400s. The gateway type-checks them up front against the OpenAI/vLLM wire schema [[OpenAI-1]](references.md#openai), [[vLLM-1]](references.md#vllm) so the client gets an immediate, field-named error instead of a backend round-trip.
+
+**Fix (client-side)**: send each field with its declared type — booleans for the flags, non-negative integers for `seed` / `min_tokens` and `stop_token_ids` elements, strings for `stop` / `bad_words` elements.
+
+## Per-model behavior
+
+### #kimi-empty-content-think-burn
+
+**What**: on Kimi-K2.6, small `max_tokens` requests can return `finish_reason=length` with `content=null`. The gateway also reshapes inbound requests:
+- `max_tokens` and `max_completion_tokens` are floored to **16** ([PR #1227](https://github.com/gonka-ai/gonka/pull/1227)).
+- `thinking_token_budget` is resolved by a single validator with this precedence:
+  1. `max_tokens < 256` → force `thinking_token_budget = 0` (bypass thinking entirely), overriding the client value.
+  2. Otherwise, if `thinking_token_budget` is absent, default to `max_tokens / 2`.
+  3. Cap at `96_000` (Moonshot HLE/AIME budget).
+  4. Clamp to `max_tokens − 64` so visible content always has headroom after `</think>`.
+
+**Why**: Kimi-K2.6 emits its reasoning inside `<think>...</think>`. vLLM's `kimi_k2` reasoning parser strips `</think>` as a special token; when the entire `max_tokens` budget is consumed by reasoning, no visible content reaches `delta.content` and the client sees an empty stream. This is the same documented outcome as OpenAI's reasoning models: *"the incomplete status might occur before any visible output tokens are produced, meaning you could incur costs for input and reasoning tokens without receiving a visible response"* — [[OpenAI-4]](references.md#openai). Anthropic documents the equivalent behavior for extended thinking with `stop_reason=max_tokens` ([[Anthropic-2]](references.md#anthropic)).
+
+**Response-side**: when the empty stream arrives with `usage.completion_tokens > 0`, the gateway classifies the attempt as **model burn** rather than host fault — telemetry-only, no `failureStrikes` increment, no quarantine. Scoped to the Kimi-K2.6 route: `completion_tokens` is host-reported, so it is honored only where reasoning-burn is expected. This mirrors OpenAI/OpenRouter behavior where empty `finish_reason=length` is a valid passthrough response, not a provider failure.
+
+**Fix (client-side)**:
+- For chat / agent traffic: set `max_tokens ≥ 256` so the gateway leaves a default thinking budget. For long reasoning, set `max_tokens ≥ 4096` and consider `thinking_token_budget` explicitly.
+- For probe / validation traffic: keep `max_tokens` small but expect `thinking_token_budget = 0` to be enforced.
+- To opt out of thinking on a non-small `max_tokens`: send `thinking_token_budget: 0` **explicitly**. The validator preserves client-set zero. Note that `thinking:{type:"disabled"}` does NOT zero ttb — Kimi empirically ignores the disable hint on hard prompts ([PR #1202](https://github.com/gonka-ai/gonka/pull/1202)), so the validator keeps the `max_tokens / 2` safety net to prevent burn-through when the model thinks anyway.
+
+---
 
 ## Per-model gotchas
 
@@ -417,3 +503,4 @@ Brief pointers to deeper notes in per-model docs:
 
 - **Kimi-K2.6**: [Known model-side bugs we work around](kimi-k2.6.md#known-model-side-bugs-we-work-around)
 - **Qwen3-235B-A22B-Instruct-2507**: [Known model-side bugs we work around](qwen3-235b-a22b-instruct-2507.md#known-model-side-bugs-we-work-around)
+- **MiniMaxAI/MiniMax-M2.7**: [Known model-side bugs we work around](minimax-m2.7.md#known-model-side-bugs-we-work-around)
diff --git a/docs/consumer_setup.md b/docs/consumer_setup.md
index fe9339b55f..d7af78b040 100644
--- a/docs/consumer_setup.md
+++ b/docs/consumer_setup.md
@@ -1,60 +1,135 @@
 # Consumer Setup Guide
 
-Step-by-step guide for creating a developer account and sending inference requests to the Gonka network.
+Step-by-step guide for sending inference requests to the Gonka network.
+
+> **The most up-to-date version of this guide lives at**
+> **<https://gonka.ai/docs/developer/quickstart/>.** If anything here differs from
+> the website, the website is authoritative.
+
+## How inference access works today
+
+Gonka inference is organized around **devshards** — short-lived sessions that hold a
+small on-chain deposit (an escrow) and settle per-request billing off-chain. The role
+of opening a devshard, signing requests, rotating the session, and submitting
+settlement to the chain is performed by a piece of software called a **gateway**.
+
+There are two ways to reach the network:
+
+| Path | Who it is for | What you need |
+|---|---|---|
+| **1. Use a community broker** (recommended) | Most developers | An API key from a broker |
+| **2. Run your own gateway** (advanced) | High-throughput / self-custody users | A Gonka account whose address is on the on-chain allow-list |
+
+> **Important — the broker-less CLI path is not self-serve today.** A funded,
+> on-chain-registered account that signs its own requests still receives
+> `401 {"error":{"message":"model \"...\" requires an API key"}}` for every model,
+> because access is gated node-side per model. Sending inference directly with only
+> the `inferenced` CLI and your own private key does **not** work end-to-end. To send
+> inference you must either use a community broker (option 1) or run your own
+> allow-listed gateway (option 2).
 
 ---
 
-## 1. Define Variables
+## 1. Use a community broker (recommended)
 
-Before starting, set the required environment variables:
+A broker is an independent operator who runs a Gonka gateway and resells inference to
+developers. From your application's point of view, a broker endpoint behaves like any
+OpenAI-compatible API: you set a `base_url`, pass an `Authorization: Bearer <API_KEY>`
+header, and call `/v1/chat/completions` as usual.
 
-```bash
-export ACCOUNT_NAME="myaccount"
-export NODE_URL="http://node2.gonka.ai:8000"
-```
+> Brokers are independent third parties. Pricing, payment methods, rate limits,
+> supported models, SLAs, and data handling are determined by each broker. Read the
+> broker's own documentation and terms before going live.
+
+### 1.1 Pick a broker and get an API key
+
+Pick a broker from the directory at
+[gonka.ai/docs/developer/quickstart](https://gonka.ai/docs/developer/quickstart/#11-pick-a-broker),
+then follow the onboarding on the broker's site. Typically you will:
 
-| Variable | Description |
-|---|---|
-| `ACCOUNT_NAME` | Local keyring name for your account. Exists only on your machine — not recorded on-chain. |
-| `NODE_URL` | URL of any Gonka node. Used for account queries, inference requests, and on-chain operations. |
+1. Sign up on the broker's site (email, account, billing setup).
+2. Generate an API key in the broker's dashboard.
+3. Note the broker's `base_url` (for example `https://api.<broker-domain>/v1`) and the
+   list of supported models.
 
-Replace `myaccount` with any name you like and pick a node URL from the list below.
+### 1.2 Send an inference request
 
-<details>
-<summary><b>Genesis nodes</b></summary>
+Set the environment variables you got from your broker:
 
+```bash
+export GONKA_BROKER_URL=<broker-base-url>     # e.g. https://api.example-broker.com/v1
+export GONKA_BROKER_API_KEY=<your-api-key>
+export GONKA_MODEL=MiniMaxAI/MiniMax-M2.7   # or any model your broker supports
 ```
-http://node1.gonka.ai:8000
-http://node2.gonka.ai:8000
-http://node3.gonka.ai:8000
-http://185.216.21.98:8000
-http://36.189.234.197:18026
-http://36.189.234.237:17241
-http://47.236.26.199:8000
-http://47.236.19.22:18000
-http://gonka.spv.re:8000
+
+The broker endpoint is OpenAI-compatible, so you can use the official OpenAI SDK
+directly — **no Gonka-specific client is required**.
+
+```bash
+pip install openai
 ```
 
-</details>
+```python
+import os
+from openai import OpenAI
 
-<details>
-<summary><b>How to pick a random active node instead</b></summary>
+client = OpenAI(
+    base_url=os.environ["GONKA_BROKER_URL"],
+    api_key=os.environ["GONKA_BROKER_API_KEY"],
+)
 
-Fetch the current list of active participants and pick any `inference_url`:
+response = client.chat.completions.create(
+    model=os.environ["GONKA_MODEL"],
+    messages=[{"role": "user", "content": "Hello!"}],
+)
 
-```bash
-curl "$NODE_URL/v1/epochs/current/participants"
+print(response.choices[0].message.content)
 ```
 
-Using a random node improves network decentralization and load distribution.
+Model IDs are case-sensitive — copy them exactly, e.g.
+`MiniMaxAI/MiniMax-M2.7`.
 
-</details>
+For the full set of language examples (TypeScript, Go), tool calling, and no-code app
+integrations (Open WebUI, Cursor, n8n, etc.), see the
+[Developer Quickstart](https://gonka.ai/docs/developer/quickstart/).
 
 ---
 
-## 2. Install the `inferenced` CLI
+## 2. Run your own gateway (advanced)
 
-Download the latest `inferenced` binary for your system from the [official repository](https://github.com/gonka-ai/gonka).
+If your application has high throughput, or you want to pay GNK directly on-chain
+instead of going through a broker, you can run a Gonka gateway yourself. The gateway is
+a small program (shipped as a Docker container) that you run on your own machine or
+server — never on a Gonka host. It exposes the same OpenAI-compatible API as a broker,
+but you own the keys and you pay GNK directly on-chain for the devshards it creates.
+
+> **Self-hosted gateways require an allow-listed address.** Today, only Gonka accounts
+> on the on-chain `devshard_escrow_params.allowed_creator_addresses` list can open
+> devshards. If your address is not on that list, your gateway cannot create sessions
+> and you cannot send inference. The allow-list is changed only by on-chain governance
+> vote.
+
+Full deployment instructions are in
+[Run your own gateway](https://gonka.ai/docs/developer/gateway-developer-quickstart/).
+
+To request consideration for on-chain allow-listing, open a GitHub issue including your
+operator name and contact, the `gonka1...` address you intend to use, and the models
+you plan to serve. Inclusion is an on-chain governance decision and expressing interest
+does not guarantee inclusion or a timeline.
+
+---
+
+## Managing a Gonka account
+
+If you use a community broker (option 1), you do **not** need your own Gonka account —
+the broker handles GNK and on-chain settlement for you. You only need an account if you
+plan to run your own gateway, pay GNK directly on-chain, or otherwise participate in the
+network. The `inferenced` CLI manages keys and on-chain operations.
+
+### Install the `inferenced` CLI
+
+Download the latest `inferenced` binary for your system from the
+[official repository](https://github.com/gonka-ai/gonka).
 
 ```bash
 chmod +x inferenced
@@ -62,48 +137,39 @@ sudo mv inferenced /usr/local/bin/
 inferenced version
 ```
 
-**macOS:** if you see a security warning, go to **System Settings → Privacy & Security** and click "Allow Anyway".
-
----
-
-## 3. Create an Account
+**macOS:** if you see a security warning, go to **System Settings → Privacy & Security**
+and click "Allow Anyway".
 
-Create a local keypair that will be used to sign inference requests.
+### Create an account
 
 ```bash
+export ACCOUNT_NAME="myaccount"
+export NODE_URL="http://node2.gonka.ai:8000"
+
 inferenced keys add "$ACCOUNT_NAME"
 ```
 
 The output contains your **address**, **public key**, and **mnemonic phrase**.
 
-> **Important:** Back up the mnemonic phrase and private key securely — they are the only way to recover the account and sign requests.
-
-Save the address for later steps:
+> **Important:** Back up the mnemonic phrase and private key securely — they are the
+> only way to recover the account.
 
 ```bash
 export GONKA_ADDRESS="<address from the output>"
 ```
 
-You will also need your private key in Step 5 to configure the client connector. How you store and supply it (environment variable, secrets manager, `.env` file, etc.) is up to you.
-
----
-
-## 4. Fund the Account and Publish Your Public Key
-
-To send inference requests, your account must have a positive balance and its public key must be published on-chain.
-You do **not** need to register as a Participant — that is only required for inference hosting.
-
-### 4.1 Fund the account
+### Fund the account and publish your public key
 
-Your account needs a positive balance to pay for inference. For a full guide on wallets, balances, and transfers see the [Wallet & Transfer Guide](https://gonka.ai/wallet/wallet-and-transfer-guide/).
+For a full guide on wallets, balances, and transfers see the
+[Wallet & Transfer Guide](https://gonka.ai/docs/wallet/wallet-and-transfer-guide/).
 
-You can check your current balance at any time:
+Check your balance:
 
 ```bash
 inferenced query bank balances "$GONKA_ADDRESS" --node "$NODE_URL/chain-rpc"
 ```
 
-To fund the account, send any amount of `ngonka` from another wallet:
+Fund the account by sending `ngonka` from another wallet:
 
 ```bash
 inferenced tx bank send <sender-key-name> "$GONKA_ADDRESS" 1000000ngonka \
@@ -111,11 +177,7 @@ inferenced tx bank send <sender-key-name> "$GONKA_ADDRESS" 1000000ngonka \
   --node "$NODE_URL/chain-rpc"
 ```
 
-You can also transfer funds using [Keplr](https://gonka.ai/wallet/wallet-and-transfer-guide/#send-coins) or [Leap](https://gonka.ai/wallet/wallet-and-transfer-guide/#send-coins) wallets.
-
-### 4.2 Publish the public key on-chain
-
-Once the account is funded, publish your public key:
+Once funded, publish your public key on-chain:
 
 ```bash
 inferenced publish-pubkey \
@@ -124,11 +186,10 @@ inferenced publish-pubkey \
   --yes
 ```
 
-This performs a minimal self-transfer (`1ngonka`) that registers your public key on the blockchain.
+> If you get `rpc error: code = NotFound ... account ... not found`, your account has
+> not received tokens yet — fund it first.
 
-> If you get `rpc error: code = NotFound ... account ... not found`, your account has not received tokens yet — complete step 4.1 first.
-
-### 4.3 Verify the account
+Verify the account:
 
 ```bash
 curl -s "$NODE_URL/v2/accounts/$GONKA_ADDRESS" | jq .
@@ -136,40 +197,7 @@ curl -s "$NODE_URL/v2/accounts/$GONKA_ADDRESS" | jq .
 
 The response should include `pubkey`, `balance`, and `denom`.
 
----
-
-## 5. Send an Inference Request
-
-Gonka uses a modified OpenAI SDK that automatically signs every request with your private key. Full documentation and examples for all supported languages are in the [gonka-openai repository](https://github.com/gonka-ai/gonka-openai/).
-
-### Minimal Python example
-
-```bash
-pip install gonka-openai
-```
-
-```python
-from gonka_openai import GonkaOpenAI
-
-client = GonkaOpenAI(
-    gonka_private_key="<your-private-key>",  # hex-encoded private key from Step 3
-    source_url="<NODE_URL>",                 # same node URL from Step 1
-)
-
-response = client.chat.completions.create(
-    model="Qwen/Qwen2.5-7B-Instruct",
-    messages=[{"role": "user", "content": "Hello!"}],
-    max_tokens=128,
-)
-
-print(response.choices[0].message.content)
-```
-
-> If you get `Insufficient balance`, fund the account with more tokens or lower `max_tokens`.
-
----
-
-## Key Management Reference
+### Key Management Reference
 
 ```bash
 # List all accounts
diff --git a/docs/devshard-0.2.13-optimizations.md b/docs/devshard-0.2.13-optimizations.md
index 4712fa48b7..4b6950d8f1 100644
--- a/docs/devshard-0.2.13-optimizations.md
+++ b/docs/devshard-0.2.13-optimizations.md
@@ -10,7 +10,7 @@ Devshard uses **two independent version concepts**. Do not mix them.
 |------|--------|---------|
 | **Runtime / binary version** | `DevshardEscrowParams.approved_versions` | Which devshard binary may run. versiond sets `DEVSHARD_LOG_PREFIX` and `DEVSHARD_BINARY_VERSION` to the oracle name; devshardd checks it against its build. |
 | **State root & protocol version** | `types.DevshardStateRootAndProtocolVersion` (`"v2"`) | Tag hashed into state roots and carried on `MsgSettleDevshardEscrow.state_root_and_protocol_version`. Bump only when root composition or settlement rules change. |
-| **Legacy route tag** | `types.LegacyRouteSessionVersion` (`"v1"`) | Storage bind tag for `/v1/devshard` and embedded dapi hosts only. |
+| **Session route tag** | `types.SessionVersionV1` (`"v1"`) | Historical storage bind tag for sessions created before versioned devshardd routing. |
 
 Details: [devshard/docs/protocol-version.md](../devshard/docs/protocol-version.md), [devshard/docs/upgrade.md](../devshard/docs/upgrade.md).
 
diff --git a/docs/gonka_poc_inference.md b/docs/gonka_poc_inference.md
new file mode 100644
index 0000000000..d744808bfe
--- /dev/null
+++ b/docs/gonka_poc_inference.md
@@ -0,0 +1,106 @@
+# Inference During the PoC Validation Phase
+
+This document describes how the Gonka network keeps serving inference during the PoC validation stage. It builds on the Proof of Compute design in [gonka_poc.md](gonka_poc.md), where a PoC sprint normally takes most nodes away from inference and only preserved nodes keep answering requests.
+
+## Background
+
+PoC version 2 runs the proof computation inside the vLLM process instead of a separate worker. During the validation stage a node re-runs a sampled set of nonces rather than generating new ones, so most of the GPU stays idle. A node in that state can still answer inference requests while it validates.
+
+The earlier behavior treated the whole sprint the same way: only preserved nodes served inference, through both generation and validation, and the gateway raised its per-weight concurrency limit for the entire sprint. Two facts let us do better during validation. The work is light, and each node knows whether its vLLM build allows inference while validation runs. Three changes use that:
+
+1. ML nodes report, per node, whether they can serve inference during validation.
+2. The gateway routes inference to those capable nodes during the validation phase, on top of the preserved set.
+3. The raised concurrency limit applies only during the generation phase, not validation.
+
+## Capability Reporting
+
+The capability travels from the ML node to the developer-facing gateway over the existing version endpoints.
+
+### ML Node Side
+
+**vLLM (`vllm/.../poc/routes.py`)**:
+- The `/api/v1/pow/versions` route returns the build version and a `poc_validation_inference` flag.
+- The flag is `true` when the build can answer inference requests while PoC validation runs in the same process.
+
+**MLNode API (`mlnode/packages/api/src/api/routes.py`)**:
+- The `/api/v1/state` route includes `poc_validation_inference` alongside the existing node heartbeat fields, so the broker learns capability without an extra per-node polling request.
+- The `/api/v1/versions` route is also available on `poc_port` for direct capability inspection.
+- Both routes use vLLM's `/api/v1/pow/versions` response from a healthy backend. The first successful response is cached because it is a build capability. Unknown capability, no healthy backend, and vLLM errors fail closed to `poc_validation_inference: false`.
+
+### Decentralized API Side
+
+**Per-node tracking (`decentralized-api/broker/broker.go`)**:
+- `queryNodeStatus` reads `poc_validation_inference` from the regular `mlnodeclient.NodeState` response. Older MLNodes omit the field, which decodes to `false`.
+- The result is stored on `NodeState.PoCValidationInference`. A failed state request also leaves the flag false.
+- The flag flows through the same path as the node version: `statusQueryResult` to `StatusUpdate` to `NodeState`. The reconcile step emits an update when only this flag changes, so a flip is not held back until an unrelated status change.
+
+**Public reporting (`decentralized-api/internal/server/public/app_info_handlers.go`)**:
+- `GET /v1/versions` returns a per-node `mlnodes` list. Each entry carries `node_id`, `version`, and `poc_validation_inference`, built from `Broker.GetNodes()`.
+- A nil broker yields an empty list. A `GetNodes` error is logged and also yields an empty list; the endpoint still returns the API and node versions.
+
+The flag is self-reported and used only for routing. It never gates authorization or consensus.
+
+## Gateway Routing During Validation
+
+The devshard gateway decides, per phase, which miners can take inference traffic. The phase constants live in `devshard/cmd/devshardctl/phase_gate.go`.
+
+**Generation phases** (`PoCGenerate`, `PoCGenerateWindDown`, and the confirmation-PoC grace and generation phases): only preserved miners serve inference, as before.
+
+**Validation phases** (`PoCValidate`, `PoCValidateWindDown`, `CONFIRMATION_POC_VALIDATION`): preserved miners plus any non-preserved miner that has at least one validation-capable node.
+
+### Tracking Capability (`versions_cache.go`)
+
+- `VersionsCache` runs as a background poller on the gate's lifecycle. It reads each candidate miner's `/v1/versions` and records, per `(miner, node_id)`, whether that node reports `poc_validation_inference`.
+- `IsNodeValidationCapable(miner, nodeID)` answers the per-node question. It returns `false` for an unknown miner or node, a failed fetch, or an entry older than the cache TTL.
+- The poller holds its lock only to copy the candidate set and to store results. It does not hold the lock across the HTTP call, so a slow miner does not block reads from the refresh path.
+- `refresh` feeds the candidate set from the participants response on every poll, so the cache stays warm and is ready when the phase turns to validation.
+
+### Merging the Sets (`phase_gate.go`)
+
+During a validation phase, `mergePreservedWithValidationCapable` produces the availability and weight views the limiter uses:
+
+- Preserved miners keep their PoC-filtered weight.
+- For each non-preserved miner, the gateway sums the chain weight of only its validation-capable nodes, per model, and adds the miner with that weight.
+- A miner with no capable node is left out.
+
+The per-node weight comes from the chain participants response (`chainMLNodeInfo`, fields `node_id` and `poc_weight`). The `node_id` in the `/v1/versions` list is the miner's broker `Node.Id`, which is the same identifier the chain stores as `MLNodeInfo.NodeId` (set in `decentralized-api/broker/broker.go` when the node is registered). The gateway matches the two by `node_id` and sums.
+
+Giving a capable miner real capacity needs both halves. `CapacityState.TotalWeightForModel` sums current weight only over available hosts, so the merge adds the miner to the preserved set and writes its capable-node weight into the current view. The full view stays at the steady-state weight.
+
+## Concurrency Limit
+
+The gateway scales its concurrency cap by `PoCMaxConcurrentPer10000Weight` when fewer nodes serve inference. That happens during generation, when only preserved nodes are available. Validation reopens the non-preserved capable nodes, so the higher cap is no longer needed there.
+
+**Phase-scoped cap (`devshard/cmd/devshardctl/gateway.go`)**:
+- `currentMaxConcurrentPer10000Weight` returns `PoCMaxConcurrentPer10000Weight` only when `pocGenerationActive` is true.
+- `pocGenerationActive` reads the phase snapshot and calls `rawPoCGenerationState`, which is true for the four generation phases and false for validation.
+- Validation and steady-state both fall back to the base `MaxConcurrentPer10000Weight`.
+
+## Fail-Closed Behavior
+
+Every unknown resolves to "not capable", so a miner or node is never offered traffic it cannot serve:
+
+- A node whose `/api/v1/state` response does not include `poc_validation_inference` reports `false`.
+- A miner whose `/v1/versions` cannot be reached or parsed contributes no capable nodes.
+- A cache entry past its TTL is treated as unknown until the next poll refreshes it.
+- A nil broker or a missing node returns `false`.
+
+## Key Implementation Files
+
+### ML Node
+- `vllm/.../poc/routes.py` - the vLLM `/api/v1/pow/versions` route and the `poc_validation_inference` flag
+- `mlnode/packages/api/src/api/routes.py` - the MLNode `/api/v1/state` and `/api/v1/versions` endpoints that proxy vLLM capability
+
+### Decentralized API
+- `decentralized-api/mlnodeclient/client.go` - `StateResponse` with `poc_validation_inference`
+- `decentralized-api/broker/broker.go` - per-node capability in `queryNodeStatus` and `NodeState`
+- `decentralized-api/internal/server/public/app_info_handlers.go` - the per-node `mlnodes` list on `/v1/versions`
+
+### Devshard Gateway
+- `devshard/cmd/devshardctl/versions_cache.go` - the background capability poller
+- `devshard/cmd/devshardctl/phase_gate.go` - `mergePreservedWithValidationCapable`, `rawPoCValidationState`, `rawPoCGenerationState`
+- `devshard/cmd/devshardctl/gateway.go` - the phase-scoped concurrency cap
+
+## Summary
+
+During PoC validation a node does light work, so it can answer inference alongside it. Each node reports whether its build allows that, the gateway learns it through `/v1/versions`, and during the validation phase the gateway routes inference to preserved miners plus the non-preserved miners whose nodes are capable, weighted by those nodes. The raised concurrency cap stays scoped to generation, where the serving set is smallest. Unknown capability always reads as not capable, so the change only ever adds traffic to nodes that have said they can take it.
diff --git a/docs/testermint-upgrade-rehearsal.md b/docs/testermint-upgrade-rehearsal.md
new file mode 100644
index 0000000000..a2f2be365c
--- /dev/null
+++ b/docs/testermint-upgrade-rehearsal.md
@@ -0,0 +1,151 @@
+# Testermint Upgrade Rehearsal
+
+This workflow tests an actual local software upgrade before we spend Testnet time on it. It starts a Testermint cluster from the previous production release, creates meaningful pre-upgrade state, then upgrades the still-running cluster with binaries built from the candidate branch.
+
+The rehearsal is intentionally separate from the normal integration matrix. It needs two repository checkouts, two versions of the Testermint harness, and live Docker state that must survive between phases.
+
+## What It Proves
+
+- The previous release can still boot in the current CI environment using the production images declared by that release.
+- The previous release's own Testermint harness can create realistic pre-upgrade state.
+- The candidate branch can submit a real Cosmos SDK software-upgrade proposal against that existing cluster.
+- Cosmovisor downloads and installs the candidate `inferenced` and `decentralized-api` upgrade archives.
+- The chain resumes block production after the upgrade and records the expected `last-upgrade-height`.
+- The upgraded chain completes a new epoch/PoC cycle with the prepared miners still active and with no dramatic miner-power shift.
+- Normal inference and devshard settlement still work after the upgrade.
+
+## Version And Image Discovery
+
+The workflow treats deploy scripts as the canonical source for production image references.
+
+1. The target upgrade defaults to the newest semantic `UpgradeName` found under `inference-chain/app/upgrades/*/constants.go` in the candidate checkout.
+2. The previous release defaults to the highest canonical release tag below that target, where canonical means `release/vX.Y.Z`.
+3. Suffix tags such as `release/v0.2.13-testnet-3`, `release/v0.2.13-testnet-rehearsal-1`, or ad hoc tags are ignored.
+4. The old checkout is made at that previous release tag.
+5. Previous production image refs are read from the old checkout's `deploy/join/docker-compose.yml`.
+6. Those production images are pulled and retagged to the local Testermint image names, such as `ghcr.io/product-science/inferenced`, `ghcr.io/product-science/api`, and `ghcr.io/product-science/proxy:latest`.
+
+Manual workflow inputs can override the target upgrade or previous release when debugging a non-standard branch.
+
+## Phase 1: Prepare Old State
+
+The old release checkout runs the old release's Testermint harness against the previous production images.
+
+Because old release tags are immutable, the candidate branch stores a small patch at:
+
+`testermint/upgrade-rehearsal/previous-release-prep.patch`
+
+The workflow applies that patch to the old checkout before running the prep test. The patched test:
+
+- boots the old cluster from scratch;
+- waits through an epoch;
+- runs a normal inference;
+- creates and settles a devshard escrow;
+- waits into another epoch;
+- writes an upgrade rehearsal manifest with heights, epoch indexes, participant ids, baseline participant weights, inference id, and devshard escrow id.
+
+The workflow must not tear the cluster down after this phase. The live Docker containers and volumes are the upgrade subject.
+
+### Maintaining The Prep Patch
+
+`previous-release-prep.patch` is intentionally version-coupled to the previous release's Testermint harness. When the previous canonical release changes, refresh the patch against that release instead of assuming the old patch still applies.
+
+Recommended refresh loop:
+
+1. Check out the new previous release tag in a scratch worktree, for example `git worktree add /tmp/gonka-prev release/v0.2.14`.
+2. Add or update `testermint/src/test/kotlin/UpgradeRehearsalPrepTests.kt` in that scratch checkout.
+3. Run the prep test locally or in a temporary workflow run until it creates the expected manifest and leaves the cluster running.
+4. From the scratch checkout, regenerate the patch with `git diff -- testermint/src/test/kotlin/UpgradeRehearsalPrepTests.kt > /path/to/current/testermint/upgrade-rehearsal/previous-release-prep.patch`.
+5. Re-run `testermint-upgrade-rehearsal.yml` with explicit `target_upgrade` and `previous_release` overrides before relying on the default discovery path.
+
+Keep the patch narrow. It should add only the old-checkout prep test and should not alter cluster teardown, Docker image naming, or production chain code in the old release.
+
+## Phase 2: Build Candidate Upgrade Archives
+
+The candidate checkout builds the upgrade archives with:
+
+`make build-for-upgrade`
+
+The generated archives live under:
+
+- `public-html/v2/inferenced/inferenced-amd64.zip`
+- `public-html/v2/dapi/decentralized-api-amd64.zip`
+
+The workflow starts a small HTTP container on the `chain-public` Docker network and serves `public-html` to the old cluster. The current Testermint attach test computes SHA-256 checksums locally and includes them in the upgrade URLs.
+
+Do not use `make build-for-upgrade-tests` for this rehearsal. That target builds `inferenced` with the `upgraded` build tag, which swaps in the synthetic `v0.0.1test` handler and omits release handlers such as `v0.2.14`. This workflow is meant to exercise production-style release archives.
+
+## Phase 3: Complete The Upgrade
+
+The current checkout runs an attach-only Testermint test. This is the most important safety rule: phase 2 must discover the existing cluster and must not call the normal cluster setup path that can rebuild Docker state.
+
+The attach test:
+
+- reads the phase 1 manifest and asserts that meaningful old state exists;
+- attaches to `genesis`, `join1`, and `join2` containers by local Testermint image/name conventions;
+- submits a software-upgrade proposal whose title matches the target `UpgradeName`;
+- deposits and votes;
+- waits for the upgrade height and cosmovisor restart;
+- verifies `last-upgrade-height` on every node after the candidate binary is running;
+- verifies basic API/node health;
+- waits for a post-upgrade `START_OF_POC`, the matching `SET_NEW_VALIDATORS` stage, and then `CLAIM_REWARDS` so the candidate binary has completed PoC and crossed into the new epoch flow;
+- verifies every prepared miner is still active, not excluded, has non-zero PoC power, and has no dramatic power change after both `SET_NEW_VALIDATORS` and `CLAIM_REWARDS`;
+- runs a post-upgrade normal inference;
+- enables devshard request handling with a governance params proposal if the upgraded chain reports it disabled;
+- creates and settles a post-upgrade devshard escrow.
+
+By default, the power-stability check allows at most a 50% per-miner and total-power change across that post-upgrade PoC cycle. Use `UPGRADE_REHEARSAL_MAX_POWER_CHANGE_PERCENT` only for debugging a known intentional power-model change; do not loosen it to hide unexpected miner removal or cPoC fallout.
+
+The completion manifest records the post-upgrade PoC start block, `SET_NEW_VALIDATORS` block, `CLAIM_REWARDS` block, pre-upgrade baseline epoch/weights, post-PoC epoch/weights, and new-epoch weights so a failed or suspicious run can be compared without replaying the full logs first.
+
+## Running In GitHub Actions
+
+Use the dedicated workflow:
+
+`testermint-upgrade-rehearsal.yml`
+
+Typical manual run:
+
+```bash
+gh workflow run testermint-upgrade-rehearsal.yml --ref <candidate-ref>
+```
+
+Useful debug overrides:
+
+```bash
+gh workflow run testermint-upgrade-rehearsal.yml \
+  --ref <candidate-ref> \
+  -f target_upgrade=v0.2.14 \
+  -f previous_release=release/v0.2.13
+```
+
+The workflow uploads:
+
+- old and new Testermint logs;
+- old and new JUnit XML;
+- the prep and completion manifests;
+- a Docker state snapshot from the runner.
+
+The first live `v0.2.13` to `v0.2.14` rehearsal prep run completed in about 19 minutes and produced old-chain state across heights 76 to 198 and epochs 2 to 5. Treat a quiet prep step as normal while it is still within its workflow timeout.
+
+## Common Failures
+
+If previous image resolution fails, inspect the old tag's `deploy/join/docker-compose.yml`. The parser expects a service-level `image:` entry for at least `node` and `api`.
+
+If phase 1 fails before booting, confirm the old production images are still pullable from GHCR and that the retagged image names match local Testermint compose files.
+
+If the candidate archive build fails with `Cache export is not supported for the docker driver`, keep `USE_REGISTRY_CACHE=0` for this workflow or add an explicit Docker Buildx container-driver setup plus package write permissions. The rehearsal does not need to publish registry build caches.
+
+If the completion test fails on `last-upgrade-height` before submitting the proposal, make sure it is not querying candidate-only CLI commands against the previous release binary. Pre-upgrade assertions should rely on the prep manifest and old-chain health; `last-upgrade-height` is only meaningful after the candidate upgrade has applied.
+
+If phase 2 rebuilds the cluster, that is a bug. The current rehearsal test should only call attach/discovery helpers and should never call `initCluster`, `setupLocalCluster`, `launch.sh`, or `stop-rebuild.sh`.
+
+If the proposal passes but the chain never resumes, inspect node logs around the upgrade height. The most useful signals are cosmovisor download errors, checksum mismatches, missing upgrade handler names, or archive layout issues.
+
+If the node downloads the candidate binary and restarts, but the new binary still halts with `UPGRADE "<target>" NEEDED`, first confirm the candidate archive was built with `make build-for-upgrade` and not the test-only target. A test-tagged binary will not register normal release upgrade handlers.
+
+If post-upgrade inference fails with versioned endpoint routing, check that the test stubs mock-server responses for the target upgrade segment as well as the default segment.
+
+If the post-upgrade PoC/power check fails, inspect whether the prepared miners disappeared from active participants, appeared in `excluded_participants`, reported zero PoC weight, failed to remain available after `CLAIM_REWARDS`, or crossed the configured power-change threshold. This check is meant to catch upgrades that technically resume blocks but break the next epoch's miner set or cPoC/PoC accounting.
+
+If post-upgrade devshard settlement fails with `devshard completion and timeout requests are disabled`, query inference params and confirm `devshard_escrow_params.devshard_requests_enabled` is true. The rehearsal completion test enables this through a normal governance params proposal because older state or operational settings can carry a disabled value across the upgrade. When building that params proposal, preserve the existing `devshard_escrow_params.max_nonce` value, or repair a missing/zero value to the chain default, because a full `MsgUpdateParams` proposal with `max_nonce: 0` is rejected during proposal validation.
diff --git a/inference-chain/Dockerfile b/inference-chain/Dockerfile
index 3b9b1c73da..25e5e400da 100644
--- a/inference-chain/Dockerfile
+++ b/inference-chain/Dockerfile
@@ -3,7 +3,7 @@
 ################################################################################
 # Build stage
 ################################################################################
-FROM golang:1.24.2-alpine3.20 AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 
 ARG GOOS=linux
 ARG GOARCH=amd64
@@ -67,7 +67,7 @@ RUN mkdir /build_output
 FROM scratch AS binary-exporter
 # Copy all required files to a flat structure
 COPY --from=builder /app/inference-chain/build/inferenced /build_output/inferenced
-COPY --from=builder /lib/libwasmvm_muslc.x86_64.a /build_output/libwasmvm_muslc.x86_64.a
+COPY --from=builder /lib/libwasmvm_muslc.*.a /build_output/
 COPY --from=builder /root/wrapped_token.wasm /build_output/wrapped_token.wasm
 COPY --from=builder /usr/lib/libgcc_s.so.1 /build_output/libgcc_s.so.1
 
@@ -75,7 +75,7 @@ COPY --from=builder /usr/lib/libgcc_s.so.1 /build_output/libgcc_s.so.1
 # Final stage
 ################################################################################
 ARG TARGETPLATFORM
-FROM --platform=$TARGETPLATFORM alpine:3.18 AS final
+FROM --platform=$TARGETPLATFORM alpine:3.21 AS final
 
 ARG GOOS
 ARG GOARCH
diff --git a/inference-chain/Makefile b/inference-chain/Makefile
index 886a4bd54b..e701b6c5c1 100644
--- a/inference-chain/Makefile
+++ b/inference-chain/Makefile
@@ -8,6 +8,9 @@ include ../scripts/blst-portable.mk
 VERSION ?= $(shell git describe --always)
 SET_LATEST ?= 0
 SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
+PLATFORM ?= linux/amd64
+GOOS ?= linux
+GOARCH ?= amd64
 
 ldflags = \
   -X github.com/cosmos/cosmos-sdk/version.Name=inference-chain \
@@ -26,9 +29,10 @@ WASMVM_STATIC_LINUX_X64_URL := https://github.com/CosmWasm/wasmvm/releases/downl
 WASMVM_STATIC_LINUX_ARM64_URL := https://github.com/CosmWasm/wasmvm/releases/download/$(WASMVM_VERSION)/libwasmvm_muslc.aarch64.a
 
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
 ifeq ($(USE_REGISTRY_CACHE),1)
-DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/inferenced:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/inferenced:buildcache,mode=min
-DOCKER_CACHE_ARGS_UPGRADE := --cache-from type=registry,ref=ghcr.io/gonka-ai/inferenced:buildcache-upgrade --cache-to type=registry,ref=ghcr.io/gonka-ai/inferenced:buildcache-upgrade,mode=min
+DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/inferenced:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/inferenced:buildcache,mode=min
+DOCKER_CACHE_ARGS_UPGRADE := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/inferenced:buildcache-upgrade --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/inferenced:buildcache-upgrade,mode=min
 DOCKER_BUILD_PREFIX := docker buildx build --load $(DOCKER_CACHE_ARGS)
 DOCKER_BUILD_UPGRADE_PREFIX := docker buildx build $(DOCKER_CACHE_ARGS_UPGRADE)
 else
@@ -168,30 +172,26 @@ docker-push:
 	fi
 
 build-for-upgrade:
-	$(eval PLATFORM=linux/amd64)
-	$(eval GOOS=linux)
-	$(eval GOARCH=amd64)
 	$(eval DOCKER_FILE=Dockerfile)
 	$(DOCKER_BUILD_UPGRADE)
-	@echo "--> clearing out ../public-html/v2/inferenced"
-	@rm -rf ../public-html/v2/inferenced/*
+	@echo "--> staging inferenced binary and dependencies for $(GOARCH)"
 	@mkdir -p ../public-html/v2/inferenced
-	@echo "--> copying built inferenced binary and dependencies to ../public-html/v2/inferenced/"
-	@cp ./output/build_output/* ../public-html/v2/inferenced/
-	@echo "--> cleaning up intermediate build output"
-	@rm -rf ./output
-	@echo "--> zipping inferenced binary with dependencies"
+	@rm -rf ./output/upgrade-package-$(GOARCH)
+	@mkdir -p ./output/upgrade-package-$(GOARCH)
+	@cp ./output/build_output/* ./output/upgrade-package-$(GOARCH)/
+	@echo "--> zipping inferenced binary with dependencies for $(GOARCH)"
 	# We set the timestamp to a const and strip metadata in zip so we have a reproduceable checksum
-	@TZ=UTC find ../public-html/v2/inferenced -type f -exec touch -t 200001010000 {} \;
-	@cd ../public-html/v2/inferenced && zip -X -r inferenced-amd64.zip .
-	@echo "--> generating shasum for inferenced-amd64.zip"
-	@shasum -a 256 ../public-html/v2/inferenced/inferenced-amd64.zip
+	@TZ=UTC find ./output/upgrade-package-$(GOARCH) -type f -exec touch -t 200001010000 {} \;
+	@archive_path="$$(pwd)/../public-html/v2/inferenced/inferenced-$(GOARCH).zip"; \
+		rm -f "$$archive_path"; \
+		cd ./output/upgrade-package-$(GOARCH) && zip -X -r "$$archive_path" .
+	@echo "--> generating shasum for inferenced-$(GOARCH).zip"
+	@shasum -a 256 ../public-html/v2/inferenced/inferenced-$(GOARCH).zip
 	@echo "--> appending to ../public-html/v2/checksums.txt"
-	@echo "inferenced-amd64.zip $(shasum -a 256 ../public-html/v2/inferenced/inferenced-amd64.zip)" >> ../public-html/v2/checksums.txt
-
-# Disabled ARM builds as requested
-build-for-upgrade-arm:
-	@echo "ARM builds disabled"
+	@checksum=$$(shasum -a 256 ../public-html/v2/inferenced/inferenced-$(GOARCH).zip | awk '{print $$1}'); \
+		echo "inferenced-$(GOARCH).zip $$checksum" >> ../public-html/v2/checksums.txt
+	@echo "--> cleaning up intermediate build output"
+	@rm -rf ./output
 
 #################################################
 # CROSS-COMPILATION SECTION
diff --git a/inference-chain/api/inference/bls/tx.pulsar.go b/inference-chain/api/inference/bls/tx.pulsar.go
index c64f0d39f3..d08676cd5a 100644
--- a/inference-chain/api/inference/bls/tx.pulsar.go
+++ b/inference-chain/api/inference/bls/tx.pulsar.go
@@ -9756,6 +9756,8 @@ func (*MsgSubmitPartialSignatureResponse) Descriptor() ([]byte, []int) {
 }
 
 // MsgRequestThresholdSignature allows external users to request a threshold signature via transaction
+//
+// Deprecated: Do not use.
 type MsgRequestThresholdSignature struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -9830,6 +9832,8 @@ func (x *MsgRequestThresholdSignature) GetData() [][]byte {
 
 // MsgRequestThresholdSignatureResponse defines the response structure for executing a
 // MsgRequestThresholdSignature message.
+//
+// Deprecated: Do not use.
 type MsgRequestThresholdSignatureResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -10030,7 +10034,7 @@ var file_inference_bls_tx_proto_rawDesc = []byte{
 	0x6d, 0x69, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74,
 	0x75, 0x72, 0x65, 0x22, 0x23, 0x0a, 0x21, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
 	0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x89, 0x02, 0x0a, 0x1c, 0x4d, 0x73, 0x67,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8b, 0x02, 0x0a, 0x1c, 0x4d, 0x73, 0x67,
 	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64,
 	0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x63, 0x72, 0x65,
 	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14,
@@ -10043,79 +10047,79 @@ var file_inference_bls_tx_proto_rawDesc = []byte{
 	0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64,
 	0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49,
 	0x64, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52,
-	0x04, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x3d, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
+	0x04, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x3f, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
 	0x74, 0x6f, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x2c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2f, 0x78, 0x2f, 0x62, 0x6c, 0x73, 0x2f, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65,
 	0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61,
-	0x74, 0x75, 0x72, 0x65, 0x22, 0x54, 0x0a, 0x24, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61,
-	0x74, 0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x12,
-	0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f,
-	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65,
-	0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x32, 0xca, 0x06, 0x0a, 0x03, 0x4d,
-	0x73, 0x67, 0x12, 0x56, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61,
-	0x6d, 0x73, 0x12, 0x1e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
-	0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61,
-	0x6d, 0x73, 0x1a, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
-	0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61,
-	0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x10, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x12, 0x22,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d,
-	0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61,
-	0x72, 0x74, 0x1a, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
-	0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x61, 0x6c,
-	0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a,
-	0x0a, 0x18, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
-	0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74,
-	0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a, 0x17, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x64, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x70, 0x6c,
-	0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64,
-	0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x73,
-	0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73,
-	0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x44, 0x65, 0x61, 0x6c, 0x65,
-	0x72, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x95, 0x01, 0x0a, 0x21, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x47, 0x72,
+	0x74, 0x75, 0x72, 0x65, 0x18, 0x01, 0x22, 0x58, 0x0a, 0x24, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67,
+	0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c,
+	0x0a, 0x12, 0x64, 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x64, 0x65, 0x72, 0x69,
+	0x76, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x3a, 0x02, 0x18, 0x01,
+	0x32, 0xd0, 0x06, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x56, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x62, 0x0a, 0x10, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72,
+	0x50, 0x61, 0x72, 0x74, 0x12, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x44, 0x65,
+	0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x1a, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d,
+	0x69, 0x74, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x18, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x56, 0x65,
+	0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72,
+	0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73,
+	0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69,
+	0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x1a, 0x32, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67,
+	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x77, 0x0a, 0x17, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x44, 0x65, 0x61, 0x6c, 0x65,
+	0x72, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x29, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x70,
+	0x6c, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x64, 0x44, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x95, 0x01, 0x0a, 0x21, 0x53, 0x75,
+	0x62, 0x6d, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12,
+	0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e,
+	0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65,
+	0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61,
+	0x74, 0x75, 0x72, 0x65, 0x1a, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x47, 0x72,
 	0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
-	0x6d, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x1a, 0x3b,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d,
-	0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74,
-	0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a, 0x16, 0x53,
+	0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x74, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x28, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53,
 	0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e,
-	0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50,
-	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x1a,
-	0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e,
-	0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c,
-	0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x7d, 0x0a, 0x19, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65,
-	0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x2b,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d,
-	0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f,
-	0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53,
-	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0x91, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x42, 0x07, 0x54,
-	0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
-	0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x6c, 0x73, 0xa2, 0x02, 0x03, 0x49, 0x42, 0x58, 0xaa, 0x02,
-	0x0d, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6c, 0x73, 0xca, 0x02,
-	0x0d, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6c, 0x73, 0xe2, 0x02,
-	0x19, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6c, 0x73, 0x5c, 0x47,
-	0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x42, 0x6c, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x82, 0x01, 0x0a, 0x19, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x62, 0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+	0x72, 0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62,
+	0x6c, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x68, 0x72,
+	0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x1a, 0x05, 0x80, 0xe7,
+	0xb0, 0x2a, 0x01, 0x42, 0x91, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x62, 0x6c, 0x73, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x50, 0x01, 0x5a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e,
+	0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x62, 0x6c, 0x73, 0xa2, 0x02, 0x03, 0x49, 0x42, 0x58, 0xaa, 0x02, 0x0d, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6c, 0x73, 0xca, 0x02, 0x0d, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6c, 0x73, 0xe2, 0x02, 0x19, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x42, 0x6c, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x3a, 0x3a, 0x42, 0x6c, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/inference-chain/api/inference/bls/tx_grpc.pb.go b/inference-chain/api/inference/bls/tx_grpc.pb.go
index e1d0f4f815..0ee8d92f8f 100644
--- a/inference-chain/api/inference/bls/tx_grpc.pb.go
+++ b/inference-chain/api/inference/bls/tx_grpc.pb.go
@@ -45,6 +45,7 @@ type MsgClient interface {
 	SubmitGroupKeyValidationSignature(ctx context.Context, in *MsgSubmitGroupKeyValidationSignature, opts ...grpc.CallOption) (*MsgSubmitGroupKeyValidationSignatureResponse, error)
 	// SubmitPartialSignature allows a participant to submit their partial signature for threshold signing
 	SubmitPartialSignature(ctx context.Context, in *MsgSubmitPartialSignature, opts ...grpc.CallOption) (*MsgSubmitPartialSignatureResponse, error)
+	// Deprecated: Do not use.
 	// RequestThresholdSignature allows external users to request a threshold signature
 	RequestThresholdSignature(ctx context.Context, in *MsgRequestThresholdSignature, opts ...grpc.CallOption) (*MsgRequestThresholdSignatureResponse, error)
 }
@@ -111,6 +112,7 @@ func (c *msgClient) SubmitPartialSignature(ctx context.Context, in *MsgSubmitPar
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) RequestThresholdSignature(ctx context.Context, in *MsgRequestThresholdSignature, opts ...grpc.CallOption) (*MsgRequestThresholdSignatureResponse, error) {
 	out := new(MsgRequestThresholdSignatureResponse)
 	err := c.cc.Invoke(ctx, Msg_RequestThresholdSignature_FullMethodName, in, out, opts...)
@@ -137,6 +139,7 @@ type MsgServer interface {
 	SubmitGroupKeyValidationSignature(context.Context, *MsgSubmitGroupKeyValidationSignature) (*MsgSubmitGroupKeyValidationSignatureResponse, error)
 	// SubmitPartialSignature allows a participant to submit their partial signature for threshold signing
 	SubmitPartialSignature(context.Context, *MsgSubmitPartialSignature) (*MsgSubmitPartialSignatureResponse, error)
+	// Deprecated: Do not use.
 	// RequestThresholdSignature allows external users to request a threshold signature
 	RequestThresholdSignature(context.Context, *MsgRequestThresholdSignature) (*MsgRequestThresholdSignatureResponse, error)
 	mustEmbedUnimplementedMsgServer()
diff --git a/inference-chain/api/inference/inference/claim_recipient.pulsar.go b/inference-chain/api/inference/inference/claim_recipient.pulsar.go
new file mode 100644
index 0000000000..714760570b
--- /dev/null
+++ b/inference-chain/api/inference/inference/claim_recipient.pulsar.go
@@ -0,0 +1,630 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+	fmt "fmt"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var (
+	md_ClaimRecipientEntry           protoreflect.MessageDescriptor
+	fd_ClaimRecipientEntry_epoch     protoreflect.FieldDescriptor
+	fd_ClaimRecipientEntry_recipient protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_claim_recipient_proto_init()
+	md_ClaimRecipientEntry = File_inference_inference_claim_recipient_proto.Messages().ByName("ClaimRecipientEntry")
+	fd_ClaimRecipientEntry_epoch = md_ClaimRecipientEntry.Fields().ByName("epoch")
+	fd_ClaimRecipientEntry_recipient = md_ClaimRecipientEntry.Fields().ByName("recipient")
+}
+
+var _ protoreflect.Message = (*fastReflection_ClaimRecipientEntry)(nil)
+
+type fastReflection_ClaimRecipientEntry ClaimRecipientEntry
+
+func (x *ClaimRecipientEntry) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ClaimRecipientEntry)(x)
+}
+
+func (x *ClaimRecipientEntry) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_claim_recipient_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_ClaimRecipientEntry_messageType fastReflection_ClaimRecipientEntry_messageType
+var _ protoreflect.MessageType = fastReflection_ClaimRecipientEntry_messageType{}
+
+type fastReflection_ClaimRecipientEntry_messageType struct{}
+
+func (x fastReflection_ClaimRecipientEntry_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ClaimRecipientEntry)(nil)
+}
+func (x fastReflection_ClaimRecipientEntry_messageType) New() protoreflect.Message {
+	return new(fastReflection_ClaimRecipientEntry)
+}
+func (x fastReflection_ClaimRecipientEntry_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ClaimRecipientEntry
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_ClaimRecipientEntry) Descriptor() protoreflect.MessageDescriptor {
+	return md_ClaimRecipientEntry
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_ClaimRecipientEntry) Type() protoreflect.MessageType {
+	return _fastReflection_ClaimRecipientEntry_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_ClaimRecipientEntry) New() protoreflect.Message {
+	return new(fastReflection_ClaimRecipientEntry)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_ClaimRecipientEntry) Interface() protoreflect.ProtoMessage {
+	return (*ClaimRecipientEntry)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_ClaimRecipientEntry) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Epoch != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Epoch)
+		if !f(fd_ClaimRecipientEntry_epoch, value) {
+			return
+		}
+	}
+	if x.Recipient != "" {
+		value := protoreflect.ValueOfString(x.Recipient)
+		if !f(fd_ClaimRecipientEntry_recipient, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_ClaimRecipientEntry) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.ClaimRecipientEntry.epoch":
+		return x.Epoch != uint64(0)
+	case "inference.inference.ClaimRecipientEntry.recipient":
+		return x.Recipient != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ClaimRecipientEntry"))
+		}
+		panic(fmt.Errorf("message inference.inference.ClaimRecipientEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ClaimRecipientEntry) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.ClaimRecipientEntry.epoch":
+		x.Epoch = uint64(0)
+	case "inference.inference.ClaimRecipientEntry.recipient":
+		x.Recipient = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ClaimRecipientEntry"))
+		}
+		panic(fmt.Errorf("message inference.inference.ClaimRecipientEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_ClaimRecipientEntry) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.ClaimRecipientEntry.epoch":
+		value := x.Epoch
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ClaimRecipientEntry.recipient":
+		value := x.Recipient
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ClaimRecipientEntry"))
+		}
+		panic(fmt.Errorf("message inference.inference.ClaimRecipientEntry does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ClaimRecipientEntry) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.ClaimRecipientEntry.epoch":
+		x.Epoch = value.Uint()
+	case "inference.inference.ClaimRecipientEntry.recipient":
+		x.Recipient = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ClaimRecipientEntry"))
+		}
+		panic(fmt.Errorf("message inference.inference.ClaimRecipientEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ClaimRecipientEntry) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.ClaimRecipientEntry.epoch":
+		panic(fmt.Errorf("field epoch of message inference.inference.ClaimRecipientEntry is not mutable"))
+	case "inference.inference.ClaimRecipientEntry.recipient":
+		panic(fmt.Errorf("field recipient of message inference.inference.ClaimRecipientEntry is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ClaimRecipientEntry"))
+		}
+		panic(fmt.Errorf("message inference.inference.ClaimRecipientEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_ClaimRecipientEntry) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.ClaimRecipientEntry.epoch":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ClaimRecipientEntry.recipient":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ClaimRecipientEntry"))
+		}
+		panic(fmt.Errorf("message inference.inference.ClaimRecipientEntry does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_ClaimRecipientEntry) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ClaimRecipientEntry", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_ClaimRecipientEntry) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_ClaimRecipientEntry) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_ClaimRecipientEntry) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_ClaimRecipientEntry) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*ClaimRecipientEntry)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Epoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.Epoch))
+		}
+		l = len(x.Recipient)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*ClaimRecipientEntry)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Recipient) > 0 {
+			i -= len(x.Recipient)
+			copy(dAtA[i:], x.Recipient)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Recipient)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Epoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Epoch))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*ClaimRecipientEntry)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClaimRecipientEntry: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ClaimRecipientEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
+				}
+				x.Epoch = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Epoch |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Recipient = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: inference/inference/claim_recipient.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// ClaimRecipientEntry specifies, for a given epoch, where the participant's
+// claim rewards must be sent. An empty recipient removes the override (revert
+// to the participant's own creator address).
+type ClaimRecipientEntry struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Epoch     uint64 `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
+	Recipient string `protobuf:"bytes,2,opt,name=recipient,proto3" json:"recipient,omitempty"`
+}
+
+func (x *ClaimRecipientEntry) Reset() {
+	*x = ClaimRecipientEntry{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_claim_recipient_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ClaimRecipientEntry) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ClaimRecipientEntry) ProtoMessage() {}
+
+// Deprecated: Use ClaimRecipientEntry.ProtoReflect.Descriptor instead.
+func (*ClaimRecipientEntry) Descriptor() ([]byte, []int) {
+	return file_inference_inference_claim_recipient_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ClaimRecipientEntry) GetEpoch() uint64 {
+	if x != nil {
+		return x.Epoch
+	}
+	return 0
+}
+
+func (x *ClaimRecipientEntry) GetRecipient() string {
+	if x != nil {
+		return x.Recipient
+	}
+	return ""
+}
+
+var File_inference_inference_claim_recipient_proto protoreflect.FileDescriptor
+
+var file_inference_inference_claim_recipient_proto_rawDesc = []byte{
+	0x0a, 0x29, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x69,
+	0x70, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x22, 0x49, 0x0a, 0x13, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65,
+	0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x1c, 0x0a,
+	0x09, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x42, 0xc1, 0x01, 0x0a, 0x17,
+	0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x13, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65,
+	0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42,
+	0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_inference_inference_claim_recipient_proto_rawDescOnce sync.Once
+	file_inference_inference_claim_recipient_proto_rawDescData = file_inference_inference_claim_recipient_proto_rawDesc
+)
+
+func file_inference_inference_claim_recipient_proto_rawDescGZIP() []byte {
+	file_inference_inference_claim_recipient_proto_rawDescOnce.Do(func() {
+		file_inference_inference_claim_recipient_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_claim_recipient_proto_rawDescData)
+	})
+	return file_inference_inference_claim_recipient_proto_rawDescData
+}
+
+var file_inference_inference_claim_recipient_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_inference_inference_claim_recipient_proto_goTypes = []interface{}{
+	(*ClaimRecipientEntry)(nil), // 0: inference.inference.ClaimRecipientEntry
+}
+var file_inference_inference_claim_recipient_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_claim_recipient_proto_init() }
+func file_inference_inference_claim_recipient_proto_init() {
+	if File_inference_inference_claim_recipient_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_inference_inference_claim_recipient_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ClaimRecipientEntry); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_inference_inference_claim_recipient_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_inference_inference_claim_recipient_proto_goTypes,
+		DependencyIndexes: file_inference_inference_claim_recipient_proto_depIdxs,
+		MessageInfos:      file_inference_inference_claim_recipient_proto_msgTypes,
+	}.Build()
+	File_inference_inference_claim_recipient_proto = out.File
+	file_inference_inference_claim_recipient_proto_rawDesc = nil
+	file_inference_inference_claim_recipient_proto_goTypes = nil
+	file_inference_inference_claim_recipient_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/devshard_escrow.pulsar.go b/inference-chain/api/inference/inference/devshard_escrow.pulsar.go
index b16bc3053e..3976530043 100644
--- a/inference-chain/api/inference/inference/devshard_escrow.pulsar.go
+++ b/inference-chain/api/inference/inference/devshard_escrow.pulsar.go
@@ -74,6 +74,7 @@ var (
 	fd_DevshardEscrow_inference_seal_grace_nonces  protoreflect.FieldDescriptor
 	fd_DevshardEscrow_inference_seal_grace_seconds protoreflect.FieldDescriptor
 	fd_DevshardEscrow_auto_seal_every_n_nonces     protoreflect.FieldDescriptor
+	fd_DevshardEscrow_validation_rate              protoreflect.FieldDescriptor
 )
 
 func init() {
@@ -93,6 +94,7 @@ func init() {
 	fd_DevshardEscrow_inference_seal_grace_nonces = md_DevshardEscrow.Fields().ByName("inference_seal_grace_nonces")
 	fd_DevshardEscrow_inference_seal_grace_seconds = md_DevshardEscrow.Fields().ByName("inference_seal_grace_seconds")
 	fd_DevshardEscrow_auto_seal_every_n_nonces = md_DevshardEscrow.Fields().ByName("auto_seal_every_n_nonces")
+	fd_DevshardEscrow_validation_rate = md_DevshardEscrow.Fields().ByName("validation_rate")
 }
 
 var _ protoreflect.Message = (*fastReflection_DevshardEscrow)(nil)
@@ -244,6 +246,12 @@ func (x *fastReflection_DevshardEscrow) Range(f func(protoreflect.FieldDescripto
 			return
 		}
 	}
+	if x.ValidationRate != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.ValidationRate)
+		if !f(fd_DevshardEscrow_validation_rate, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -287,6 +295,8 @@ func (x *fastReflection_DevshardEscrow) Has(fd protoreflect.FieldDescriptor) boo
 		return x.InferenceSealGraceSeconds != uint32(0)
 	case "inference.inference.DevshardEscrow.auto_seal_every_n_nonces":
 		return x.AutoSealEveryNNonces != uint32(0)
+	case "inference.inference.DevshardEscrow.validation_rate":
+		return x.ValidationRate != uint32(0)
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DevshardEscrow"))
@@ -331,6 +341,8 @@ func (x *fastReflection_DevshardEscrow) Clear(fd protoreflect.FieldDescriptor) {
 		x.InferenceSealGraceSeconds = uint32(0)
 	case "inference.inference.DevshardEscrow.auto_seal_every_n_nonces":
 		x.AutoSealEveryNNonces = uint32(0)
+	case "inference.inference.DevshardEscrow.validation_rate":
+		x.ValidationRate = uint32(0)
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DevshardEscrow"))
@@ -392,6 +404,9 @@ func (x *fastReflection_DevshardEscrow) Get(descriptor protoreflect.FieldDescrip
 	case "inference.inference.DevshardEscrow.auto_seal_every_n_nonces":
 		value := x.AutoSealEveryNNonces
 		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.DevshardEscrow.validation_rate":
+		value := x.ValidationRate
+		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DevshardEscrow"))
@@ -442,6 +457,8 @@ func (x *fastReflection_DevshardEscrow) Set(fd protoreflect.FieldDescriptor, val
 		x.InferenceSealGraceSeconds = uint32(value.Uint())
 	case "inference.inference.DevshardEscrow.auto_seal_every_n_nonces":
 		x.AutoSealEveryNNonces = uint32(value.Uint())
+	case "inference.inference.DevshardEscrow.validation_rate":
+		x.ValidationRate = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DevshardEscrow"))
@@ -494,6 +511,8 @@ func (x *fastReflection_DevshardEscrow) Mutable(fd protoreflect.FieldDescriptor)
 		panic(fmt.Errorf("field inference_seal_grace_seconds of message inference.inference.DevshardEscrow is not mutable"))
 	case "inference.inference.DevshardEscrow.auto_seal_every_n_nonces":
 		panic(fmt.Errorf("field auto_seal_every_n_nonces of message inference.inference.DevshardEscrow is not mutable"))
+	case "inference.inference.DevshardEscrow.validation_rate":
+		panic(fmt.Errorf("field validation_rate of message inference.inference.DevshardEscrow is not mutable"))
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DevshardEscrow"))
@@ -536,6 +555,8 @@ func (x *fastReflection_DevshardEscrow) NewField(fd protoreflect.FieldDescriptor
 		return protoreflect.ValueOfUint32(uint32(0))
 	case "inference.inference.DevshardEscrow.auto_seal_every_n_nonces":
 		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.DevshardEscrow.validation_rate":
+		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DevshardEscrow"))
@@ -653,6 +674,9 @@ func (x *fastReflection_DevshardEscrow) ProtoMethods() *protoiface.Methods {
 		if x.AutoSealEveryNNonces != 0 {
 			n += 1 + runtime.Sov(uint64(x.AutoSealEveryNNonces))
 		}
+		if x.ValidationRate != 0 {
+			n += 1 + runtime.Sov(uint64(x.ValidationRate))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -682,6 +706,11 @@ func (x *fastReflection_DevshardEscrow) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.ValidationRate != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ValidationRate))
+			i--
+			dAtA[i] = 0x78
+		}
 		if x.AutoSealEveryNNonces != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.AutoSealEveryNNonces))
 			i--
@@ -1135,6 +1164,25 @@ func (x *fastReflection_DevshardEscrow) ProtoMethods() *protoiface.Methods {
 						break
 					}
 				}
+			case 15:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationRate", wireType)
+				}
+				x.ValidationRate = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ValidationRate |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -3072,6 +3120,9 @@ type DevshardEscrow struct {
 	InferenceSealGraceNonces  uint32   `protobuf:"varint,12,opt,name=inference_seal_grace_nonces,json=inferenceSealGraceNonces,proto3" json:"inference_seal_grace_nonces,omitempty"`
 	InferenceSealGraceSeconds uint32   `protobuf:"varint,13,opt,name=inference_seal_grace_seconds,json=inferenceSealGraceSeconds,proto3" json:"inference_seal_grace_seconds,omitempty"`
 	AutoSealEveryNNonces      uint32   `protobuf:"varint,14,opt,name=auto_seal_every_n_nonces,json=autoSealEveryNNonces,proto3" json:"auto_seal_every_n_nonces,omitempty"`
+	// Snapshotted from DevshardEscrowParams at create (lane A). Zero on legacy
+	// rows means "unset"; clients fall back to DefaultDevshardValidationRate.
+	ValidationRate uint32 `protobuf:"varint,15,opt,name=validation_rate,json=validationRate,proto3" json:"validation_rate,omitempty"`
 }
 
 func (x *DevshardEscrow) Reset() {
@@ -3192,6 +3243,13 @@ func (x *DevshardEscrow) GetAutoSealEveryNNonces() uint32 {
 	return 0
 }
 
+func (x *DevshardEscrow) GetValidationRate() uint32 {
+	if x != nil {
+		return x.ValidationRate
+	}
+	return 0
+}
+
 type DevshardHostEpochStats struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -3408,7 +3466,7 @@ var file_inference_inference_devshard_escrow_proto_rawDesc = []byte{
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x65,
 	0x73, 0x63, 0x72, 0x6f, 0x77, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x22, 0x86, 0x04, 0x0a, 0x0e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63,
+	0x22, 0xaf, 0x04, 0x0a, 0x0e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63,
 	0x72, 0x6f, 0x77, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
 	0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02,
 	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a,
@@ -3440,58 +3498,61 @@ var file_inference_inference_devshard_escrow_proto_rawDesc = []byte{
 	0x73, 0x12, 0x36, 0x0a, 0x18, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x73, 0x65, 0x61, 0x6c, 0x5f, 0x65,
 	0x76, 0x65, 0x72, 0x79, 0x5f, 0x6e, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x0e, 0x20,
 	0x01, 0x28, 0x0d, 0x52, 0x14, 0x61, 0x75, 0x74, 0x6f, 0x53, 0x65, 0x61, 0x6c, 0x45, 0x76, 0x65,
-	0x72, 0x79, 0x4e, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x22, 0xac, 0x02, 0x0a, 0x16, 0x44, 0x65,
-	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53,
-	0x74, 0x61, 0x74, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
-	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x73, 0x73, 0x65,
-	0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x12,
-	0x18, 0x0a, 0x07, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d,
-	0x52, 0x07, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x73,
-	0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x12, 0x31, 0x0a,
-	0x14, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x72, 0x65, 0x71,
-	0x75, 0x69, 0x72, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x12, 0x33, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52,
-	0x14, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x5f,
-	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x65, 0x73, 0x63,
-	0x72, 0x6f, 0x77, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xe4, 0x01, 0x0a, 0x1b, 0x44, 0x65, 0x76,
-	0x73, 0x68, 0x61, 0x72, 0x64, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x48,
-	0x6f, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x6c, 0x6f, 0x74,
-	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x73, 0x6c, 0x6f, 0x74, 0x49,
-	0x64, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0d, 0x52, 0x06, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x76,
-	0x61, 0x6c, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x69, 0x6e, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x71, 0x75, 0x69,
-	0x72, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
-	0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x56,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x33, 0x0a, 0x15, 0x63, 0x6f,
-	0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x14, 0x63, 0x6f, 0x6d, 0x70, 0x6c,
-	0x65, 0x74, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22,
-	0x4e, 0x0a, 0x15, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x53, 0x6c, 0x6f, 0x74, 0x53,
-	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x6c, 0x6f, 0x74,
-	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x73, 0x6c, 0x6f, 0x74, 0x49,
-	0x64, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42,
-	0xc1, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x13, 0x44, 0x65, 0x76,
-	0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x50, 0x72, 0x6f, 0x74, 0x6f,
-	0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f,
-	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02,
-	0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x72, 0x79, 0x4e, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x0f, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x61,
+	0x74, 0x65, 0x22, 0xac, 0x02, 0x0a, 0x16, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48,
+	0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x20, 0x0a,
+	0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12,
+	0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78,
+	0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x06, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x69, 0x6e, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x04, 0x63, 0x6f, 0x73, 0x74, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
+	0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x33, 0x0a, 0x15, 0x63, 0x6f, 0x6d,
+	0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x14, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65,
+	0x74, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21,
+	0x0a, 0x0c, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x43, 0x6f, 0x75, 0x6e,
+	0x74, 0x22, 0xe4, 0x01, 0x0a, 0x1b, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x53, 0x65,
+	0x74, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x6c, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x06, 0x73, 0x6c, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69,
+	0x73, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6d, 0x69, 0x73, 0x73,
+	0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x07, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04,
+	0x63, 0x6f, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x63, 0x6f, 0x73, 0x74,
+	0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13,
+	0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x12, 0x33, 0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64,
+	0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x14, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4e, 0x0a, 0x15, 0x44, 0x65, 0x76, 0x73,
+	0x68, 0x61, 0x72, 0x64, 0x53, 0x6c, 0x6f, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+	0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x6c, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x06, 0x73, 0x6c, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69,
+	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0xc1, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x42, 0x13, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73,
+	0x63, 0x72, 0x6f, 0x77, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73,
+	0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13,
+	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c,
+	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74,
+	0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/inference-chain/api/inference/inference/maintenance.pulsar.go b/inference-chain/api/inference/inference/maintenance.pulsar.go
new file mode 100644
index 0000000000..fc4626260f
--- /dev/null
+++ b/inference-chain/api/inference/inference/maintenance.pulsar.go
@@ -0,0 +1,2446 @@
+// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
+package inference
+
+import (
+	fmt "fmt"
+	runtime "github.com/cosmos/cosmos-proto/runtime"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoiface "google.golang.org/protobuf/runtime/protoiface"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	io "io"
+	reflect "reflect"
+	sync "sync"
+)
+
+var (
+	md_MaintenanceReservation                    protoreflect.MessageDescriptor
+	fd_MaintenanceReservation_reservation_id     protoreflect.FieldDescriptor
+	fd_MaintenanceReservation_participant        protoreflect.FieldDescriptor
+	fd_MaintenanceReservation_start_height       protoreflect.FieldDescriptor
+	fd_MaintenanceReservation_duration_blocks    protoreflect.FieldDescriptor
+	fd_MaintenanceReservation_created_by         protoreflect.FieldDescriptor
+	fd_MaintenanceReservation_status             protoreflect.FieldDescriptor
+	fd_MaintenanceReservation_activation_warning protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_maintenance_proto_init()
+	md_MaintenanceReservation = File_inference_inference_maintenance_proto.Messages().ByName("MaintenanceReservation")
+	fd_MaintenanceReservation_reservation_id = md_MaintenanceReservation.Fields().ByName("reservation_id")
+	fd_MaintenanceReservation_participant = md_MaintenanceReservation.Fields().ByName("participant")
+	fd_MaintenanceReservation_start_height = md_MaintenanceReservation.Fields().ByName("start_height")
+	fd_MaintenanceReservation_duration_blocks = md_MaintenanceReservation.Fields().ByName("duration_blocks")
+	fd_MaintenanceReservation_created_by = md_MaintenanceReservation.Fields().ByName("created_by")
+	fd_MaintenanceReservation_status = md_MaintenanceReservation.Fields().ByName("status")
+	fd_MaintenanceReservation_activation_warning = md_MaintenanceReservation.Fields().ByName("activation_warning")
+}
+
+var _ protoreflect.Message = (*fastReflection_MaintenanceReservation)(nil)
+
+type fastReflection_MaintenanceReservation MaintenanceReservation
+
+func (x *MaintenanceReservation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MaintenanceReservation)(x)
+}
+
+func (x *MaintenanceReservation) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_maintenance_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MaintenanceReservation_messageType fastReflection_MaintenanceReservation_messageType
+var _ protoreflect.MessageType = fastReflection_MaintenanceReservation_messageType{}
+
+type fastReflection_MaintenanceReservation_messageType struct{}
+
+func (x fastReflection_MaintenanceReservation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MaintenanceReservation)(nil)
+}
+func (x fastReflection_MaintenanceReservation_messageType) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceReservation)
+}
+func (x fastReflection_MaintenanceReservation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceReservation
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MaintenanceReservation) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceReservation
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MaintenanceReservation) Type() protoreflect.MessageType {
+	return _fastReflection_MaintenanceReservation_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MaintenanceReservation) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceReservation)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MaintenanceReservation) Interface() protoreflect.ProtoMessage {
+	return (*MaintenanceReservation)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MaintenanceReservation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ReservationId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ReservationId)
+		if !f(fd_MaintenanceReservation_reservation_id, value) {
+			return
+		}
+	}
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_MaintenanceReservation_participant, value) {
+			return
+		}
+	}
+	if x.StartHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.StartHeight)
+		if !f(fd_MaintenanceReservation_start_height, value) {
+			return
+		}
+	}
+	if x.DurationBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.DurationBlocks)
+		if !f(fd_MaintenanceReservation_duration_blocks, value) {
+			return
+		}
+	}
+	if x.CreatedBy != "" {
+		value := protoreflect.ValueOfString(x.CreatedBy)
+		if !f(fd_MaintenanceReservation_created_by, value) {
+			return
+		}
+	}
+	if x.Status != 0 {
+		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Status))
+		if !f(fd_MaintenanceReservation_status, value) {
+			return
+		}
+	}
+	if x.ActivationWarning != "" {
+		value := protoreflect.ValueOfString(x.ActivationWarning)
+		if !f(fd_MaintenanceReservation_activation_warning, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MaintenanceReservation) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceReservation.reservation_id":
+		return x.ReservationId != uint64(0)
+	case "inference.inference.MaintenanceReservation.participant":
+		return x.Participant != ""
+	case "inference.inference.MaintenanceReservation.start_height":
+		return x.StartHeight != int64(0)
+	case "inference.inference.MaintenanceReservation.duration_blocks":
+		return x.DurationBlocks != uint64(0)
+	case "inference.inference.MaintenanceReservation.created_by":
+		return x.CreatedBy != ""
+	case "inference.inference.MaintenanceReservation.status":
+		return x.Status != 0
+	case "inference.inference.MaintenanceReservation.activation_warning":
+		return x.ActivationWarning != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceReservation"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceReservation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceReservation) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceReservation.reservation_id":
+		x.ReservationId = uint64(0)
+	case "inference.inference.MaintenanceReservation.participant":
+		x.Participant = ""
+	case "inference.inference.MaintenanceReservation.start_height":
+		x.StartHeight = int64(0)
+	case "inference.inference.MaintenanceReservation.duration_blocks":
+		x.DurationBlocks = uint64(0)
+	case "inference.inference.MaintenanceReservation.created_by":
+		x.CreatedBy = ""
+	case "inference.inference.MaintenanceReservation.status":
+		x.Status = 0
+	case "inference.inference.MaintenanceReservation.activation_warning":
+		x.ActivationWarning = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceReservation"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceReservation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MaintenanceReservation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MaintenanceReservation.reservation_id":
+		value := x.ReservationId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceReservation.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MaintenanceReservation.start_height":
+		value := x.StartHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.MaintenanceReservation.duration_blocks":
+		value := x.DurationBlocks
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceReservation.created_by":
+		value := x.CreatedBy
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MaintenanceReservation.status":
+		value := x.Status
+		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+	case "inference.inference.MaintenanceReservation.activation_warning":
+		value := x.ActivationWarning
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceReservation"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceReservation does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceReservation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceReservation.reservation_id":
+		x.ReservationId = value.Uint()
+	case "inference.inference.MaintenanceReservation.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.MaintenanceReservation.start_height":
+		x.StartHeight = value.Int()
+	case "inference.inference.MaintenanceReservation.duration_blocks":
+		x.DurationBlocks = value.Uint()
+	case "inference.inference.MaintenanceReservation.created_by":
+		x.CreatedBy = value.Interface().(string)
+	case "inference.inference.MaintenanceReservation.status":
+		x.Status = (MaintenanceReservationStatus)(value.Enum())
+	case "inference.inference.MaintenanceReservation.activation_warning":
+		x.ActivationWarning = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceReservation"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceReservation does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceReservation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceReservation.reservation_id":
+		panic(fmt.Errorf("field reservation_id of message inference.inference.MaintenanceReservation is not mutable"))
+	case "inference.inference.MaintenanceReservation.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.MaintenanceReservation is not mutable"))
+	case "inference.inference.MaintenanceReservation.start_height":
+		panic(fmt.Errorf("field start_height of message inference.inference.MaintenanceReservation is not mutable"))
+	case "inference.inference.MaintenanceReservation.duration_blocks":
+		panic(fmt.Errorf("field duration_blocks of message inference.inference.MaintenanceReservation is not mutable"))
+	case "inference.inference.MaintenanceReservation.created_by":
+		panic(fmt.Errorf("field created_by of message inference.inference.MaintenanceReservation is not mutable"))
+	case "inference.inference.MaintenanceReservation.status":
+		panic(fmt.Errorf("field status of message inference.inference.MaintenanceReservation is not mutable"))
+	case "inference.inference.MaintenanceReservation.activation_warning":
+		panic(fmt.Errorf("field activation_warning of message inference.inference.MaintenanceReservation is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceReservation"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceReservation does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MaintenanceReservation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceReservation.reservation_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceReservation.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MaintenanceReservation.start_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.MaintenanceReservation.duration_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceReservation.created_by":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MaintenanceReservation.status":
+		return protoreflect.ValueOfEnum(0)
+	case "inference.inference.MaintenanceReservation.activation_warning":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceReservation"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceReservation does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MaintenanceReservation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MaintenanceReservation", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MaintenanceReservation) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceReservation) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MaintenanceReservation) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MaintenanceReservation) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MaintenanceReservation)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.ReservationId != 0 {
+			n += 1 + runtime.Sov(uint64(x.ReservationId))
+		}
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.StartHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.StartHeight))
+		}
+		if x.DurationBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.DurationBlocks))
+		}
+		l = len(x.CreatedBy)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Status != 0 {
+			n += 1 + runtime.Sov(uint64(x.Status))
+		}
+		l = len(x.ActivationWarning)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceReservation)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ActivationWarning) > 0 {
+			i -= len(x.ActivationWarning)
+			copy(dAtA[i:], x.ActivationWarning)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ActivationWarning)))
+			i--
+			dAtA[i] = 0x3a
+		}
+		if x.Status != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Status))
+			i--
+			dAtA[i] = 0x30
+		}
+		if len(x.CreatedBy) > 0 {
+			i -= len(x.CreatedBy)
+			copy(dAtA[i:], x.CreatedBy)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CreatedBy)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if x.DurationBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.DurationBlocks))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.StartHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.StartHeight))
+			i--
+			dAtA[i] = 0x18
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.ReservationId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ReservationId))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceReservation)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceReservation: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceReservation: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+				}
+				x.ReservationId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ReservationId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
+				}
+				x.StartHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.StartHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DurationBlocks", wireType)
+				}
+				x.DurationBlocks = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.DurationBlocks |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreatedBy", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.CreatedBy = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+				}
+				x.Status = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Status |= MaintenanceReservationStatus(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActivationWarning", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ActivationWarning = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MaintenanceState                            protoreflect.MessageDescriptor
+	fd_MaintenanceState_participant                protoreflect.FieldDescriptor
+	fd_MaintenanceState_credit_blocks              protoreflect.FieldDescriptor
+	fd_MaintenanceState_last_maintenance_epoch     protoreflect.FieldDescriptor
+	fd_MaintenanceState_active_reservation_id      protoreflect.FieldDescriptor
+	fd_MaintenanceState_scheduled_reservation_id   protoreflect.FieldDescriptor
+	fd_MaintenanceState_last_maintenance_end_epoch protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_maintenance_proto_init()
+	md_MaintenanceState = File_inference_inference_maintenance_proto.Messages().ByName("MaintenanceState")
+	fd_MaintenanceState_participant = md_MaintenanceState.Fields().ByName("participant")
+	fd_MaintenanceState_credit_blocks = md_MaintenanceState.Fields().ByName("credit_blocks")
+	fd_MaintenanceState_last_maintenance_epoch = md_MaintenanceState.Fields().ByName("last_maintenance_epoch")
+	fd_MaintenanceState_active_reservation_id = md_MaintenanceState.Fields().ByName("active_reservation_id")
+	fd_MaintenanceState_scheduled_reservation_id = md_MaintenanceState.Fields().ByName("scheduled_reservation_id")
+	fd_MaintenanceState_last_maintenance_end_epoch = md_MaintenanceState.Fields().ByName("last_maintenance_end_epoch")
+}
+
+var _ protoreflect.Message = (*fastReflection_MaintenanceState)(nil)
+
+type fastReflection_MaintenanceState MaintenanceState
+
+func (x *MaintenanceState) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MaintenanceState)(x)
+}
+
+func (x *MaintenanceState) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_maintenance_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MaintenanceState_messageType fastReflection_MaintenanceState_messageType
+var _ protoreflect.MessageType = fastReflection_MaintenanceState_messageType{}
+
+type fastReflection_MaintenanceState_messageType struct{}
+
+func (x fastReflection_MaintenanceState_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MaintenanceState)(nil)
+}
+func (x fastReflection_MaintenanceState_messageType) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceState)
+}
+func (x fastReflection_MaintenanceState_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceState
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MaintenanceState) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceState
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MaintenanceState) Type() protoreflect.MessageType {
+	return _fastReflection_MaintenanceState_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MaintenanceState) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceState)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MaintenanceState) Interface() protoreflect.ProtoMessage {
+	return (*MaintenanceState)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MaintenanceState) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_MaintenanceState_participant, value) {
+			return
+		}
+	}
+	if x.CreditBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.CreditBlocks)
+		if !f(fd_MaintenanceState_credit_blocks, value) {
+			return
+		}
+	}
+	if x.LastMaintenanceEpoch != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.LastMaintenanceEpoch)
+		if !f(fd_MaintenanceState_last_maintenance_epoch, value) {
+			return
+		}
+	}
+	if x.ActiveReservationId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ActiveReservationId)
+		if !f(fd_MaintenanceState_active_reservation_id, value) {
+			return
+		}
+	}
+	if x.ScheduledReservationId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ScheduledReservationId)
+		if !f(fd_MaintenanceState_scheduled_reservation_id, value) {
+			return
+		}
+	}
+	if x.LastMaintenanceEndEpoch != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.LastMaintenanceEndEpoch)
+		if !f(fd_MaintenanceState_last_maintenance_end_epoch, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MaintenanceState) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceState.participant":
+		return x.Participant != ""
+	case "inference.inference.MaintenanceState.credit_blocks":
+		return x.CreditBlocks != uint64(0)
+	case "inference.inference.MaintenanceState.last_maintenance_epoch":
+		return x.LastMaintenanceEpoch != uint64(0)
+	case "inference.inference.MaintenanceState.active_reservation_id":
+		return x.ActiveReservationId != uint64(0)
+	case "inference.inference.MaintenanceState.scheduled_reservation_id":
+		return x.ScheduledReservationId != uint64(0)
+	case "inference.inference.MaintenanceState.last_maintenance_end_epoch":
+		return x.LastMaintenanceEndEpoch != uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceState"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceState does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceState) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceState.participant":
+		x.Participant = ""
+	case "inference.inference.MaintenanceState.credit_blocks":
+		x.CreditBlocks = uint64(0)
+	case "inference.inference.MaintenanceState.last_maintenance_epoch":
+		x.LastMaintenanceEpoch = uint64(0)
+	case "inference.inference.MaintenanceState.active_reservation_id":
+		x.ActiveReservationId = uint64(0)
+	case "inference.inference.MaintenanceState.scheduled_reservation_id":
+		x.ScheduledReservationId = uint64(0)
+	case "inference.inference.MaintenanceState.last_maintenance_end_epoch":
+		x.LastMaintenanceEndEpoch = uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceState"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceState does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MaintenanceState) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MaintenanceState.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MaintenanceState.credit_blocks":
+		value := x.CreditBlocks
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceState.last_maintenance_epoch":
+		value := x.LastMaintenanceEpoch
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceState.active_reservation_id":
+		value := x.ActiveReservationId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceState.scheduled_reservation_id":
+		value := x.ScheduledReservationId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceState.last_maintenance_end_epoch":
+		value := x.LastMaintenanceEndEpoch
+		return protoreflect.ValueOfUint64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceState"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceState does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceState) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceState.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.MaintenanceState.credit_blocks":
+		x.CreditBlocks = value.Uint()
+	case "inference.inference.MaintenanceState.last_maintenance_epoch":
+		x.LastMaintenanceEpoch = value.Uint()
+	case "inference.inference.MaintenanceState.active_reservation_id":
+		x.ActiveReservationId = value.Uint()
+	case "inference.inference.MaintenanceState.scheduled_reservation_id":
+		x.ScheduledReservationId = value.Uint()
+	case "inference.inference.MaintenanceState.last_maintenance_end_epoch":
+		x.LastMaintenanceEndEpoch = value.Uint()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceState"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceState does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceState) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceState.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.MaintenanceState is not mutable"))
+	case "inference.inference.MaintenanceState.credit_blocks":
+		panic(fmt.Errorf("field credit_blocks of message inference.inference.MaintenanceState is not mutable"))
+	case "inference.inference.MaintenanceState.last_maintenance_epoch":
+		panic(fmt.Errorf("field last_maintenance_epoch of message inference.inference.MaintenanceState is not mutable"))
+	case "inference.inference.MaintenanceState.active_reservation_id":
+		panic(fmt.Errorf("field active_reservation_id of message inference.inference.MaintenanceState is not mutable"))
+	case "inference.inference.MaintenanceState.scheduled_reservation_id":
+		panic(fmt.Errorf("field scheduled_reservation_id of message inference.inference.MaintenanceState is not mutable"))
+	case "inference.inference.MaintenanceState.last_maintenance_end_epoch":
+		panic(fmt.Errorf("field last_maintenance_end_epoch of message inference.inference.MaintenanceState is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceState"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceState does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MaintenanceState) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceState.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MaintenanceState.credit_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceState.last_maintenance_epoch":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceState.active_reservation_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceState.scheduled_reservation_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceState.last_maintenance_end_epoch":
+		return protoreflect.ValueOfUint64(uint64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceState"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceState does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MaintenanceState) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MaintenanceState", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MaintenanceState) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceState) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MaintenanceState) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MaintenanceState) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MaintenanceState)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.CreditBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.CreditBlocks))
+		}
+		if x.LastMaintenanceEpoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.LastMaintenanceEpoch))
+		}
+		if x.ActiveReservationId != 0 {
+			n += 1 + runtime.Sov(uint64(x.ActiveReservationId))
+		}
+		if x.ScheduledReservationId != 0 {
+			n += 1 + runtime.Sov(uint64(x.ScheduledReservationId))
+		}
+		if x.LastMaintenanceEndEpoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.LastMaintenanceEndEpoch))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceState)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.LastMaintenanceEndEpoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastMaintenanceEndEpoch))
+			i--
+			dAtA[i] = 0x30
+		}
+		if x.ScheduledReservationId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ScheduledReservationId))
+			i--
+			dAtA[i] = 0x28
+		}
+		if x.ActiveReservationId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ActiveReservationId))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.LastMaintenanceEpoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastMaintenanceEpoch))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.CreditBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CreditBlocks))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceState)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceState: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceState: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreditBlocks", wireType)
+				}
+				x.CreditBlocks = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.CreditBlocks |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastMaintenanceEpoch", wireType)
+				}
+				x.LastMaintenanceEpoch = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.LastMaintenanceEpoch |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActiveReservationId", wireType)
+				}
+				x.ActiveReservationId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ActiveReservationId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ScheduledReservationId", wireType)
+				}
+				x.ScheduledReservationId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ScheduledReservationId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastMaintenanceEndEpoch", wireType)
+				}
+				x.LastMaintenanceEndEpoch = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.LastMaintenanceEndEpoch |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MaintenanceTransition                protoreflect.MessageDescriptor
+	fd_MaintenanceTransition_block_height   protoreflect.FieldDescriptor
+	fd_MaintenanceTransition_reservation_id protoreflect.FieldDescriptor
+	fd_MaintenanceTransition_type           protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_maintenance_proto_init()
+	md_MaintenanceTransition = File_inference_inference_maintenance_proto.Messages().ByName("MaintenanceTransition")
+	fd_MaintenanceTransition_block_height = md_MaintenanceTransition.Fields().ByName("block_height")
+	fd_MaintenanceTransition_reservation_id = md_MaintenanceTransition.Fields().ByName("reservation_id")
+	fd_MaintenanceTransition_type = md_MaintenanceTransition.Fields().ByName("type")
+}
+
+var _ protoreflect.Message = (*fastReflection_MaintenanceTransition)(nil)
+
+type fastReflection_MaintenanceTransition MaintenanceTransition
+
+func (x *MaintenanceTransition) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MaintenanceTransition)(x)
+}
+
+func (x *MaintenanceTransition) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_maintenance_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MaintenanceTransition_messageType fastReflection_MaintenanceTransition_messageType
+var _ protoreflect.MessageType = fastReflection_MaintenanceTransition_messageType{}
+
+type fastReflection_MaintenanceTransition_messageType struct{}
+
+func (x fastReflection_MaintenanceTransition_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MaintenanceTransition)(nil)
+}
+func (x fastReflection_MaintenanceTransition_messageType) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceTransition)
+}
+func (x fastReflection_MaintenanceTransition_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceTransition
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MaintenanceTransition) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceTransition
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MaintenanceTransition) Type() protoreflect.MessageType {
+	return _fastReflection_MaintenanceTransition_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MaintenanceTransition) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceTransition)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MaintenanceTransition) Interface() protoreflect.ProtoMessage {
+	return (*MaintenanceTransition)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MaintenanceTransition) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_MaintenanceTransition_block_height, value) {
+			return
+		}
+	}
+	if x.ReservationId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ReservationId)
+		if !f(fd_MaintenanceTransition_reservation_id, value) {
+			return
+		}
+	}
+	if x.Type_ != 0 {
+		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.Type_))
+		if !f(fd_MaintenanceTransition_type, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MaintenanceTransition) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceTransition.block_height":
+		return x.BlockHeight != int64(0)
+	case "inference.inference.MaintenanceTransition.reservation_id":
+		return x.ReservationId != uint64(0)
+	case "inference.inference.MaintenanceTransition.type":
+		return x.Type_ != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceTransition"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceTransition does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceTransition) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceTransition.block_height":
+		x.BlockHeight = int64(0)
+	case "inference.inference.MaintenanceTransition.reservation_id":
+		x.ReservationId = uint64(0)
+	case "inference.inference.MaintenanceTransition.type":
+		x.Type_ = 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceTransition"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceTransition does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MaintenanceTransition) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MaintenanceTransition.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.MaintenanceTransition.reservation_id":
+		value := x.ReservationId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceTransition.type":
+		value := x.Type_
+		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceTransition"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceTransition does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceTransition) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceTransition.block_height":
+		x.BlockHeight = value.Int()
+	case "inference.inference.MaintenanceTransition.reservation_id":
+		x.ReservationId = value.Uint()
+	case "inference.inference.MaintenanceTransition.type":
+		x.Type_ = (MaintenanceTransitionType)(value.Enum())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceTransition"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceTransition does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceTransition) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceTransition.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.MaintenanceTransition is not mutable"))
+	case "inference.inference.MaintenanceTransition.reservation_id":
+		panic(fmt.Errorf("field reservation_id of message inference.inference.MaintenanceTransition is not mutable"))
+	case "inference.inference.MaintenanceTransition.type":
+		panic(fmt.Errorf("field type of message inference.inference.MaintenanceTransition is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceTransition"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceTransition does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MaintenanceTransition) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceTransition.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.MaintenanceTransition.reservation_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceTransition.type":
+		return protoreflect.ValueOfEnum(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceTransition"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceTransition does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MaintenanceTransition) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MaintenanceTransition", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MaintenanceTransition) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceTransition) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MaintenanceTransition) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MaintenanceTransition) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MaintenanceTransition)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		}
+		if x.ReservationId != 0 {
+			n += 1 + runtime.Sov(uint64(x.ReservationId))
+		}
+		if x.Type_ != 0 {
+			n += 1 + runtime.Sov(uint64(x.Type_))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceTransition)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Type_ != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Type_))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.ReservationId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ReservationId))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceTransition)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceTransition: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceTransition: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				}
+				x.BlockHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.BlockHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+				}
+				x.ReservationId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ReservationId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Type_", wireType)
+				}
+				x.Type_ = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Type_ |= MaintenanceTransitionType(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: inference/inference/maintenance.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// MaintenanceReservationStatus represents the lifecycle status of a maintenance reservation.
+type MaintenanceReservationStatus int32
+
+const (
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED MaintenanceReservationStatus = 0
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED   MaintenanceReservationStatus = 1
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE      MaintenanceReservationStatus = 2
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_COMPLETED   MaintenanceReservationStatus = 3
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED    MaintenanceReservationStatus = 4
+)
+
+// Enum value maps for MaintenanceReservationStatus.
+var (
+	MaintenanceReservationStatus_name = map[int32]string{
+		0: "MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED",
+		1: "MAINTENANCE_RESERVATION_STATUS_SCHEDULED",
+		2: "MAINTENANCE_RESERVATION_STATUS_ACTIVE",
+		3: "MAINTENANCE_RESERVATION_STATUS_COMPLETED",
+		4: "MAINTENANCE_RESERVATION_STATUS_CANCELED",
+	}
+	MaintenanceReservationStatus_value = map[string]int32{
+		"MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED": 0,
+		"MAINTENANCE_RESERVATION_STATUS_SCHEDULED":   1,
+		"MAINTENANCE_RESERVATION_STATUS_ACTIVE":      2,
+		"MAINTENANCE_RESERVATION_STATUS_COMPLETED":   3,
+		"MAINTENANCE_RESERVATION_STATUS_CANCELED":    4,
+	}
+)
+
+func (x MaintenanceReservationStatus) Enum() *MaintenanceReservationStatus {
+	p := new(MaintenanceReservationStatus)
+	*p = x
+	return p
+}
+
+func (x MaintenanceReservationStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (MaintenanceReservationStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_inference_inference_maintenance_proto_enumTypes[0].Descriptor()
+}
+
+func (MaintenanceReservationStatus) Type() protoreflect.EnumType {
+	return &file_inference_inference_maintenance_proto_enumTypes[0]
+}
+
+func (x MaintenanceReservationStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use MaintenanceReservationStatus.Descriptor instead.
+func (MaintenanceReservationStatus) EnumDescriptor() ([]byte, []int) {
+	return file_inference_inference_maintenance_proto_rawDescGZIP(), []int{0}
+}
+
+// MaintenanceTransitionType represents the type of lifecycle transition at a given block height.
+type MaintenanceTransitionType int32
+
+const (
+	MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED MaintenanceTransitionType = 0
+	MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_ACTIVATE    MaintenanceTransitionType = 1
+	MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_COMPLETE    MaintenanceTransitionType = 2
+)
+
+// Enum value maps for MaintenanceTransitionType.
+var (
+	MaintenanceTransitionType_name = map[int32]string{
+		0: "MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED",
+		1: "MAINTENANCE_TRANSITION_TYPE_ACTIVATE",
+		2: "MAINTENANCE_TRANSITION_TYPE_COMPLETE",
+	}
+	MaintenanceTransitionType_value = map[string]int32{
+		"MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED": 0,
+		"MAINTENANCE_TRANSITION_TYPE_ACTIVATE":    1,
+		"MAINTENANCE_TRANSITION_TYPE_COMPLETE":    2,
+	}
+)
+
+func (x MaintenanceTransitionType) Enum() *MaintenanceTransitionType {
+	p := new(MaintenanceTransitionType)
+	*p = x
+	return p
+}
+
+func (x MaintenanceTransitionType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (MaintenanceTransitionType) Descriptor() protoreflect.EnumDescriptor {
+	return file_inference_inference_maintenance_proto_enumTypes[1].Descriptor()
+}
+
+func (MaintenanceTransitionType) Type() protoreflect.EnumType {
+	return &file_inference_inference_maintenance_proto_enumTypes[1]
+}
+
+func (x MaintenanceTransitionType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use MaintenanceTransitionType.Descriptor instead.
+func (MaintenanceTransitionType) EnumDescriptor() ([]byte, []int) {
+	return file_inference_inference_maintenance_proto_rawDescGZIP(), []int{1}
+}
+
+// MaintenanceReservation represents a scheduled maintenance window for a participant.
+type MaintenanceReservation struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ReservationId     uint64                       `protobuf:"varint,1,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+	Participant       string                       `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
+	StartHeight       int64                        `protobuf:"varint,3,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
+	DurationBlocks    uint64                       `protobuf:"varint,4,opt,name=duration_blocks,json=durationBlocks,proto3" json:"duration_blocks,omitempty"`
+	CreatedBy         string                       `protobuf:"bytes,5,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"`
+	Status            MaintenanceReservationStatus `protobuf:"varint,6,opt,name=status,proto3,enum=inference.inference.MaintenanceReservationStatus" json:"status,omitempty"`
+	ActivationWarning string                       `protobuf:"bytes,7,opt,name=activation_warning,json=activationWarning,proto3" json:"activation_warning,omitempty"`
+}
+
+func (x *MaintenanceReservation) Reset() {
+	*x = MaintenanceReservation{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_maintenance_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MaintenanceReservation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MaintenanceReservation) ProtoMessage() {}
+
+// Deprecated: Use MaintenanceReservation.ProtoReflect.Descriptor instead.
+func (*MaintenanceReservation) Descriptor() ([]byte, []int) {
+	return file_inference_inference_maintenance_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *MaintenanceReservation) GetReservationId() uint64 {
+	if x != nil {
+		return x.ReservationId
+	}
+	return 0
+}
+
+func (x *MaintenanceReservation) GetParticipant() string {
+	if x != nil {
+		return x.Participant
+	}
+	return ""
+}
+
+func (x *MaintenanceReservation) GetStartHeight() int64 {
+	if x != nil {
+		return x.StartHeight
+	}
+	return 0
+}
+
+func (x *MaintenanceReservation) GetDurationBlocks() uint64 {
+	if x != nil {
+		return x.DurationBlocks
+	}
+	return 0
+}
+
+func (x *MaintenanceReservation) GetCreatedBy() string {
+	if x != nil {
+		return x.CreatedBy
+	}
+	return ""
+}
+
+func (x *MaintenanceReservation) GetStatus() MaintenanceReservationStatus {
+	if x != nil {
+		return x.Status
+	}
+	return MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED
+}
+
+func (x *MaintenanceReservation) GetActivationWarning() string {
+	if x != nil {
+		return x.ActivationWarning
+	}
+	return ""
+}
+
+// MaintenanceState holds per-participant maintenance metadata, keyed by participant address.
+type MaintenanceState struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Participant  string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	CreditBlocks uint64 `protobuf:"varint,2,opt,name=credit_blocks,json=creditBlocks,proto3" json:"credit_blocks,omitempty"`
+	// Earliest epoch covered by the most recent maintenance window (set on
+	// activation). Combined with last_maintenance_end_epoch, defines the
+	// [start, end] range of epochs in which credit accrual is suppressed
+	// for the participant's most recent window.
+	LastMaintenanceEpoch   uint64 `protobuf:"varint,3,opt,name=last_maintenance_epoch,json=lastMaintenanceEpoch,proto3" json:"last_maintenance_epoch,omitempty"`
+	ActiveReservationId    uint64 `protobuf:"varint,4,opt,name=active_reservation_id,json=activeReservationId,proto3" json:"active_reservation_id,omitempty"`
+	ScheduledReservationId uint64 `protobuf:"varint,5,opt,name=scheduled_reservation_id,json=scheduledReservationId,proto3" json:"scheduled_reservation_id,omitempty"`
+	// Latest epoch covered by the most recent maintenance window. Set on
+	// completion (BeginBlock) to the epoch in which the window's last block
+	// fell. While the window is still active, this stays at the activation
+	// epoch and the active_reservation_id check covers the in-progress epochs.
+	LastMaintenanceEndEpoch uint64 `protobuf:"varint,6,opt,name=last_maintenance_end_epoch,json=lastMaintenanceEndEpoch,proto3" json:"last_maintenance_end_epoch,omitempty"`
+}
+
+func (x *MaintenanceState) Reset() {
+	*x = MaintenanceState{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_maintenance_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MaintenanceState) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MaintenanceState) ProtoMessage() {}
+
+// Deprecated: Use MaintenanceState.ProtoReflect.Descriptor instead.
+func (*MaintenanceState) Descriptor() ([]byte, []int) {
+	return file_inference_inference_maintenance_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *MaintenanceState) GetParticipant() string {
+	if x != nil {
+		return x.Participant
+	}
+	return ""
+}
+
+func (x *MaintenanceState) GetCreditBlocks() uint64 {
+	if x != nil {
+		return x.CreditBlocks
+	}
+	return 0
+}
+
+func (x *MaintenanceState) GetLastMaintenanceEpoch() uint64 {
+	if x != nil {
+		return x.LastMaintenanceEpoch
+	}
+	return 0
+}
+
+func (x *MaintenanceState) GetActiveReservationId() uint64 {
+	if x != nil {
+		return x.ActiveReservationId
+	}
+	return 0
+}
+
+func (x *MaintenanceState) GetScheduledReservationId() uint64 {
+	if x != nil {
+		return x.ScheduledReservationId
+	}
+	return 0
+}
+
+func (x *MaintenanceState) GetLastMaintenanceEndEpoch() uint64 {
+	if x != nil {
+		return x.LastMaintenanceEndEpoch
+	}
+	return 0
+}
+
+// MaintenanceTransition is an entry in the exact-height transition schedule for BeginBlock processing.
+type MaintenanceTransition struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	BlockHeight   int64                     `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	ReservationId uint64                    `protobuf:"varint,2,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+	Type_         MaintenanceTransitionType `protobuf:"varint,3,opt,name=type,proto3,enum=inference.inference.MaintenanceTransitionType" json:"type,omitempty"`
+}
+
+func (x *MaintenanceTransition) Reset() {
+	*x = MaintenanceTransition{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_maintenance_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MaintenanceTransition) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MaintenanceTransition) ProtoMessage() {}
+
+// Deprecated: Use MaintenanceTransition.ProtoReflect.Descriptor instead.
+func (*MaintenanceTransition) Descriptor() ([]byte, []int) {
+	return file_inference_inference_maintenance_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *MaintenanceTransition) GetBlockHeight() int64 {
+	if x != nil {
+		return x.BlockHeight
+	}
+	return 0
+}
+
+func (x *MaintenanceTransition) GetReservationId() uint64 {
+	if x != nil {
+		return x.ReservationId
+	}
+	return 0
+}
+
+func (x *MaintenanceTransition) GetType_() MaintenanceTransitionType {
+	if x != nil {
+		return x.Type_
+	}
+	return MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED
+}
+
+var File_inference_inference_maintenance_proto protoreflect.FileDescriptor
+
+var file_inference_inference_maintenance_proto_rawDesc = []byte{
+	0x0a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63,
+	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x22, 0xc6, 0x02, 0x0a,
+	0x16, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x65,
+	0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72,
+	0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x20,
+	0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x64, 0x75,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x1d, 0x0a, 0x0a,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x49, 0x0a, 0x06, 0x73,
+	0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73,
+	0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06,
+	0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x61, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x11, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x61,
+	0x72, 0x6e, 0x69, 0x6e, 0x67, 0x22, 0xba, 0x02, 0x0a, 0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d,
+	0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
+	0x73, 0x12, 0x34, 0x0a, 0x16, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x32, 0x0a, 0x15, 0x61, 0x63, 0x74, 0x69, 0x76,
+	0x65, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65,
+	0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x38, 0x0a, 0x18, 0x73,
+	0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, 0x73,
+	0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x1a, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61,
+	0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x17, 0x6c, 0x61, 0x73, 0x74, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x45, 0x6e, 0x64, 0x45, 0x70, 0x6f,
+	0x63, 0x68, 0x22, 0xa5, 0x01, 0x0a, 0x15, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c,
+	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+	0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x42, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x61, 0x69, 0x6e, 0x74,
+	0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+	0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x2a, 0x82, 0x02, 0x0a, 0x1c, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2e, 0x0a, 0x2a, 0x4d,
+	0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x52,
+	0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e,
+	0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x2c, 0x0a, 0x28, 0x4d,
+	0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x52,
+	0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x53, 0x43,
+	0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x44, 0x10, 0x01, 0x12, 0x29, 0x0a, 0x25, 0x4d, 0x41, 0x49,
+	0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41,
+	0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x41, 0x43, 0x54, 0x49,
+	0x56, 0x45, 0x10, 0x02, 0x12, 0x2c, 0x0a, 0x28, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41,
+	0x4e, 0x43, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f,
+	0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x44,
+	0x10, 0x03, 0x12, 0x2b, 0x0a, 0x27, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43,
+	0x45, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x54,
+	0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x10, 0x04, 0x2a,
+	0x9c, 0x01, 0x0a, 0x19, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x54,
+	0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2b, 0x0a,
+	0x27, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x54, 0x52, 0x41,
+	0x4e, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53,
+	0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x28, 0x0a, 0x24, 0x4d, 0x41,
+	0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x49,
+	0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x41,
+	0x54, 0x45, 0x10, 0x01, 0x12, 0x28, 0x0a, 0x24, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41,
+	0x4e, 0x43, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54,
+	0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x02, 0x42, 0xbe,
+	0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x10, 0x4d, 0x61, 0x69, 0x6e,
+	0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42,
+	0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_inference_inference_maintenance_proto_rawDescOnce sync.Once
+	file_inference_inference_maintenance_proto_rawDescData = file_inference_inference_maintenance_proto_rawDesc
+)
+
+func file_inference_inference_maintenance_proto_rawDescGZIP() []byte {
+	file_inference_inference_maintenance_proto_rawDescOnce.Do(func() {
+		file_inference_inference_maintenance_proto_rawDescData = protoimpl.X.CompressGZIP(file_inference_inference_maintenance_proto_rawDescData)
+	})
+	return file_inference_inference_maintenance_proto_rawDescData
+}
+
+var file_inference_inference_maintenance_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_inference_inference_maintenance_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_inference_inference_maintenance_proto_goTypes = []interface{}{
+	(MaintenanceReservationStatus)(0), // 0: inference.inference.MaintenanceReservationStatus
+	(MaintenanceTransitionType)(0),    // 1: inference.inference.MaintenanceTransitionType
+	(*MaintenanceReservation)(nil),    // 2: inference.inference.MaintenanceReservation
+	(*MaintenanceState)(nil),          // 3: inference.inference.MaintenanceState
+	(*MaintenanceTransition)(nil),     // 4: inference.inference.MaintenanceTransition
+}
+var file_inference_inference_maintenance_proto_depIdxs = []int32{
+	0, // 0: inference.inference.MaintenanceReservation.status:type_name -> inference.inference.MaintenanceReservationStatus
+	1, // 1: inference.inference.MaintenanceTransition.type:type_name -> inference.inference.MaintenanceTransitionType
+	2, // [2:2] is the sub-list for method output_type
+	2, // [2:2] is the sub-list for method input_type
+	2, // [2:2] is the sub-list for extension type_name
+	2, // [2:2] is the sub-list for extension extendee
+	0, // [0:2] is the sub-list for field type_name
+}
+
+func init() { file_inference_inference_maintenance_proto_init() }
+func file_inference_inference_maintenance_proto_init() {
+	if File_inference_inference_maintenance_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_inference_inference_maintenance_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MaintenanceReservation); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_maintenance_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MaintenanceState); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_maintenance_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MaintenanceTransition); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_inference_inference_maintenance_proto_rawDesc,
+			NumEnums:      2,
+			NumMessages:   3,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_inference_inference_maintenance_proto_goTypes,
+		DependencyIndexes: file_inference_inference_maintenance_proto_depIdxs,
+		EnumInfos:         file_inference_inference_maintenance_proto_enumTypes,
+		MessageInfos:      file_inference_inference_maintenance_proto_msgTypes,
+	}.Build()
+	File_inference_inference_maintenance_proto = out.File
+	file_inference_inference_maintenance_proto_rawDesc = nil
+	file_inference_inference_maintenance_proto_goTypes = nil
+	file_inference_inference_maintenance_proto_depIdxs = nil
+}
diff --git a/inference-chain/api/inference/inference/params.pulsar.go b/inference-chain/api/inference/inference/params.pulsar.go
index 2df95290db..9838fd4de7 100644
--- a/inference-chain/api/inference/inference/params.pulsar.go
+++ b/inference-chain/api/inference/inference/params.pulsar.go
@@ -33,6 +33,7 @@ var (
 	fd_Params_devshard_escrow_params       protoreflect.FieldDescriptor
 	fd_Params_fee_params                   protoreflect.FieldDescriptor
 	fd_Params_delegation_params            protoreflect.FieldDescriptor
+	fd_Params_maintenance_params           protoreflect.FieldDescriptor
 )
 
 func init() {
@@ -54,6 +55,7 @@ func init() {
 	fd_Params_devshard_escrow_params = md_Params.Fields().ByName("devshard_escrow_params")
 	fd_Params_fee_params = md_Params.Fields().ByName("fee_params")
 	fd_Params_delegation_params = md_Params.Fields().ByName("delegation_params")
+	fd_Params_maintenance_params = md_Params.Fields().ByName("maintenance_params")
 }
 
 var _ protoreflect.Message = (*fastReflection_Params)(nil)
@@ -217,6 +219,12 @@ func (x *fastReflection_Params) Range(f func(protoreflect.FieldDescriptor, proto
 			return
 		}
 	}
+	if x.MaintenanceParams != nil {
+		value := protoreflect.ValueOfMessage(x.MaintenanceParams.ProtoReflect())
+		if !f(fd_Params_maintenance_params, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -264,6 +272,8 @@ func (x *fastReflection_Params) Has(fd protoreflect.FieldDescriptor) bool {
 		return x.FeeParams != nil
 	case "inference.inference.Params.delegation_params":
 		return x.DelegationParams != nil
+	case "inference.inference.Params.maintenance_params":
+		return x.MaintenanceParams != nil
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
@@ -312,6 +322,8 @@ func (x *fastReflection_Params) Clear(fd protoreflect.FieldDescriptor) {
 		x.FeeParams = nil
 	case "inference.inference.Params.delegation_params":
 		x.DelegationParams = nil
+	case "inference.inference.Params.maintenance_params":
+		x.MaintenanceParams = nil
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
@@ -376,6 +388,9 @@ func (x *fastReflection_Params) Get(descriptor protoreflect.FieldDescriptor) pro
 	case "inference.inference.Params.delegation_params":
 		value := x.DelegationParams
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.Params.maintenance_params":
+		value := x.MaintenanceParams
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
@@ -428,6 +443,8 @@ func (x *fastReflection_Params) Set(fd protoreflect.FieldDescriptor, value proto
 		x.FeeParams = value.Message().Interface().(*FeeParams)
 	case "inference.inference.Params.delegation_params":
 		x.DelegationParams = value.Message().Interface().(*DelegationParams)
+	case "inference.inference.Params.maintenance_params":
+		x.MaintenanceParams = value.Message().Interface().(*MaintenanceParams)
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
@@ -528,6 +545,11 @@ func (x *fastReflection_Params) Mutable(fd protoreflect.FieldDescriptor) protore
 			x.DelegationParams = new(DelegationParams)
 		}
 		return protoreflect.ValueOfMessage(x.DelegationParams.ProtoReflect())
+	case "inference.inference.Params.maintenance_params":
+		if x.MaintenanceParams == nil {
+			x.MaintenanceParams = new(MaintenanceParams)
+		}
+		return protoreflect.ValueOfMessage(x.MaintenanceParams.ProtoReflect())
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
@@ -589,6 +611,9 @@ func (x *fastReflection_Params) NewField(fd protoreflect.FieldDescriptor) protor
 	case "inference.inference.Params.delegation_params":
 		m := new(DelegationParams)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.Params.maintenance_params":
+		m := new(MaintenanceParams)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Params"))
@@ -722,6 +747,10 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 			l = options.Size(x.DelegationParams)
 			n += 2 + l + runtime.Sov(uint64(l))
 		}
+		if x.MaintenanceParams != nil {
+			l = options.Size(x.MaintenanceParams)
+			n += 2 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -751,6 +780,22 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.MaintenanceParams != nil {
+			encoded, err := options.Marshal(x.MaintenanceParams)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1
+			i--
+			dAtA[i] = 0x8a
+		}
 		if x.DelegationParams != nil {
 			encoded, err := options.Marshal(x.DelegationParams)
 			if err != nil {
@@ -1390,7 +1435,843 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 				if wireType != 2 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DeveloperAccessParams", wireType)
 				}
-				var msglen int
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.DeveloperAccessParams == nil {
+					x.DeveloperAccessParams = &DeveloperAccessParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DeveloperAccessParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 12:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAccessParams", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.ParticipantAccessParams == nil {
+					x.ParticipantAccessParams = &ParticipantAccessParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantAccessParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 13:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TransferAgentAccessParams", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.TransferAgentAccessParams == nil {
+					x.TransferAgentAccessParams = &TransferAgentAccessParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TransferAgentAccessParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 14:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DevshardEscrowParams", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.DevshardEscrowParams == nil {
+					x.DevshardEscrowParams = &DevshardEscrowParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DevshardEscrowParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 15:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FeeParams", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.FeeParams == nil {
+					x.FeeParams = &FeeParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.FeeParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 16:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegationParams", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.DelegationParams == nil {
+					x.DelegationParams = &DelegationParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DelegationParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 17:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceParams", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.MaintenanceParams == nil {
+					x.MaintenanceParams = &MaintenanceParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MaintenanceParams); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MaintenanceParams                                                     protoreflect.MessageDescriptor
+	fd_MaintenanceParams_maintenance_enabled                                 protoreflect.FieldDescriptor
+	fd_MaintenanceParams_maintenance_min_schedule_lead_blocks                protoreflect.FieldDescriptor
+	fd_MaintenanceParams_maintenance_max_window_blocks                       protoreflect.FieldDescriptor
+	fd_MaintenanceParams_maintenance_max_concurrent_validators               protoreflect.FieldDescriptor
+	fd_MaintenanceParams_maintenance_max_concurrent_power_bps                protoreflect.FieldDescriptor
+	fd_MaintenanceParams_maintenance_credit_cap_blocks                       protoreflect.FieldDescriptor
+	fd_MaintenanceParams_maintenance_credit_earn_per_successful_epoch_blocks protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_params_proto_init()
+	md_MaintenanceParams = File_inference_inference_params_proto.Messages().ByName("MaintenanceParams")
+	fd_MaintenanceParams_maintenance_enabled = md_MaintenanceParams.Fields().ByName("maintenance_enabled")
+	fd_MaintenanceParams_maintenance_min_schedule_lead_blocks = md_MaintenanceParams.Fields().ByName("maintenance_min_schedule_lead_blocks")
+	fd_MaintenanceParams_maintenance_max_window_blocks = md_MaintenanceParams.Fields().ByName("maintenance_max_window_blocks")
+	fd_MaintenanceParams_maintenance_max_concurrent_validators = md_MaintenanceParams.Fields().ByName("maintenance_max_concurrent_validators")
+	fd_MaintenanceParams_maintenance_max_concurrent_power_bps = md_MaintenanceParams.Fields().ByName("maintenance_max_concurrent_power_bps")
+	fd_MaintenanceParams_maintenance_credit_cap_blocks = md_MaintenanceParams.Fields().ByName("maintenance_credit_cap_blocks")
+	fd_MaintenanceParams_maintenance_credit_earn_per_successful_epoch_blocks = md_MaintenanceParams.Fields().ByName("maintenance_credit_earn_per_successful_epoch_blocks")
+}
+
+var _ protoreflect.Message = (*fastReflection_MaintenanceParams)(nil)
+
+type fastReflection_MaintenanceParams MaintenanceParams
+
+func (x *MaintenanceParams) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MaintenanceParams)(x)
+}
+
+func (x *MaintenanceParams) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_params_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MaintenanceParams_messageType fastReflection_MaintenanceParams_messageType
+var _ protoreflect.MessageType = fastReflection_MaintenanceParams_messageType{}
+
+type fastReflection_MaintenanceParams_messageType struct{}
+
+func (x fastReflection_MaintenanceParams_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MaintenanceParams)(nil)
+}
+func (x fastReflection_MaintenanceParams_messageType) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceParams)
+}
+func (x fastReflection_MaintenanceParams_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceParams
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MaintenanceParams) Descriptor() protoreflect.MessageDescriptor {
+	return md_MaintenanceParams
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MaintenanceParams) Type() protoreflect.MessageType {
+	return _fastReflection_MaintenanceParams_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MaintenanceParams) New() protoreflect.Message {
+	return new(fastReflection_MaintenanceParams)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MaintenanceParams) Interface() protoreflect.ProtoMessage {
+	return (*MaintenanceParams)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MaintenanceParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.MaintenanceEnabled != false {
+		value := protoreflect.ValueOfBool(x.MaintenanceEnabled)
+		if !f(fd_MaintenanceParams_maintenance_enabled, value) {
+			return
+		}
+	}
+	if x.MaintenanceMinScheduleLeadBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.MaintenanceMinScheduleLeadBlocks)
+		if !f(fd_MaintenanceParams_maintenance_min_schedule_lead_blocks, value) {
+			return
+		}
+	}
+	if x.MaintenanceMaxWindowBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.MaintenanceMaxWindowBlocks)
+		if !f(fd_MaintenanceParams_maintenance_max_window_blocks, value) {
+			return
+		}
+	}
+	if x.MaintenanceMaxConcurrentValidators != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.MaintenanceMaxConcurrentValidators)
+		if !f(fd_MaintenanceParams_maintenance_max_concurrent_validators, value) {
+			return
+		}
+	}
+	if x.MaintenanceMaxConcurrentPowerBps != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.MaintenanceMaxConcurrentPowerBps)
+		if !f(fd_MaintenanceParams_maintenance_max_concurrent_power_bps, value) {
+			return
+		}
+	}
+	if x.MaintenanceCreditCapBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.MaintenanceCreditCapBlocks)
+		if !f(fd_MaintenanceParams_maintenance_credit_cap_blocks, value) {
+			return
+		}
+	}
+	if x.MaintenanceCreditEarnPerSuccessfulEpochBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.MaintenanceCreditEarnPerSuccessfulEpochBlocks)
+		if !f(fd_MaintenanceParams_maintenance_credit_earn_per_successful_epoch_blocks, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MaintenanceParams) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceParams.maintenance_enabled":
+		return x.MaintenanceEnabled != false
+	case "inference.inference.MaintenanceParams.maintenance_min_schedule_lead_blocks":
+		return x.MaintenanceMinScheduleLeadBlocks != uint64(0)
+	case "inference.inference.MaintenanceParams.maintenance_max_window_blocks":
+		return x.MaintenanceMaxWindowBlocks != uint64(0)
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_validators":
+		return x.MaintenanceMaxConcurrentValidators != uint32(0)
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_power_bps":
+		return x.MaintenanceMaxConcurrentPowerBps != uint32(0)
+	case "inference.inference.MaintenanceParams.maintenance_credit_cap_blocks":
+		return x.MaintenanceCreditCapBlocks != uint64(0)
+	case "inference.inference.MaintenanceParams.maintenance_credit_earn_per_successful_epoch_blocks":
+		return x.MaintenanceCreditEarnPerSuccessfulEpochBlocks != uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceParams"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceParams) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceParams.maintenance_enabled":
+		x.MaintenanceEnabled = false
+	case "inference.inference.MaintenanceParams.maintenance_min_schedule_lead_blocks":
+		x.MaintenanceMinScheduleLeadBlocks = uint64(0)
+	case "inference.inference.MaintenanceParams.maintenance_max_window_blocks":
+		x.MaintenanceMaxWindowBlocks = uint64(0)
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_validators":
+		x.MaintenanceMaxConcurrentValidators = uint32(0)
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_power_bps":
+		x.MaintenanceMaxConcurrentPowerBps = uint32(0)
+	case "inference.inference.MaintenanceParams.maintenance_credit_cap_blocks":
+		x.MaintenanceCreditCapBlocks = uint64(0)
+	case "inference.inference.MaintenanceParams.maintenance_credit_earn_per_successful_epoch_blocks":
+		x.MaintenanceCreditEarnPerSuccessfulEpochBlocks = uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceParams"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MaintenanceParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MaintenanceParams.maintenance_enabled":
+		value := x.MaintenanceEnabled
+		return protoreflect.ValueOfBool(value)
+	case "inference.inference.MaintenanceParams.maintenance_min_schedule_lead_blocks":
+		value := x.MaintenanceMinScheduleLeadBlocks
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceParams.maintenance_max_window_blocks":
+		value := x.MaintenanceMaxWindowBlocks
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_validators":
+		value := x.MaintenanceMaxConcurrentValidators
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_power_bps":
+		value := x.MaintenanceMaxConcurrentPowerBps
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.MaintenanceParams.maintenance_credit_cap_blocks":
+		value := x.MaintenanceCreditCapBlocks
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MaintenanceParams.maintenance_credit_earn_per_successful_epoch_blocks":
+		value := x.MaintenanceCreditEarnPerSuccessfulEpochBlocks
+		return protoreflect.ValueOfUint64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceParams"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceParams does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceParams.maintenance_enabled":
+		x.MaintenanceEnabled = value.Bool()
+	case "inference.inference.MaintenanceParams.maintenance_min_schedule_lead_blocks":
+		x.MaintenanceMinScheduleLeadBlocks = value.Uint()
+	case "inference.inference.MaintenanceParams.maintenance_max_window_blocks":
+		x.MaintenanceMaxWindowBlocks = value.Uint()
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_validators":
+		x.MaintenanceMaxConcurrentValidators = uint32(value.Uint())
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_power_bps":
+		x.MaintenanceMaxConcurrentPowerBps = uint32(value.Uint())
+	case "inference.inference.MaintenanceParams.maintenance_credit_cap_blocks":
+		x.MaintenanceCreditCapBlocks = value.Uint()
+	case "inference.inference.MaintenanceParams.maintenance_credit_earn_per_successful_epoch_blocks":
+		x.MaintenanceCreditEarnPerSuccessfulEpochBlocks = value.Uint()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceParams"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceParams.maintenance_enabled":
+		panic(fmt.Errorf("field maintenance_enabled of message inference.inference.MaintenanceParams is not mutable"))
+	case "inference.inference.MaintenanceParams.maintenance_min_schedule_lead_blocks":
+		panic(fmt.Errorf("field maintenance_min_schedule_lead_blocks of message inference.inference.MaintenanceParams is not mutable"))
+	case "inference.inference.MaintenanceParams.maintenance_max_window_blocks":
+		panic(fmt.Errorf("field maintenance_max_window_blocks of message inference.inference.MaintenanceParams is not mutable"))
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_validators":
+		panic(fmt.Errorf("field maintenance_max_concurrent_validators of message inference.inference.MaintenanceParams is not mutable"))
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_power_bps":
+		panic(fmt.Errorf("field maintenance_max_concurrent_power_bps of message inference.inference.MaintenanceParams is not mutable"))
+	case "inference.inference.MaintenanceParams.maintenance_credit_cap_blocks":
+		panic(fmt.Errorf("field maintenance_credit_cap_blocks of message inference.inference.MaintenanceParams is not mutable"))
+	case "inference.inference.MaintenanceParams.maintenance_credit_earn_per_successful_epoch_blocks":
+		panic(fmt.Errorf("field maintenance_credit_earn_per_successful_epoch_blocks of message inference.inference.MaintenanceParams is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceParams"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MaintenanceParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MaintenanceParams.maintenance_enabled":
+		return protoreflect.ValueOfBool(false)
+	case "inference.inference.MaintenanceParams.maintenance_min_schedule_lead_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceParams.maintenance_max_window_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_validators":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.MaintenanceParams.maintenance_max_concurrent_power_bps":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.MaintenanceParams.maintenance_credit_cap_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MaintenanceParams.maintenance_credit_earn_per_successful_epoch_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MaintenanceParams"))
+		}
+		panic(fmt.Errorf("message inference.inference.MaintenanceParams does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MaintenanceParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MaintenanceParams", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MaintenanceParams) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MaintenanceParams) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MaintenanceParams) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MaintenanceParams) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MaintenanceParams)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.MaintenanceEnabled {
+			n += 2
+		}
+		if x.MaintenanceMinScheduleLeadBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaintenanceMinScheduleLeadBlocks))
+		}
+		if x.MaintenanceMaxWindowBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaintenanceMaxWindowBlocks))
+		}
+		if x.MaintenanceMaxConcurrentValidators != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaintenanceMaxConcurrentValidators))
+		}
+		if x.MaintenanceMaxConcurrentPowerBps != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaintenanceMaxConcurrentPowerBps))
+		}
+		if x.MaintenanceCreditCapBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaintenanceCreditCapBlocks))
+		}
+		if x.MaintenanceCreditEarnPerSuccessfulEpochBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.MaintenanceCreditEarnPerSuccessfulEpochBlocks))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceParams)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.MaintenanceCreditEarnPerSuccessfulEpochBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaintenanceCreditEarnPerSuccessfulEpochBlocks))
+			i--
+			dAtA[i] = 0x38
+		}
+		if x.MaintenanceCreditCapBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaintenanceCreditCapBlocks))
+			i--
+			dAtA[i] = 0x30
+		}
+		if x.MaintenanceMaxConcurrentPowerBps != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaintenanceMaxConcurrentPowerBps))
+			i--
+			dAtA[i] = 0x28
+		}
+		if x.MaintenanceMaxConcurrentValidators != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaintenanceMaxConcurrentValidators))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.MaintenanceMaxWindowBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaintenanceMaxWindowBlocks))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.MaintenanceMinScheduleLeadBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.MaintenanceMinScheduleLeadBlocks))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.MaintenanceEnabled {
+			i--
+			if x.MaintenanceEnabled {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MaintenanceParams)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceParams: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MaintenanceParams: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceEnabled", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.MaintenanceEnabled = bool(v != 0)
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMinScheduleLeadBlocks", wireType)
+				}
+				x.MaintenanceMinScheduleLeadBlocks = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -1400,33 +2281,16 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.MaintenanceMinScheduleLeadBlocks |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.DeveloperAccessParams == nil {
-					x.DeveloperAccessParams = &DeveloperAccessParams{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DeveloperAccessParams); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 12:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAccessParams", wireType)
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMaxWindowBlocks", wireType)
 				}
-				var msglen int
+				x.MaintenanceMaxWindowBlocks = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -1436,33 +2300,16 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.MaintenanceMaxWindowBlocks |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.ParticipantAccessParams == nil {
-					x.ParticipantAccessParams = &ParticipantAccessParams{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantAccessParams); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 13:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TransferAgentAccessParams", wireType)
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMaxConcurrentValidators", wireType)
 				}
-				var msglen int
+				x.MaintenanceMaxConcurrentValidators = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -1472,33 +2319,16 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.MaintenanceMaxConcurrentValidators |= uint32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.TransferAgentAccessParams == nil {
-					x.TransferAgentAccessParams = &TransferAgentAccessParams{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TransferAgentAccessParams); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 14:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DevshardEscrowParams", wireType)
+			case 5:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMaxConcurrentPowerBps", wireType)
 				}
-				var msglen int
+				x.MaintenanceMaxConcurrentPowerBps = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -1508,33 +2338,16 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.MaintenanceMaxConcurrentPowerBps |= uint32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.DevshardEscrowParams == nil {
-					x.DevshardEscrowParams = &DevshardEscrowParams{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DevshardEscrowParams); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 15:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FeeParams", wireType)
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceCreditCapBlocks", wireType)
 				}
-				var msglen int
+				x.MaintenanceCreditCapBlocks = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -1544,33 +2357,16 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.MaintenanceCreditCapBlocks |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.FeeParams == nil {
-					x.FeeParams = &FeeParams{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.FeeParams); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 16:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DelegationParams", wireType)
+			case 7:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MaintenanceCreditEarnPerSuccessfulEpochBlocks", wireType)
 				}
-				var msglen int
+				x.MaintenanceCreditEarnPerSuccessfulEpochBlocks = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -1580,28 +2376,11 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.MaintenanceCreditEarnPerSuccessfulEpochBlocks |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.DelegationParams == nil {
-					x.DelegationParams = &DelegationParams{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.DelegationParams); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -1721,7 +2500,7 @@ func (x *GenesisOnlyParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *GenesisOnlyParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[1]
+	mi := &file_inference_inference_params_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2663,7 +3442,7 @@ func (x *TokenomicsParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *TokenomicsParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[2]
+	mi := &file_inference_inference_params_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -3372,7 +4151,7 @@ func (x *EpochParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *EpochParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[3]
+	mi := &file_inference_inference_params_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4501,7 +5280,7 @@ func (x *ValidationParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *ValidationParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[4]
+	mi := &file_inference_inference_params_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -6617,7 +7396,7 @@ func (x *PoCModelParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *PoCModelParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[5]
+	mi := &file_inference_inference_params_proto_msgTypes[6]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -7630,7 +8409,7 @@ func (x *PoCStatTestParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *PoCStatTestParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[6]
+	mi := &file_inference_inference_params_proto_msgTypes[7]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -8227,7 +9006,7 @@ func (x *PoCModelConfig) ProtoReflect() protoreflect.Message {
 }
 
 func (x *PoCModelConfig) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[7]
+	mi := &file_inference_inference_params_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -8970,7 +9749,7 @@ func (x *PocParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *PocParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[8]
+	mi := &file_inference_inference_params_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -10146,7 +10925,7 @@ func (x *Decimal) ProtoReflect() protoreflect.Message {
 }
 
 func (x *Decimal) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[9]
+	mi := &file_inference_inference_params_proto_msgTypes[10]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -10606,7 +11385,7 @@ func (x *CollateralParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *CollateralParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[10]
+	mi := &file_inference_inference_params_proto_msgTypes[11]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -11407,7 +12186,7 @@ func (x *BitcoinRewardParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *BitcoinRewardParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[11]
+	mi := &file_inference_inference_params_proto_msgTypes[12]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -12231,7 +13010,7 @@ func (x *DynamicPricingParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *DynamicPricingParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[12]
+	mi := &file_inference_inference_params_proto_msgTypes[13]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -13064,7 +13843,7 @@ func (x *BandwidthLimitsParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *BandwidthLimitsParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[13]
+	mi := &file_inference_inference_params_proto_msgTypes[14]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -13858,7 +14637,7 @@ func (x *ConfirmationPoCParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *ConfirmationPoCParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[14]
+	mi := &file_inference_inference_params_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -14512,7 +15291,7 @@ func (x *GenesisGuardianParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *GenesisGuardianParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[15]
+	mi := &file_inference_inference_params_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -15086,7 +15865,7 @@ func (x *DeveloperAccessParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *DeveloperAccessParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[16]
+	mi := &file_inference_inference_params_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -15618,7 +16397,7 @@ func (x *ParticipantAccessParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *ParticipantAccessParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[17]
+	mi := &file_inference_inference_params_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -16242,7 +17021,7 @@ func (x *TransferAgentAccessParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *TransferAgentAccessParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[18]
+	mi := &file_inference_inference_params_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -16692,7 +17471,7 @@ func (x *DelegationParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *DelegationParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[19]
+	mi := &file_inference_inference_params_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -17670,7 +18449,7 @@ func (x *DevshardApprovedVersion) ProtoReflect() protoreflect.Message {
 }
 
 func (x *DevshardApprovedVersion) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[20]
+	mi := &file_inference_inference_params_proto_msgTypes[21]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -18345,7 +19124,7 @@ func (x *DevshardEscrowParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *DevshardEscrowParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[21]
+	mi := &file_inference_inference_params_proto_msgTypes[22]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -19616,7 +20395,7 @@ func (x *FeeParams) ProtoReflect() protoreflect.Message {
 }
 
 func (x *FeeParams) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_params_proto_msgTypes[22]
+	mi := &file_inference_inference_params_proto_msgTypes[23]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -20126,7 +20905,12 @@ type Params struct {
 	TransferAgentAccessParams *TransferAgentAccessParams `protobuf:"bytes,13,opt,name=transfer_agent_access_params,json=transferAgentAccessParams,proto3" json:"transfer_agent_access_params,omitempty"`
 	DevshardEscrowParams      *DevshardEscrowParams      `protobuf:"bytes,14,opt,name=devshard_escrow_params,json=devshardEscrowParams,proto3" json:"devshard_escrow_params,omitempty"`
 	FeeParams                 *FeeParams                 `protobuf:"bytes,15,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"`
-	DelegationParams          *DelegationParams          `protobuf:"bytes,16,opt,name=delegation_params,json=delegationParams,proto3" json:"delegation_params,omitempty"`
+	// Field numbers 16 and 17 are wire-format-locked to match the upstream
+	// multi-model branch (which shipped delegation_params=16 first). Renumbering
+	// would silently lose DelegationParams from any chain that already stored
+	// params under field 16.
+	DelegationParams  *DelegationParams  `protobuf:"bytes,16,opt,name=delegation_params,json=delegationParams,proto3" json:"delegation_params,omitempty"`
+	MaintenanceParams *MaintenanceParams `protobuf:"bytes,17,opt,name=maintenance_params,json=maintenanceParams,proto3" json:"maintenance_params,omitempty"`
 }
 
 func (x *Params) Reset() {
@@ -20216,49 +21000,147 @@ func (x *Params) GetGenesisGuardianParams() *GenesisGuardianParams {
 	if x != nil {
 		return x.GenesisGuardianParams
 	}
-	return nil
+	return nil
+}
+
+func (x *Params) GetDeveloperAccessParams() *DeveloperAccessParams {
+	if x != nil {
+		return x.DeveloperAccessParams
+	}
+	return nil
+}
+
+func (x *Params) GetParticipantAccessParams() *ParticipantAccessParams {
+	if x != nil {
+		return x.ParticipantAccessParams
+	}
+	return nil
+}
+
+func (x *Params) GetTransferAgentAccessParams() *TransferAgentAccessParams {
+	if x != nil {
+		return x.TransferAgentAccessParams
+	}
+	return nil
+}
+
+func (x *Params) GetDevshardEscrowParams() *DevshardEscrowParams {
+	if x != nil {
+		return x.DevshardEscrowParams
+	}
+	return nil
+}
+
+func (x *Params) GetFeeParams() *FeeParams {
+	if x != nil {
+		return x.FeeParams
+	}
+	return nil
+}
+
+func (x *Params) GetDelegationParams() *DelegationParams {
+	if x != nil {
+		return x.DelegationParams
+	}
+	return nil
+}
+
+func (x *Params) GetMaintenanceParams() *MaintenanceParams {
+	if x != nil {
+		return x.MaintenanceParams
+	}
+	return nil
+}
+
+// MaintenanceParams defines the governance-controlled parameters for participant maintenance windows.
+type MaintenanceParams struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// maintenance_enabled enables or disables scheduling and activation of maintenance windows.
+	MaintenanceEnabled bool `protobuf:"varint,1,opt,name=maintenance_enabled,json=maintenanceEnabled,proto3" json:"maintenance_enabled,omitempty"`
+	// maintenance_min_schedule_lead_blocks is the minimum number of blocks between scheduling and start.
+	MaintenanceMinScheduleLeadBlocks uint64 `protobuf:"varint,2,opt,name=maintenance_min_schedule_lead_blocks,json=maintenanceMinScheduleLeadBlocks,proto3" json:"maintenance_min_schedule_lead_blocks,omitempty"`
+	// maintenance_max_window_blocks is the maximum duration of a single maintenance window.
+	MaintenanceMaxWindowBlocks uint64 `protobuf:"varint,3,opt,name=maintenance_max_window_blocks,json=maintenanceMaxWindowBlocks,proto3" json:"maintenance_max_window_blocks,omitempty"`
+	// maintenance_max_concurrent_validators is the maximum number of participants concurrently in maintenance.
+	MaintenanceMaxConcurrentValidators uint32 `protobuf:"varint,4,opt,name=maintenance_max_concurrent_validators,json=maintenanceMaxConcurrentValidators,proto3" json:"maintenance_max_concurrent_validators,omitempty"`
+	// maintenance_max_concurrent_power_bps is the maximum consensus power concurrently in maintenance (basis points).
+	MaintenanceMaxConcurrentPowerBps uint32 `protobuf:"varint,5,opt,name=maintenance_max_concurrent_power_bps,json=maintenanceMaxConcurrentPowerBps,proto3" json:"maintenance_max_concurrent_power_bps,omitempty"`
+	// maintenance_credit_cap_blocks is the maximum maintenance credit a participant may accumulate.
+	MaintenanceCreditCapBlocks uint64 `protobuf:"varint,6,opt,name=maintenance_credit_cap_blocks,json=maintenanceCreditCapBlocks,proto3" json:"maintenance_credit_cap_blocks,omitempty"`
+	// maintenance_credit_earn_per_successful_epoch_blocks is the number of credit blocks earned per successful epoch.
+	MaintenanceCreditEarnPerSuccessfulEpochBlocks uint64 `protobuf:"varint,7,opt,name=maintenance_credit_earn_per_successful_epoch_blocks,json=maintenanceCreditEarnPerSuccessfulEpochBlocks,proto3" json:"maintenance_credit_earn_per_successful_epoch_blocks,omitempty"`
+}
+
+func (x *MaintenanceParams) Reset() {
+	*x = MaintenanceParams{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_params_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MaintenanceParams) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MaintenanceParams) ProtoMessage() {}
+
+// Deprecated: Use MaintenanceParams.ProtoReflect.Descriptor instead.
+func (*MaintenanceParams) Descriptor() ([]byte, []int) {
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *MaintenanceParams) GetMaintenanceEnabled() bool {
+	if x != nil {
+		return x.MaintenanceEnabled
+	}
+	return false
 }
 
-func (x *Params) GetDeveloperAccessParams() *DeveloperAccessParams {
+func (x *MaintenanceParams) GetMaintenanceMinScheduleLeadBlocks() uint64 {
 	if x != nil {
-		return x.DeveloperAccessParams
+		return x.MaintenanceMinScheduleLeadBlocks
 	}
-	return nil
+	return 0
 }
 
-func (x *Params) GetParticipantAccessParams() *ParticipantAccessParams {
+func (x *MaintenanceParams) GetMaintenanceMaxWindowBlocks() uint64 {
 	if x != nil {
-		return x.ParticipantAccessParams
+		return x.MaintenanceMaxWindowBlocks
 	}
-	return nil
+	return 0
 }
 
-func (x *Params) GetTransferAgentAccessParams() *TransferAgentAccessParams {
+func (x *MaintenanceParams) GetMaintenanceMaxConcurrentValidators() uint32 {
 	if x != nil {
-		return x.TransferAgentAccessParams
+		return x.MaintenanceMaxConcurrentValidators
 	}
-	return nil
+	return 0
 }
 
-func (x *Params) GetDevshardEscrowParams() *DevshardEscrowParams {
+func (x *MaintenanceParams) GetMaintenanceMaxConcurrentPowerBps() uint32 {
 	if x != nil {
-		return x.DevshardEscrowParams
+		return x.MaintenanceMaxConcurrentPowerBps
 	}
-	return nil
+	return 0
 }
 
-func (x *Params) GetFeeParams() *FeeParams {
+func (x *MaintenanceParams) GetMaintenanceCreditCapBlocks() uint64 {
 	if x != nil {
-		return x.FeeParams
+		return x.MaintenanceCreditCapBlocks
 	}
-	return nil
+	return 0
 }
 
-func (x *Params) GetDelegationParams() *DelegationParams {
+func (x *MaintenanceParams) GetMaintenanceCreditEarnPerSuccessfulEpochBlocks() uint64 {
 	if x != nil {
-		return x.DelegationParams
+		return x.MaintenanceCreditEarnPerSuccessfulEpochBlocks
 	}
-	return nil
+	return 0
 }
 
 type GenesisOnlyParams struct {
@@ -20281,7 +21163,7 @@ type GenesisOnlyParams struct {
 func (x *GenesisOnlyParams) Reset() {
 	*x = GenesisOnlyParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[1]
+		mi := &file_inference_inference_params_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -20295,7 +21177,7 @@ func (*GenesisOnlyParams) ProtoMessage() {}
 
 // Deprecated: Use GenesisOnlyParams.ProtoReflect.Descriptor instead.
 func (*GenesisOnlyParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{1}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *GenesisOnlyParams) GetTotalSupply() int64 {
@@ -20383,7 +21265,7 @@ type TokenomicsParams struct {
 func (x *TokenomicsParams) Reset() {
 	*x = TokenomicsParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[2]
+		mi := &file_inference_inference_params_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -20397,7 +21279,7 @@ func (*TokenomicsParams) ProtoMessage() {}
 
 // Deprecated: Use TokenomicsParams.ProtoReflect.Descriptor instead.
 func (*TokenomicsParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{2}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{3}
 }
 
 func (x *TokenomicsParams) GetSubsidyReductionInterval() *Decimal {
@@ -20461,7 +21343,7 @@ type EpochParams struct {
 func (x *EpochParams) Reset() {
 	*x = EpochParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[3]
+		mi := &file_inference_inference_params_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -20475,7 +21357,7 @@ func (*EpochParams) ProtoMessage() {}
 
 // Deprecated: Use EpochParams.ProtoReflect.Descriptor instead.
 func (*EpochParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{3}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *EpochParams) GetEpochLength() int64 {
@@ -20620,7 +21502,7 @@ type ValidationParams struct {
 func (x *ValidationParams) Reset() {
 	*x = ValidationParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[4]
+		mi := &file_inference_inference_params_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -20634,7 +21516,7 @@ func (*ValidationParams) ProtoMessage() {}
 
 // Deprecated: Use ValidationParams.ProtoReflect.Descriptor instead.
 func (*ValidationParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{4}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{5}
 }
 
 func (x *ValidationParams) GetFalsePositiveRate() *Decimal {
@@ -20841,7 +21723,7 @@ type PoCModelParams struct {
 func (x *PoCModelParams) Reset() {
 	*x = PoCModelParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[5]
+		mi := &file_inference_inference_params_proto_msgTypes[6]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -20855,7 +21737,7 @@ func (*PoCModelParams) ProtoMessage() {}
 
 // Deprecated: Use PoCModelParams.ProtoReflect.Descriptor instead.
 func (*PoCModelParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{5}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{6}
 }
 
 func (x *PoCModelParams) GetDim() int32 {
@@ -20956,7 +21838,7 @@ type PoCStatTestParams struct {
 func (x *PoCStatTestParams) Reset() {
 	*x = PoCStatTestParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[6]
+		mi := &file_inference_inference_params_proto_msgTypes[7]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -20970,7 +21852,7 @@ func (*PoCStatTestParams) ProtoMessage() {}
 
 // Deprecated: Use PoCStatTestParams.ProtoReflect.Descriptor instead.
 func (*PoCStatTestParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{6}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{7}
 }
 
 func (x *PoCStatTestParams) GetDistThreshold() *Decimal {
@@ -21009,7 +21891,7 @@ type PoCModelConfig struct {
 func (x *PoCModelConfig) Reset() {
 	*x = PoCModelConfig{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[7]
+		mi := &file_inference_inference_params_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21023,7 +21905,7 @@ func (*PoCModelConfig) ProtoMessage() {}
 
 // Deprecated: Use PoCModelConfig.ProtoReflect.Descriptor instead.
 func (*PoCModelConfig) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{7}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *PoCModelConfig) GetModelId() string {
@@ -21090,7 +21972,7 @@ type PocParams struct {
 func (x *PocParams) Reset() {
 	*x = PocParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[8]
+		mi := &file_inference_inference_params_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21104,7 +21986,7 @@ func (*PocParams) ProtoMessage() {}
 
 // Deprecated: Use PocParams.ProtoReflect.Descriptor instead.
 func (*PocParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{8}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{9}
 }
 
 func (x *PocParams) GetDefaultDifficulty() int32 {
@@ -21222,7 +22104,7 @@ type Decimal struct {
 func (x *Decimal) Reset() {
 	*x = Decimal{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[9]
+		mi := &file_inference_inference_params_proto_msgTypes[10]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21236,7 +22118,7 @@ func (*Decimal) ProtoMessage() {}
 
 // Deprecated: Use Decimal.ProtoReflect.Descriptor instead.
 func (*Decimal) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{9}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{10}
 }
 
 func (x *Decimal) GetValue() int64 {
@@ -21275,7 +22157,7 @@ type CollateralParams struct {
 func (x *CollateralParams) Reset() {
 	*x = CollateralParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[10]
+		mi := &file_inference_inference_params_proto_msgTypes[11]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21289,7 +22171,7 @@ func (*CollateralParams) ProtoMessage() {}
 
 // Deprecated: Use CollateralParams.ProtoReflect.Descriptor instead.
 func (*CollateralParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{10}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{11}
 }
 
 func (x *CollateralParams) GetSlashFractionInvalid() *Decimal {
@@ -21359,7 +22241,7 @@ type BitcoinRewardParams struct {
 func (x *BitcoinRewardParams) Reset() {
 	*x = BitcoinRewardParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[11]
+		mi := &file_inference_inference_params_proto_msgTypes[12]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21373,7 +22255,7 @@ func (*BitcoinRewardParams) ProtoMessage() {}
 
 // Deprecated: Use BitcoinRewardParams.ProtoReflect.Descriptor instead.
 func (*BitcoinRewardParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{11}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *BitcoinRewardParams) GetUseBitcoinRewards() bool {
@@ -21452,7 +22334,7 @@ type DynamicPricingParams struct {
 func (x *DynamicPricingParams) Reset() {
 	*x = DynamicPricingParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[12]
+		mi := &file_inference_inference_params_proto_msgTypes[13]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21466,7 +22348,7 @@ func (*DynamicPricingParams) ProtoMessage() {}
 
 // Deprecated: Use DynamicPricingParams.ProtoReflect.Descriptor instead.
 func (*DynamicPricingParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{12}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{13}
 }
 
 func (x *DynamicPricingParams) GetStabilityZoneLowerBound() *Decimal {
@@ -21553,7 +22435,7 @@ type BandwidthLimitsParams struct {
 func (x *BandwidthLimitsParams) Reset() {
 	*x = BandwidthLimitsParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[13]
+		mi := &file_inference_inference_params_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21567,7 +22449,7 @@ func (*BandwidthLimitsParams) ProtoMessage() {}
 
 // Deprecated: Use BandwidthLimitsParams.ProtoReflect.Descriptor instead.
 func (*BandwidthLimitsParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{13}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{14}
 }
 
 func (x *BandwidthLimitsParams) GetEstimatedLimitsPerBlockKb() uint64 {
@@ -21645,7 +22527,7 @@ type ConfirmationPoCParams struct {
 func (x *ConfirmationPoCParams) Reset() {
 	*x = ConfirmationPoCParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[14]
+		mi := &file_inference_inference_params_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21659,7 +22541,7 @@ func (*ConfirmationPoCParams) ProtoMessage() {}
 
 // Deprecated: Use ConfirmationPoCParams.ProtoReflect.Descriptor instead.
 func (*ConfirmationPoCParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{14}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{15}
 }
 
 func (x *ConfirmationPoCParams) GetExpectedConfirmationsPerEpoch() uint64 {
@@ -21706,7 +22588,7 @@ type GenesisGuardianParams struct {
 func (x *GenesisGuardianParams) Reset() {
 	*x = GenesisGuardianParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[15]
+		mi := &file_inference_inference_params_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21720,7 +22602,7 @@ func (*GenesisGuardianParams) ProtoMessage() {}
 
 // Deprecated: Use GenesisGuardianParams.ProtoReflect.Descriptor instead.
 func (*GenesisGuardianParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{15}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *GenesisGuardianParams) GetNetworkMaturityThreshold() int64 {
@@ -21759,7 +22641,7 @@ type DeveloperAccessParams struct {
 func (x *DeveloperAccessParams) Reset() {
 	*x = DeveloperAccessParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[16]
+		mi := &file_inference_inference_params_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21773,7 +22655,7 @@ func (*DeveloperAccessParams) ProtoMessage() {}
 
 // Deprecated: Use DeveloperAccessParams.ProtoReflect.Descriptor instead.
 func (*DeveloperAccessParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{16}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *DeveloperAccessParams) GetUntilBlockHeight() int64 {
@@ -21821,7 +22703,7 @@ type ParticipantAccessParams struct {
 func (x *ParticipantAccessParams) Reset() {
 	*x = ParticipantAccessParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[17]
+		mi := &file_inference_inference_params_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21835,7 +22717,7 @@ func (*ParticipantAccessParams) ProtoMessage() {}
 
 // Deprecated: Use ParticipantAccessParams.ProtoReflect.Descriptor instead.
 func (*ParticipantAccessParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{17}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{18}
 }
 
 func (x *ParticipantAccessParams) GetNewParticipantRegistrationStartHeight() int64 {
@@ -21881,7 +22763,7 @@ type TransferAgentAccessParams struct {
 func (x *TransferAgentAccessParams) Reset() {
 	*x = TransferAgentAccessParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[18]
+		mi := &file_inference_inference_params_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21895,7 +22777,7 @@ func (*TransferAgentAccessParams) ProtoMessage() {}
 
 // Deprecated: Use TransferAgentAccessParams.ProtoReflect.Descriptor instead.
 func (*TransferAgentAccessParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{18}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{19}
 }
 
 func (x *TransferAgentAccessParams) GetAllowedTransferAddresses() []string {
@@ -21929,7 +22811,7 @@ type DelegationParams struct {
 func (x *DelegationParams) Reset() {
 	*x = DelegationParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[19]
+		mi := &file_inference_inference_params_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -21943,7 +22825,7 @@ func (*DelegationParams) ProtoMessage() {}
 
 // Deprecated: Use DelegationParams.ProtoReflect.Descriptor instead.
 func (*DelegationParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{19}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{20}
 }
 
 func (x *DelegationParams) GetDeployWindow() int64 {
@@ -22026,7 +22908,7 @@ type DevshardApprovedVersion struct {
 func (x *DevshardApprovedVersion) Reset() {
 	*x = DevshardApprovedVersion{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[20]
+		mi := &file_inference_inference_params_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -22040,7 +22922,7 @@ func (*DevshardApprovedVersion) ProtoMessage() {}
 
 // Deprecated: Use DevshardApprovedVersion.ProtoReflect.Descriptor instead.
 func (*DevshardApprovedVersion) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{20}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{21}
 }
 
 func (x *DevshardApprovedVersion) GetName() string {
@@ -22093,7 +22975,7 @@ type DevshardEscrowParams struct {
 func (x *DevshardEscrowParams) Reset() {
 	*x = DevshardEscrowParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[21]
+		mi := &file_inference_inference_params_proto_msgTypes[22]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -22107,7 +22989,7 @@ func (*DevshardEscrowParams) ProtoMessage() {}
 
 // Deprecated: Use DevshardEscrowParams.ProtoReflect.Descriptor instead.
 func (*DevshardEscrowParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{21}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{22}
 }
 
 func (x *DevshardEscrowParams) GetMinAmount() uint64 {
@@ -22254,7 +23136,7 @@ type FeeParams struct {
 func (x *FeeParams) Reset() {
 	*x = FeeParams{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_params_proto_msgTypes[22]
+		mi := &file_inference_inference_params_proto_msgTypes[23]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -22268,7 +23150,7 @@ func (*FeeParams) ProtoMessage() {}
 
 // Deprecated: Use FeeParams.ProtoReflect.Descriptor instead.
 func (*FeeParams) Descriptor() ([]byte, []int) {
-	return file_inference_inference_params_proto_rawDescGZIP(), []int{22}
+	return file_inference_inference_params_proto_rawDescGZIP(), []int{23}
 }
 
 func (x *FeeParams) GetMinGasPriceNgonka() uint64 {
@@ -22302,7 +23184,7 @@ var file_inference_inference_params_proto_rawDesc = []byte{
 	0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f,
 	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
 	0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63,
-	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe3, 0x0b, 0x0a, 0x06,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xba, 0x0c, 0x0a, 0x06,
 	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
 	0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
@@ -22393,707 +23275,747 @@ var file_inference_inference_params_proto_rawDesc = []byte{
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61,
 	0x6d, 0x73, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61,
-	0x72, 0x61, 0x6d, 0x73, 0x3a, 0x25, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x1c, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x14, 0x73, 0x75, 0x62,
-	0x6e, 0x65, 0x74, 0x5f, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d,
-	0x73, 0x22, 0xb4, 0x06, 0x0a, 0x11, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x4f, 0x6e, 0x6c,
-	0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c,
-	0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74,
-	0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x72,
-	0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f,
-	0x72, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x34, 0x0a, 0x16, 0x73, 0x74, 0x61, 0x6e, 0x64,
-	0x61, 0x72, 0x64, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
-	0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72,
-	0x64, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3b, 0x0a,
-	0x1a, 0x70, 0x72, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x65, 0x64, 0x5f,
-	0x73, 0x61, 0x6c, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x17, 0x70, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x65, 0x64,
-	0x53, 0x61, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x75,
-	0x70, 0x70, 0x6c, 0x79, 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0b, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x63, 0x0a,
-	0x1f, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x5f,
-	0x70, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65,
-	0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1c, 0x6d, 0x61, 0x78, 0x49, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64,
-	0x75, 0x61, 0x6c, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61,
-	0x67, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x67, 0x75,
-	0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x0d,
-	0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75, 0x61,
-	0x72, 0x64, 0x69, 0x61, 0x6e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x5c, 0x0a, 0x2b,
-	0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e,
-	0x5f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74,
-	0x79, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x27, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75, 0x61, 0x72, 0x64, 0x69,
-	0x61, 0x6e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74,
-	0x79, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x5c, 0x0a, 0x1b, 0x67, 0x65,
-	0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x6d,
-	0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x72, 0x61, 0x6d, 0x73, 0x12, 0x55, 0x0a, 0x12, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x11, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x25, 0xe8, 0xa0, 0x1f,
+	0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x1c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x78, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x52, 0x14, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x5f, 0x65, 0x73, 0x63, 0x72, 0x6f,
+	0x77, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0xaf, 0x04, 0x0a, 0x11, 0x4d, 0x61, 0x69,
+	0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2f,
+	0x0a, 0x13, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x65, 0x6e,
+	0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x6d, 0x61, 0x69,
+	0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12,
+	0x4e, 0x0a, 0x24, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d,
+	0x69, 0x6e, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x6c, 0x65, 0x61, 0x64,
+	0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x20, 0x6d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x69, 0x6e, 0x53, 0x63, 0x68,
+	0x65, 0x64, 0x75, 0x6c, 0x65, 0x4c, 0x65, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12,
+	0x41, 0x0a, 0x1d, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d,
+	0x61, 0x78, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1a, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x4d, 0x61, 0x78, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x42, 0x6c, 0x6f, 0x63,
+	0x6b, 0x73, 0x12, 0x51, 0x0a, 0x25, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63,
+	0x65, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+	0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x0d, 0x52, 0x22, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x61,
+	0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72,
+	0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x62, 0x70, 0x73, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65,
+	0x4d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x77,
+	0x65, 0x72, 0x42, 0x70, 0x73, 0x12, 0x41, 0x0a, 0x1d, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x5f, 0x63, 0x61, 0x70, 0x5f,
+	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1a, 0x6d, 0x61,
+	0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x43,
+	0x61, 0x70, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x6a, 0x0a, 0x33, 0x6d, 0x61, 0x69, 0x6e,
+	0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x5f, 0x65,
+	0x61, 0x72, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66,
+	0x75, 0x6c, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x2d, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x45, 0x61, 0x72, 0x6e, 0x50, 0x65, 0x72, 0x53,
+	0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x6c,
+	0x6f, 0x63, 0x6b, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xb4, 0x06, 0x0a, 0x11, 0x47,
+	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70,
+	0x70, 0x6c, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f,
+	0x72, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10,
+	0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79,
+	0x12, 0x34, 0x0a, 0x16, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x65, 0x77,
+	0x61, 0x72, 0x64, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x14, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64,
+	0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x1a, 0x70, 0x72, 0x65, 0x5f, 0x70, 0x72,
+	0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x65, 0x64, 0x5f, 0x73, 0x61, 0x6c, 0x65, 0x5f, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x70, 0x72, 0x65, 0x50,
+	0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x6d, 0x65, 0x64, 0x53, 0x61, 0x6c, 0x65, 0x41, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x64, 0x65,
+	0x6e, 0x6f, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x75, 0x70, 0x70, 0x6c,
+	0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x63, 0x0a, 0x1f, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x6e,
+	0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x70,
+	0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32,
 	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x19, 0x67,
-	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x4d, 0x75,
-	0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x1a, 0x67, 0x65, 0x6e, 0x65,
-	0x73, 0x69, 0x73, 0x5f, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x61, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x18, 0x67, 0x65,
-	0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x4a, 0x04, 0x08, 0x06,
-	0x10, 0x07, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09, 0x4a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x4a, 0x04,
-	0x08, 0x0a, 0x10, 0x0b, 0x4a, 0x04, 0x08, 0x0b, 0x10, 0x0c, 0x52, 0x11, 0x74, 0x6f, 0x70, 0x5f,
-	0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x0b, 0x74,
-	0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x11, 0x74, 0x6f, 0x70, 0x5f,
-	0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x12, 0x74,
-	0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74,
-	0x73, 0x52, 0x1c, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x61,
-	0x79, 0x6f, 0x75, 0x74, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x52,
-	0x17, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x6d, 0x61, 0x78, 0x5f,
-	0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xf1, 0x03, 0x0a, 0x10, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x5a, 0x0a,
-	0x1a, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64, 0x79, 0x5f, 0x72, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52,
-	0x18, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64, 0x79, 0x52, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x56, 0x0a, 0x18, 0x73, 0x75, 0x62,
-	0x73, 0x69, 0x64, 0x79, 0x5f, 0x72, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x73, 0x75, 0x62, 0x73, 0x69,
-	0x64, 0x79, 0x52, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6d, 0x6f, 0x75, 0x6e,
-	0x74, 0x12, 0x5a, 0x0a, 0x1a, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x75, 0x62,
-	0x73, 0x69, 0x64, 0x79, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x52, 0x18, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x62, 0x73,
-	0x69, 0x64, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a,
-	0x13, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x76, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65,
-	0x72, 0x69, 0x6f, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b,
-	0x56, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x32, 0x0a,
-	0x15, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x76, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f,
-	0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x72, 0x65,
-	0x77, 0x61, 0x72, 0x64, 0x56, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f,
-	0x64, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, 0x08,
-	0x05, 0x10, 0x06, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09, 0x52, 0x1a, 0x74, 0x6f, 0x70, 0x5f, 0x72,
-	0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x66, 0x61,
-	0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x1b, 0x74, 0x6f, 0x70, 0x5f, 0x6d, 0x69, 0x6e, 0x65, 0x72,
-	0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x18, 0x74, 0x6f, 0x70, 0x5f, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x76, 0x65,
-	0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xc7, 0x06, 0x0a,
-	0x0b, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x0a, 0x0c,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12,
-	0x29, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c,
-	0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x5f, 0x73, 0x68, 0x69, 0x66, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52,
-	0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x68, 0x69, 0x66, 0x74, 0x12, 0x40, 0x0a, 0x1d, 0x64,
-	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x5f, 0x6f, 0x66, 0x5f, 0x63,
-	0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x19, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f,
-	0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2c, 0x0a,
-	0x12, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x70, 0x6f, 0x63, 0x53, 0x74,
-	0x61, 0x67, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x15, 0x70,
-	0x6f, 0x63, 0x5f, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x13,
-	0x70, 0x6f, 0x63, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x12, 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x36, 0x0a, 0x17, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a,
-	0x18, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x65, 0x77, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x6f, 0x72, 0x73, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52,
-	0x15, 0x73, 0x65, 0x74, 0x4e, 0x65, 0x77, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
-	0x73, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63,
-	0x75, 0x74, 0x6f, 0x66, 0x66, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x19, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x43, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x12, 0x49, 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x1e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x75, 0x6e,
-	0x69, 0x6e, 0x67, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c,
-	0x64, 0x12, 0x32, 0x0a, 0x15, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x70,
-	0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03,
-	0x52, 0x13, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x75, 0x6e, 0x69,
-	0x6e, 0x67, 0x4d, 0x61, 0x78, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x6f, 0x63, 0x5f, 0x70, 0x72, 0x75,
-	0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d,
-	0x70, 0x6f, 0x63, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x78, 0x12, 0x4c, 0x0a,
-	0x13, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x11, 0x70, 0x6f, 0x63, 0x53, 0x6c, 0x6f,
-	0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, 0x1e, 0x63,
-	0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f,
-	0x73, 0x61, 0x66, 0x65, 0x74, 0x79, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x18, 0x0f, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x1b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x50, 0x6f, 0x63, 0x53, 0x61, 0x66, 0x65, 0x74, 0x79, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77,
-	0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xed, 0x0e, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x4c, 0x0a, 0x13, 0x66,
-	0x61, 0x6c, 0x73, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x72, 0x61,
-	0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1c, 0x6d,
+	0x61, 0x78, 0x49, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x50, 0x6f, 0x77, 0x65,
+	0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x67,
+	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f,
+	0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x67,
+	0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x45, 0x6e,
+	0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x5c, 0x0a, 0x2b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+	0x5f, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72,
+	0x6b, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73,
+	0x68, 0x6f, 0x6c, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x27, 0x67, 0x65, 0x6e, 0x65,
+	0x73, 0x69, 0x73, 0x47, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x4e, 0x65, 0x74, 0x77, 0x6f,
+	0x72, 0x6b, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68,
+	0x6f, 0x6c, 0x64, 0x12, 0x5c, 0x0a, 0x1b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x67,
+	0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69,
+	0x65, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
-	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x11, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x50, 0x6f, 0x73,
-	0x69, 0x74, 0x69, 0x76, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x18, 0x6d, 0x69, 0x6e,
-	0x5f, 0x72, 0x61, 0x6d, 0x70, 0x5f, 0x75, 0x70, 0x5f, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65,
-	0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x6d, 0x69, 0x6e,
-	0x52, 0x61, 0x6d, 0x70, 0x55, 0x70, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e,
-	0x74, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x70, 0x61, 0x73, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x70, 0x61, 0x73, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12,
-	0x52, 0x0a, 0x16, 0x6d, 0x69, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x6d,
-	0x69, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72,
-	0x61, 0x67, 0x65, 0x12, 0x52, 0x0a, 0x16, 0x6d, 0x61, 0x78, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x52, 0x14, 0x6d, 0x61, 0x78, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x65, 0x78, 0x70, 0x69, 0x72,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x06, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x10, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x74,
-	0x6f, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x73, 0x54, 0x6f, 0x4d, 0x61, 0x78, 0x12, 0x43, 0x0a, 0x1e, 0x66, 0x75, 0x6c, 0x6c,
-	0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x72, 0x61, 0x66,
-	0x66, 0x69, 0x63, 0x5f, 0x63, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03,
-	0x52, 0x1b, 0x66, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x43, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x12, 0x52, 0x0a,
-	0x16, 0x6d, 0x69, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
-	0x68, 0x61, 0x6c, 0x66, 0x77, 0x61, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x6d, 0x69, 0x6e,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x6c, 0x66, 0x77, 0x61,
-	0x79, 0x12, 0x41, 0x0a, 0x1d, 0x6d, 0x69, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x63, 0x75, 0x74, 0x6f,
-	0x66, 0x66, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x1a, 0x6d, 0x69, 0x6e, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x43, 0x75,
-	0x74, 0x6f, 0x66, 0x66, 0x12, 0x52, 0x0a, 0x16, 0x6d, 0x69, 0x73, 0x73, 0x5f, 0x70, 0x65, 0x72,
-	0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x18, 0x0b,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x19, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47,
+	0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65,
+	0x72, 0x12, 0x3c, 0x0a, 0x1a, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x67, 0x75, 0x61,
+	0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18,
+	0x10, 0x20, 0x03, 0x28, 0x09, 0x52, 0x18, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75,
+	0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x4a,
+	0x04, 0x08, 0x03, 0x10, 0x04, 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, 0x04, 0x08, 0x08, 0x10,
+	0x09, 0x4a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x4a, 0x04, 0x08, 0x0a, 0x10, 0x0b, 0x4a, 0x04, 0x08,
+	0x0b, 0x10, 0x0c, 0x52, 0x11, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f,
+	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x0b, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61,
+	0x72, 0x64, 0x73, 0x52, 0x11, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f,
+	0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x12, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61,
+	0x72, 0x64, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x73, 0x52, 0x1c, 0x74, 0x6f, 0x70, 0x5f,
+	0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x73, 0x5f, 0x70,
+	0x65, 0x72, 0x5f, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x52, 0x17, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65,
+	0x77, 0x61, 0x72, 0x64, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x22, 0xf1, 0x03, 0x0a, 0x10, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73,
+	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x5a, 0x0a, 0x1a, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64,
+	0x79, 0x5f, 0x72, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65,
+	0x72, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x18, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64,
+	0x79, 0x52, 0x65, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76,
+	0x61, 0x6c, 0x12, 0x56, 0x0a, 0x18, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64, 0x79, 0x5f, 0x72, 0x65,
+	0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02,
 	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d,
-	0x61, 0x6c, 0x52, 0x14, 0x6d, 0x69, 0x73, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61,
-	0x67, 0x65, 0x43, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x12, 0x50, 0x0a, 0x15, 0x6d, 0x69, 0x73, 0x73,
-	0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74,
-	0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
-	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x13, 0x6d, 0x69, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x73, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x12, 0x31, 0x0a, 0x14, 0x74, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
-	0x61, 0x6d, 0x70, 0x45, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x0a,
-	0x11, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x61, 0x64, 0x76, 0x61, 0x6e,
-	0x63, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
-	0x61, 0x6d, 0x70, 0x41, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x40, 0x0a, 0x1d, 0x65, 0x73,
-	0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x70,
-	0x65, 0x72, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6b, 0x62, 0x18, 0x0f, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x19, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69, 0x6d, 0x69,
-	0x74, 0x73, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4b, 0x62, 0x12, 0x5c, 0x0a, 0x1b,
-	0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28,
+	0x61, 0x6c, 0x52, 0x16, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64, 0x79, 0x52, 0x65, 0x64, 0x75, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x5a, 0x0a, 0x1a, 0x63, 0x75,
+	0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x69, 0x64, 0x79, 0x5f, 0x70, 0x65,
+	0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x18, 0x63, 0x75,
+	0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x62, 0x73, 0x69, 0x64, 0x79, 0x50, 0x65, 0x72, 0x63,
+	0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x76,
+	0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x56, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67,
+	0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x32, 0x0a, 0x15, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64,
+	0x5f, 0x76, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18,
+	0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x56, 0x65, 0x73,
+	0x74, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01,
+	0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, 0x04, 0x08, 0x05, 0x10, 0x06, 0x4a, 0x04, 0x08, 0x08,
+	0x10, 0x09, 0x52, 0x1a, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x61,
+	0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x1b,
+	0x74, 0x6f, 0x70, 0x5f, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x71, 0x75,
+	0x61, 0x6c, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x18, 0x74, 0x6f, 0x70,
+	0x5f, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x5f, 0x76, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70,
+	0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xc7, 0x06, 0x0a, 0x0b, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50,
+	0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x6c,
+	0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x65, 0x70, 0x6f,
+	0x63, 0x68, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c,
+	0x69, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x73, 0x68, 0x69,
+	0x66, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x53,
+	0x68, 0x69, 0x66, 0x74, 0x12, 0x40, 0x0a, 0x1d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
+	0x75, 0x6e, 0x69, 0x74, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x5f,
+	0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x19, 0x64, 0x65, 0x66,
+	0x61, 0x75, 0x6c, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74,
+	0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74,
+	0x61, 0x67, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x10, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x44, 0x75, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x15, 0x70, 0x6f, 0x63, 0x5f, 0x65, 0x78, 0x63, 0x68,
+	0x61, 0x6e, 0x67, 0x65, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x13, 0x70, 0x6f, 0x63, 0x45, 0x78, 0x63, 0x68,
+	0x61, 0x6e, 0x67, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x14,
+	0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64,
+	0x65, 0x6c, 0x61, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x70, 0x6f, 0x63, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x36,
+	0x0a, 0x17, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x15, 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x75,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x18, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x65,
+	0x77, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x64, 0x65, 0x6c,
+	0x61, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x73, 0x65, 0x74, 0x4e, 0x65, 0x77,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12,
+	0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x18, 0x0a,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x19, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x12,
+	0x49, 0x0a, 0x21, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x72, 0x75,
+	0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73,
+	0x68, 0x6f, 0x6c, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x45, 0x70, 0x6f, 0x63,
+	0x68, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x32, 0x0a, 0x15, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x5f,
+	0x6d, 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x78, 0x12, 0x26,
+	0x0a, 0x0f, 0x70, 0x6f, 0x63, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x61,
+	0x78, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x70, 0x6f, 0x63, 0x50, 0x72, 0x75, 0x6e,
+	0x69, 0x6e, 0x67, 0x4d, 0x61, 0x78, 0x12, 0x4c, 0x0a, 0x13, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x6c,
+	0x6f, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61,
+	0x6c, 0x52, 0x11, 0x70, 0x6f, 0x63, 0x53, 0x6c, 0x6f, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, 0x1e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x61, 0x66, 0x65, 0x74, 0x79, 0x5f,
+	0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, 0x1b, 0x63, 0x6f,
+	0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x63, 0x53, 0x61, 0x66,
+	0x65, 0x74, 0x79, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22,
+	0xed, 0x0e, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x12, 0x4c, 0x0a, 0x13, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x5f, 0x70, 0x6f,
+	0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
 	0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52,
-	0x19, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x12, 0x67, 0x0a, 0x21, 0x62, 0x61,
-	0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x6e,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18,
-	0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x52, 0x1e, 0x62, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x61, 0x74, 0x65, 0x12, 0x56, 0x0a, 0x18, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18,
-	0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x52, 0x16, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x48, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x56, 0x0a, 0x18, 0x64,
-	0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x67, 0x6f, 0x6f, 0x64, 0x5f, 0x70, 0x65, 0x72,
-	0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x64, 0x6f, 0x77,
-	0x6e, 0x74, 0x69, 0x6d, 0x65, 0x47, 0x6f, 0x6f, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74,
-	0x61, 0x67, 0x65, 0x12, 0x54, 0x0a, 0x17, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f,
-	0x62, 0x61, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x14,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d,
-	0x61, 0x6c, 0x52, 0x15, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x61, 0x64, 0x50,
-	0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x4e, 0x0a, 0x14, 0x64, 0x6f, 0x77,
-	0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x68, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c,
-	0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
-	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x12, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x48,
-	0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x5e, 0x0a, 0x1c, 0x64, 0x6f, 0x77,
-	0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x5f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x11, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x52, 0x61,
+	0x74, 0x65, 0x12, 0x37, 0x0a, 0x18, 0x6d, 0x69, 0x6e, 0x5f, 0x72, 0x61, 0x6d, 0x70, 0x5f, 0x75,
+	0x70, 0x5f, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x05, 0x52, 0x15, 0x6d, 0x69, 0x6e, 0x52, 0x61, 0x6d, 0x70, 0x55, 0x70, 0x4d,
+	0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x70,
+	0x61, 0x73, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
 	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1a, 0x64,
-	0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x12, 0x54, 0x0a, 0x17, 0x71, 0x75, 0x69,
-	0x63, 0x6b, 0x5f, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73,
-	0x68, 0x6f, 0x6c, 0x64, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x15, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x46,
-	0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12,
-	0x40, 0x0a, 0x0d, 0x62, 0x69, 0x6e, 0x6f, 0x6d, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x30,
-	0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0b, 0x62, 0x69, 0x6e, 0x6f, 0x6d, 0x54, 0x65, 0x73, 0x74, 0x50,
-	0x30, 0x12, 0x38, 0x0a, 0x18, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x19, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x16, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6c,
-	0x6f, 0x67, 0x70, 0x72, 0x6f, 0x62, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x1a, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0c, 0x6c, 0x6f, 0x67, 0x70, 0x72, 0x6f, 0x62, 0x73, 0x4d, 0x6f, 0x64, 0x65,
-	0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xd8, 0x03, 0x0a, 0x0e, 0x50, 0x6f, 0x43, 0x4d, 0x6f,
-	0x64, 0x65, 0x6c, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x69, 0x6d,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x69, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6e,
-	0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x6e,
-	0x4c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x5f, 0x68, 0x65, 0x61, 0x64,
-	0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x73, 0x12,
-	0x1c, 0x0a, 0x0a, 0x6e, 0x5f, 0x6b, 0x76, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x08, 0x6e, 0x4b, 0x76, 0x48, 0x65, 0x61, 0x64, 0x73, 0x12, 0x1d, 0x0a,
-	0x0a, 0x76, 0x6f, 0x63, 0x61, 0x62, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x05, 0x52, 0x09, 0x76, 0x6f, 0x63, 0x61, 0x62, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x4a, 0x0a, 0x12,
-	0x66, 0x66, 0x6e, 0x5f, 0x64, 0x69, 0x6d, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69,
-	0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x70,
+	0x61, 0x73, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x52, 0x0a, 0x16, 0x6d, 0x69, 0x6e, 0x5f,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61,
+	0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
-	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x10, 0x66, 0x66, 0x6e, 0x44, 0x69, 0x6d, 0x4d, 0x75,
-	0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x75, 0x6c, 0x74,
-	0x69, 0x70, 0x6c, 0x65, 0x5f, 0x6f, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6d,
-	0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x4f, 0x66, 0x12, 0x37, 0x0a, 0x08, 0x6e, 0x6f, 0x72,
-	0x6d, 0x5f, 0x65, 0x70, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x07, 0x6e, 0x6f, 0x72, 0x6d, 0x45,
-	0x70, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x6f, 0x70, 0x65, 0x5f, 0x74, 0x68, 0x65, 0x74, 0x61,
-	0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x72, 0x6f, 0x70, 0x65, 0x54, 0x68, 0x65, 0x74,
-	0x61, 0x12, 0x26, 0x0a, 0x0f, 0x75, 0x73, 0x65, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x5f,
-	0x72, 0x6f, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x75, 0x73, 0x65, 0x53,
-	0x63, 0x61, 0x6c, 0x65, 0x64, 0x52, 0x6f, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x65, 0x71,
-	0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x65, 0x71, 0x4c,
-	0x65, 0x6e, 0x12, 0x37, 0x0a, 0x08, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x0c,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d,
-	0x61, 0x6c, 0x52, 0x07, 0x72, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f,
-	0x01, 0x22, 0xe5, 0x01, 0x0a, 0x11, 0x50, 0x6f, 0x43, 0x53, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73,
-	0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x43, 0x0a, 0x0e, 0x64, 0x69, 0x73, 0x74, 0x5f,
-	0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0d, 0x64,
-	0x69, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x3b, 0x0a, 0x0a,
-	0x70, 0x5f, 0x6d, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09,
-	0x70, 0x4d, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x48, 0x0a, 0x11, 0x70, 0x5f, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d,
-	0x61, 0x6c, 0x52, 0x0f, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68,
-	0x6f, 0x6c, 0x64, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x8d, 0x02, 0x0a, 0x0e, 0x50, 0x6f,
-	0x43, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x19, 0x0a, 0x08,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x65, 0x71, 0x5f, 0x6c,
-	0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x73, 0x65, 0x71, 0x4c, 0x65, 0x6e,
-	0x12, 0x43, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x74, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x53, 0x74, 0x61,
-	0x74, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x08, 0x73, 0x74, 0x61,
-	0x74, 0x54, 0x65, 0x73, 0x74, 0x12, 0x4c, 0x0a, 0x13, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f,
-	0x73, 0x63, 0x61, 0x6c, 0x65, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c,
-	0x52, 0x11, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x46, 0x61, 0x63,
-	0x74, 0x6f, 0x72, 0x12, 0x2e, 0x0a, 0x13, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x5f, 0x73,
-	0x74, 0x61, 0x72, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x11, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x45, 0x70,
-	0x6f, 0x63, 0x68, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xa3, 0x06, 0x0a, 0x09, 0x50, 0x6f,
-	0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x64, 0x65, 0x66, 0x61, 0x75,
-	0x6c, 0x74, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x11, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x44, 0x69, 0x66, 0x66,
-	0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x12, 0x34, 0x0a, 0x16, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x46, 0x0a, 0x20,
-	0x70, 0x6f, 0x63, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67,
-	0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1c, 0x70, 0x6f, 0x63, 0x44, 0x61, 0x74, 0x61, 0x50,
-	0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x54, 0x68, 0x72, 0x65, 0x73,
-	0x68, 0x6f, 0x6c, 0x64, 0x12, 0x50, 0x0a, 0x13, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x73,
-	0x63, 0x61, 0x6c, 0x65, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x42,
-	0x02, 0x18, 0x01, 0x52, 0x11, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x53, 0x63, 0x61, 0x6c, 0x65,
-	0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x4a, 0x0a, 0x0c, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f,
-	0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x61, 0x72, 0x61, 0x6d,
-	0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x61, 0x72, 0x61,
-	0x6d, 0x73, 0x12, 0x1d, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x06,
-	0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49,
-	0x64, 0x12, 0x1b, 0x0a, 0x07, 0x73, 0x65, 0x71, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x01,
-	0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x06, 0x73, 0x65, 0x71, 0x4c, 0x65, 0x6e, 0x12, 0x24,
-	0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x32, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64,
-	0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x70, 0x6f, 0x63, 0x56, 0x32, 0x45, 0x6e, 0x61,
-	0x62, 0x6c, 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x1b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x32, 0x5f, 0x65, 0x6e, 0x61, 0x62,
-	0x6c, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x63, 0x6f, 0x6e, 0x66, 0x69,
-	0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x63, 0x56, 0x32, 0x45, 0x6e, 0x61, 0x62,
-	0x6c, 0x65, 0x64, 0x12, 0x47, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x74, 0x5f, 0x74, 0x65, 0x73, 0x74,
-	0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43,
-	0x53, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x02,
-	0x18, 0x01, 0x52, 0x08, 0x73, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x10,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73,
-	0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x6c, 0x6f, 0x74, 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x6f, 0x63, 0x5f, 0x6e,
-	0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x61,
-	0x62, 0x6c, 0x65, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x70, 0x6f, 0x63, 0x4e,
-	0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x61, 0x62,
-	0x6c, 0x65, 0x64, 0x12, 0x37, 0x0a, 0x18, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x72, 0x6f, 0x6e,
-	0x67, 0x65, 0x72, 0x5f, 0x72, 0x6e, 0x67, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18,
-	0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x72, 0x6f, 0x6e, 0x67,
-	0x65, 0x72, 0x52, 0x6e, 0x67, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x3b, 0x0a, 0x06,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69,
-	0x67, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22,
-	0x41, 0x0a, 0x07, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
-	0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x05, 0x52, 0x08, 0x65, 0x78, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x3a, 0x04, 0xe8, 0xa0,
-	0x1f, 0x01, 0x22, 0x8b, 0x04, 0x0a, 0x10, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61,
-	0x6c, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x52, 0x0a, 0x16, 0x73, 0x6c, 0x61, 0x73, 0x68,
-	0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69,
-	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
-	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x46, 0x72, 0x61, 0x63,
-	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x54, 0x0a, 0x17, 0x73,
-	0x6c, 0x61, 0x73, 0x68, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x6f,
-	0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x6d, 0x69, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x52, 0x0a, 0x16,
+	0x6d, 0x61, 0x78, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61,
+	0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x15, 0x73, 0x6c, 0x61, 0x73,
-	0x68, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d,
-	0x65, 0x12, 0x6d, 0x0a, 0x24, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x69,
-	0x73, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x5f,
-	0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x21, 0x64,
-	0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x50, 0x65, 0x72,
-	0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64,
-	0x12, 0x33, 0x0a, 0x16, 0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64,
-	0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x13, 0x67, 0x72, 0x61, 0x63, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x45, 0x6e, 0x64,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x48, 0x0a, 0x11, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x77, 0x65,
-	0x69, 0x67, 0x68, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b,
+	0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x6d, 0x61, 0x78, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65,
+	0x12, 0x2b, 0x0a, 0x11, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x65, 0x78, 0x70,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x22, 0x0a,
+	0x0d, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x54, 0x6f, 0x4d, 0x61,
+	0x78, 0x12, 0x43, 0x0a, 0x1e, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x63, 0x75, 0x74,
+	0x6f, 0x66, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x1b, 0x66, 0x75, 0x6c, 0x6c, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63,
+	0x43, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x12, 0x52, 0x0a, 0x16, 0x6d, 0x69, 0x6e, 0x5f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x61, 0x6c, 0x66, 0x77, 0x61, 0x79,
+	0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x6d, 0x69, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x48, 0x61, 0x6c, 0x66, 0x77, 0x61, 0x79, 0x12, 0x41, 0x0a, 0x1d, 0x6d, 0x69,
+	0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x72, 0x61,
+	0x66, 0x66, 0x69, 0x63, 0x5f, 0x63, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x18, 0x0a, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x1a, 0x6d, 0x69, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x43, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x12, 0x52, 0x0a,
+	0x16, 0x6d, 0x69, 0x73, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65,
+	0x5f, 0x63, 0x75, 0x74, 0x6f, 0x66, 0x66, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14, 0x6d, 0x69, 0x73,
+	0x73, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x43, 0x75, 0x74, 0x6f, 0x66,
+	0x66, 0x12, 0x50, 0x0a, 0x15, 0x6d, 0x69, 0x73, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x73, 0x5f, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b,
 	0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f,
-	0x62, 0x61, 0x73, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x12,
-	0x59, 0x0a, 0x1a, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x70, 0x65,
-	0x72, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x52, 0x17, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x50, 0x65, 0x72,
-	0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01,
-	0x22, 0xf3, 0x03, 0x0a, 0x13, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61,
-	0x72, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x75, 0x73, 0x65, 0x5f,
-	0x62, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x75, 0x73, 0x65, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69,
-	0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x69, 0x74,
-	0x69, 0x61, 0x6c, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x45,
-	0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x3b, 0x0a, 0x0a, 0x64, 0x65,
-	0x63, 0x61, 0x79, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x13,
+	0x6d, 0x69, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x50, 0x65, 0x6e, 0x61,
+	0x6c, 0x74, 0x79, 0x12, 0x31, 0x0a, 0x14, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x13, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x45, 0x78, 0x70, 0x69,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
+	0x61, 0x6d, 0x70, 0x5f, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x10, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x41, 0x64, 0x76, 0x61,
+	0x6e, 0x63, 0x65, 0x12, 0x40, 0x0a, 0x1d, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64,
+	0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x5f, 0x6b, 0x62, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x65, 0x73, 0x74, 0x69,
+	0x6d, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x50, 0x65, 0x72, 0x42, 0x6c,
+	0x6f, 0x63, 0x6b, 0x4b, 0x62, 0x12, 0x5c, 0x0a, 0x1b, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x5f, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x73,
+	0x65, 0x72, 0x76, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x19, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x73, 0x65,
+	0x72, 0x76, 0x65, 0x12, 0x67, 0x0a, 0x21, 0x62, 0x61, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x64, 0x65,
-	0x63, 0x61, 0x79, 0x52, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x73,
-	0x69, 0x73, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c,
-	0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x56, 0x0a, 0x18,
-	0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x6e, 0x75,
-	0x73, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1e, 0x62, 0x61,
+	0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x6e, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x56, 0x0a, 0x18,
+	0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x5f, 0x74,
+	0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x75, 0x74,
-	0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6f, 0x6e, 0x75, 0x73, 0x46, 0x61,
-	0x63, 0x74, 0x6f, 0x72, 0x12, 0x59, 0x0a, 0x1a, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x63, 0x6f, 0x76,
-	0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x62, 0x6f, 0x6e, 0x75, 0x73, 0x5f, 0x66, 0x61, 0x63, 0x74,
-	0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
-	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x17, 0x66, 0x75, 0x6c, 0x6c, 0x43, 0x6f, 0x76, 0x65,
-	0x72, 0x61, 0x67, 0x65, 0x42, 0x6f, 0x6e, 0x75, 0x73, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12,
-	0x5f, 0x0a, 0x1d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72,
-	0x61, 0x67, 0x65, 0x5f, 0x62, 0x6f, 0x6e, 0x75, 0x73, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72,
-	0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x69, 0x6e,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x54, 0x68, 0x72, 0x65, 0x73,
+	0x68, 0x6f, 0x6c, 0x64, 0x12, 0x56, 0x0a, 0x18, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65,
+	0x5f, 0x67, 0x6f, 0x6f, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65,
+	0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x43, 0x6f, 0x76,
-	0x65, 0x72, 0x61, 0x67, 0x65, 0x42, 0x6f, 0x6e, 0x75, 0x73, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72,
-	0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xb0, 0x04, 0x0a, 0x14, 0x44, 0x79, 0x6e, 0x61, 0x6d,
-	0x69, 0x63, 0x50, 0x72, 0x69, 0x63, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12,
-	0x59, 0x0a, 0x1a, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e,
-	0x65, 0x5f, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x01, 0x20,
+	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x47, 0x6f,
+	0x6f, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x54, 0x0a, 0x17,
+	0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x62, 0x61, 0x64, 0x5f, 0x70, 0x65, 0x72,
+	0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x15, 0x64, 0x6f, 0x77,
+	0x6e, 0x74, 0x69, 0x6d, 0x65, 0x42, 0x61, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61,
+	0x67, 0x65, 0x12, 0x4e, 0x0a, 0x14, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x68,
+	0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x12,
+	0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x48, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f,
+	0x6c, 0x64, 0x12, 0x5e, 0x0a, 0x1c, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x72,
+	0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72,
+	0x76, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1a, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65,
+	0x52, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72,
+	0x76, 0x65, 0x12, 0x54, 0x0a, 0x17, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x5f, 0x66, 0x61, 0x69, 0x6c,
+	0x75, 0x72, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x17, 0x20,
 	0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
 	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x52, 0x17, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5a, 0x6f, 0x6e, 0x65,
-	0x4c, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x59, 0x0a, 0x1a, 0x73, 0x74,
-	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x5f, 0x75, 0x70, 0x70,
-	0x65, 0x72, 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x17, 0x73, 0x74,
-	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5a, 0x6f, 0x6e, 0x65, 0x55, 0x70, 0x70, 0x65, 0x72,
-	0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x47, 0x0a, 0x10, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x65,
-	0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x6c, 0x52, 0x15, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x54,
+	0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x40, 0x0a, 0x0d, 0x62, 0x69, 0x6e, 0x6f,
+	0x6d, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x30, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32,
 	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x70,
-	0x72, 0x69, 0x63, 0x65, 0x45, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x69, 0x74, 0x79, 0x12, 0x3e,
-	0x0a, 0x1b, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69,
-	0x6e, 0x64, 0x6f, 0x77, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x04, 0x52, 0x19, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d,
-	0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f,
-	0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x6d, 0x69, 0x6e,
-	0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2f, 0x0a,
-	0x14, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f,
-	0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x62, 0x61, 0x73,
-	0x65, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x33,
-	0x0a, 0x16, 0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x65,
-	0x6e, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13,
-	0x67, 0x72, 0x61, 0x63, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x45, 0x6e, 0x64, 0x45, 0x70,
-	0x6f, 0x63, 0x68, 0x12, 0x3e, 0x0a, 0x1c, 0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72,
-	0x69, 0x6f, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72,
-	0x69, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x18, 0x67, 0x72, 0x61, 0x63, 0x65,
-	0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72,
-	0x69, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xa7, 0x04, 0x0a, 0x15, 0x42, 0x61,
-	0x6e, 0x64, 0x77, 0x69, 0x64, 0x74, 0x68, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x50, 0x61, 0x72,
-	0x61, 0x6d, 0x73, 0x12, 0x40, 0x0a, 0x1d, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64,
-	0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x5f, 0x6b, 0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x65, 0x73, 0x74, 0x69,
-	0x6d, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x50, 0x65, 0x72, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x4b, 0x62, 0x12, 0x49, 0x0a, 0x12, 0x6b, 0x62, 0x5f, 0x70, 0x65, 0x72, 0x5f,
-	0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0b, 0x62,
+	0x69, 0x6e, 0x6f, 0x6d, 0x54, 0x65, 0x73, 0x74, 0x50, 0x30, 0x12, 0x38, 0x0a, 0x18, 0x63, 0x6c,
+	0x61, 0x69, 0x6d, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65,
+	0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x19, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x63, 0x6c,
+	0x61, 0x69, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x61,
+	0x62, 0x6c, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x6f, 0x67, 0x70, 0x72, 0x6f, 0x62, 0x73,
+	0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6c, 0x6f, 0x67,
+	0x70, 0x72, 0x6f, 0x62, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22,
+	0xd8, 0x03, 0x0a, 0x0e, 0x50, 0x6f, 0x43, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x69, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x03, 0x64, 0x69, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x6e, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x12,
+	0x17, 0x0a, 0x07, 0x6e, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x06, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x73, 0x12, 0x1c, 0x0a, 0x0a, 0x6e, 0x5f, 0x6b, 0x76,
+	0x5f, 0x68, 0x65, 0x61, 0x64, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6e, 0x4b,
+	0x76, 0x48, 0x65, 0x61, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x6f, 0x63, 0x61, 0x62, 0x5f,
+	0x73, 0x69, 0x7a, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x76, 0x6f, 0x63, 0x61,
+	0x62, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x4a, 0x0a, 0x12, 0x66, 0x66, 0x6e, 0x5f, 0x64, 0x69, 0x6d,
+	0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28,
 	0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52,
-	0x0f, 0x6b, 0x62, 0x50, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
-	0x12, 0x4b, 0x0a, 0x13, 0x6b, 0x62, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75,
-	0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x10, 0x66, 0x66, 0x6e, 0x44, 0x69, 0x6d, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x69, 0x65,
+	0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x5f, 0x6f, 0x66,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65,
+	0x4f, 0x66, 0x12, 0x37, 0x0a, 0x08, 0x6e, 0x6f, 0x72, 0x6d, 0x5f, 0x65, 0x70, 0x73, 0x18, 0x08,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d,
+	0x61, 0x6c, 0x52, 0x07, 0x6e, 0x6f, 0x72, 0x6d, 0x45, 0x70, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x72,
+	0x6f, 0x70, 0x65, 0x5f, 0x74, 0x68, 0x65, 0x74, 0x61, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x09, 0x72, 0x6f, 0x70, 0x65, 0x54, 0x68, 0x65, 0x74, 0x61, 0x12, 0x26, 0x0a, 0x0f, 0x75, 0x73,
+	0x65, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x6f, 0x70, 0x65, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x0d, 0x75, 0x73, 0x65, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x64, 0x52, 0x6f,
+	0x70, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x65, 0x71, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x65, 0x71, 0x4c, 0x65, 0x6e, 0x12, 0x37, 0x0a, 0x08, 0x72,
+	0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
 	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x10, 0x6b, 0x62, 0x50,
-	0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x2f, 0x0a,
-	0x13, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x6c,
-	0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x69, 0x6e, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x3e,
-	0x0a, 0x1b, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f,
-	0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x05, 0x20,
-	0x01, 0x28, 0x04, 0x52, 0x19, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x3a,
-	0x0a, 0x19, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f,
-	0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x76, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x17, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x4c, 0x69, 0x6d, 0x69, 0x74, 0x43, 0x75, 0x72, 0x76, 0x65, 0x12, 0x48, 0x0a, 0x20, 0x6d, 0x69,
-	0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
-	0x5f, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07,
-	0x20, 0x01, 0x28, 0x0d, 0x52, 0x1e, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x43, 0x6f, 0x6e,
-	0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a, 0x18, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15, 0x6d, 0x61, 0x78, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x73, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x3a, 0x04, 0xe8,
-	0xa0, 0x1f, 0x01, 0x22, 0xae, 0x02, 0x0a, 0x15, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x47, 0x0a,
-	0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72,
-	0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1d, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65,
-	0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x65,
-	0x72, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x45, 0x0a, 0x0f, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x5f,
-	0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0e, 0x61,
-	0x6c, 0x70, 0x68, 0x61, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x43, 0x0a,
-	0x0e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x07, 0x72, 0x54, 0x61,
+	0x72, 0x67, 0x65, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xe5, 0x01, 0x0a, 0x11, 0x50,
+	0x6f, 0x43, 0x53, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x12, 0x43, 0x0a, 0x0e, 0x64, 0x69, 0x73, 0x74, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f,
+	0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0d, 0x64, 0x69, 0x73, 0x74, 0x54, 0x68, 0x72, 0x65,
+	0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x3b, 0x0a, 0x0a, 0x70, 0x5f, 0x6d, 0x69, 0x73, 0x6d, 0x61,
+	0x74, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x70, 0x4d, 0x69, 0x73, 0x6d, 0x61, 0x74,
+	0x63, 0x68, 0x12, 0x48, 0x0a, 0x11, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x68,
+	0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x70, 0x56, 0x61,
+	0x6c, 0x75, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x3a, 0x04, 0xe8, 0xa0,
+	0x1f, 0x01, 0x22, 0x8d, 0x02, 0x0a, 0x0e, 0x50, 0x6f, 0x43, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43,
+	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64,
+	0x12, 0x17, 0x0a, 0x07, 0x73, 0x65, 0x71, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x06, 0x73, 0x65, 0x71, 0x4c, 0x65, 0x6e, 0x12, 0x43, 0x0a, 0x09, 0x73, 0x74, 0x61,
+	0x74, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x53, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73, 0x74, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x52, 0x08, 0x73, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73, 0x74, 0x12, 0x4c,
+	0x0a, 0x13, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x5f, 0x66,
+	0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x11, 0x77, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x2e, 0x0a, 0x13,
+	0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x70, 0x65, 0x6e, 0x61, 0x6c,
+	0x74, 0x79, 0x53, 0x74, 0x61, 0x72, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x3a, 0x04, 0xe8, 0xa0,
+	0x1f, 0x01, 0x22, 0xa3, 0x06, 0x0a, 0x09, 0x50, 0x6f, 0x63, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x12, 0x2d, 0x0a, 0x12, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x64, 0x69, 0x66, 0x66,
+	0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x64, 0x65,
+	0x66, 0x61, 0x75, 0x6c, 0x74, 0x44, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x12,
+	0x34, 0x0a, 0x16, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x61,
+	0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x61, 0x6d, 0x70, 0x6c,
+	0x65, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x46, 0x0a, 0x20, 0x70, 0x6f, 0x63, 0x5f, 0x64, 0x61, 0x74,
+	0x61, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+	0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x1c, 0x70, 0x6f, 0x63, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x45,
+	0x70, 0x6f, 0x63, 0x68, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x50, 0x0a,
+	0x13, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x5f, 0x66, 0x61,
+	0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x11, 0x77, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12,
+	0x4a, 0x0a, 0x0c, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18,
+	0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0b,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1d, 0x0a, 0x08, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18,
+	0x01, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x07, 0x73, 0x65,
+	0x71, 0x5f, 0x6c, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52,
+	0x06, 0x73, 0x65, 0x71, 0x4c, 0x65, 0x6e, 0x12, 0x24, 0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76,
+	0x32, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x0c, 0x70, 0x6f, 0x63, 0x56, 0x32, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x3d, 0x0a,
+	0x1b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f,
+	0x63, 0x5f, 0x76, 0x32, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x18, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x50, 0x6f, 0x63, 0x56, 0x32, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x47, 0x0a, 0x09,
+	0x73, 0x74, 0x61, 0x74, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x53, 0x74, 0x61, 0x74, 0x54, 0x65, 0x73,
+	0x74, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x73, 0x74, 0x61,
+	0x74, 0x54, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52,
+	0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6c, 0x6f, 0x74, 0x73,
+	0x12, 0x3a, 0x0a, 0x19, 0x70, 0x6f, 0x63, 0x5f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x17, 0x70, 0x6f, 0x63, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x37, 0x0a, 0x18,
+	0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x5f, 0x72, 0x6e, 0x67,
+	0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15,
+	0x70, 0x6f, 0x63, 0x53, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x52, 0x6e, 0x67, 0x45, 0x6e,
+	0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x3b, 0x0a, 0x06, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x18,
+	0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x6d, 0x6f, 0x64, 0x65,
+	0x6c, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x41, 0x0a, 0x07, 0x44, 0x65, 0x63, 0x69,
+	0x6d, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x70,
+	0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x65, 0x78, 0x70,
+	0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x8b, 0x04, 0x0a, 0x10,
+	0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x12, 0x52, 0x0a, 0x16, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x14,
+	0x73, 0x6c, 0x61, 0x73, 0x68, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x12, 0x54, 0x0a, 0x17, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x5f, 0x66, 0x72,
+	0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x52, 0x0d, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x12, 0x3a, 0x0a, 0x19, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x70, 0x72,
-	0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x18,
-	0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72,
-	0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x3a, 0x04,
-	0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc9, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
-	0x47, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x3c,
-	0x0a, 0x1a, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69,
-	0x74, 0x79, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x18, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x74, 0x75, 0x72,
-	0x69, 0x74, 0x79, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x3d, 0x0a, 0x1b,
-	0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79,
-	0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x18, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69,
-	0x74, 0x79, 0x4d, 0x69, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x67,
-	0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
-	0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x11, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61,
-	0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01,
-	0x22, 0x8b, 0x01, 0x0a, 0x15, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41, 0x63,
-	0x63, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x6e,
-	0x74, 0x69, 0x6c, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x61, 0x6c, 0x6c, 0x6f,
-	0x77, 0x65, 0x64, 0x5f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x19, 0x61,
-	0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xd1,
-	0x02, 0x0a, 0x17, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x63,
-	0x63, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x58, 0x0a, 0x29, 0x6e, 0x65,
-	0x77, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x72, 0x65,
-	0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74,
-	0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x25, 0x6e,
-	0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x67,
-	0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65,
-	0x69, 0x67, 0x68, 0x74, 0x12, 0x42, 0x0a, 0x1d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f,
-	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x1b, 0x62, 0x6c, 0x6f,
-	0x63, 0x6b, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x75, 0x73, 0x65, 0x5f,
-	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x6f,
-	0x77, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x75, 0x73, 0x65,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77,
-	0x6c, 0x69, 0x73, 0x74, 0x12, 0x56, 0x0a, 0x28, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x6c, 0x69, 0x73, 0x74, 0x5f, 0x75, 0x6e,
-	0x74, 0x69, 0x6c, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x24, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x6c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x74, 0x69,
-	0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x04, 0xe8, 0xa0,
-	0x1f, 0x01, 0x22, 0x5f, 0x0a, 0x19, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x41, 0x67,
-	0x65, 0x6e, 0x74, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12,
-	0x3c, 0x0a, 0x1a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73,
-	0x66, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20,
-	0x03, 0x28, 0x09, 0x52, 0x18, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e,
-	0x73, 0x66, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x04, 0xe8,
-	0xa0, 0x1f, 0x01, 0x22, 0xc8, 0x04, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x70, 0x6c,
-	0x6f, 0x79, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
-	0x0c, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x12, 0x45, 0x0a,
-	0x0f, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x5f, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0e, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x50, 0x65, 0x6e,
-	0x61, 0x6c, 0x74, 0x79, 0x12, 0x56, 0x0a, 0x18, 0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79,
+	0x6d, 0x61, 0x6c, 0x52, 0x15, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x44, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x6d, 0x0a, 0x24, 0x64, 0x6f,
+	0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x65,
+	0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f,
+	0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x21, 0x64, 0x6f, 0x77, 0x6e, 0x74, 0x69, 0x6d, 0x65,
+	0x4d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65,
+	0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x33, 0x0a, 0x16, 0x67, 0x72, 0x61,
+	0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x67, 0x72, 0x61, 0x63, 0x65,
+	0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x45, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x48,
+	0x0a, 0x11, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x62, 0x61, 0x73, 0x65, 0x57, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x12, 0x59, 0x0a, 0x1a, 0x63, 0x6f, 0x6c, 0x6c,
+	0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x17, 0x63, 0x6f, 0x6c, 0x6c,
+	0x61, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x55,
+	0x6e, 0x69, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xf3, 0x03, 0x0a, 0x13, 0x42, 0x69,
+	0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d,
+	0x73, 0x12, 0x2e, 0x0a, 0x13, 0x75, 0x73, 0x65, 0x5f, 0x62, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e,
+	0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11,
+	0x75, 0x73, 0x65, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64,
+	0x73, 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x65, 0x70, 0x6f,
+	0x63, 0x68, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x12, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x77,
+	0x61, 0x72, 0x64, 0x12, 0x3b, 0x0a, 0x0a, 0x64, 0x65, 0x63, 0x61, 0x79, 0x5f, 0x72, 0x61, 0x74,
+	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
+	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x64, 0x65, 0x63, 0x61, 0x79, 0x52, 0x61, 0x74, 0x65,
+	0x12, 0x23, 0x0a, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73,
+	0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x56, 0x0a, 0x18, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6f, 0x6e, 0x75, 0x73, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f,
+	0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
+	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x42, 0x6f, 0x6e, 0x75, 0x73, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x59, 0x0a,
+	0x1a, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x62,
+	0x6f, 0x6e, 0x75, 0x73, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52,
+	0x17, 0x66, 0x75, 0x6c, 0x6c, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x42, 0x6f, 0x6e,
+	0x75, 0x73, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x5f, 0x0a, 0x1d, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x62, 0x6f, 0x6e,
+	0x75, 0x73, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1a, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x42, 0x6f,
+	0x6e, 0x75, 0x73, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22,
+	0xb0, 0x04, 0x0a, 0x14, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x50, 0x72, 0x69, 0x63, 0x69,
+	0x6e, 0x67, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x59, 0x0a, 0x1a, 0x73, 0x74, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x5f, 0x6c, 0x6f, 0x77, 0x65, 0x72,
+	0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x17, 0x73, 0x74, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x79, 0x5a, 0x6f, 0x6e, 0x65, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x6f,
+	0x75, 0x6e, 0x64, 0x12, 0x59, 0x0a, 0x1a, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+	0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x5f, 0x75, 0x70, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6f, 0x75, 0x6e,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
+	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x17, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+	0x5a, 0x6f, 0x6e, 0x65, 0x55, 0x70, 0x70, 0x65, 0x72, 0x42, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x47,
+	0x0a, 0x10, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x65, 0x6c, 0x61, 0x73, 0x74, 0x69, 0x63, 0x69,
+	0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x45, 0x6c, 0x61,
+	0x73, 0x74, 0x69, 0x63, 0x69, 0x74, 0x79, 0x12, 0x3e, 0x0a, 0x1b, 0x75, 0x74, 0x69, 0x6c, 0x69,
+	0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x5f, 0x64, 0x75,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x75, 0x74,
+	0x69, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x44,
+	0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x13, 0x6d, 0x69, 0x6e, 0x5f, 0x70,
+	0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x6d, 0x69, 0x6e, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x2f, 0x0a, 0x14, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x70,
+	0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x06,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x62, 0x61, 0x73, 0x65, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b,
+	0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x67, 0x72, 0x61, 0x63, 0x65,
+	0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x67, 0x72, 0x61, 0x63, 0x65, 0x50, 0x65,
+	0x72, 0x69, 0x6f, 0x64, 0x45, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x3e, 0x0a, 0x1c,
+	0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x70, 0x65, 0x72,
+	0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x18, 0x67, 0x72, 0x61, 0x63, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x50,
+	0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x3a, 0x04, 0xe8, 0xa0,
+	0x1f, 0x01, 0x22, 0xa7, 0x04, 0x0a, 0x15, 0x42, 0x61, 0x6e, 0x64, 0x77, 0x69, 0x64, 0x74, 0x68,
+	0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x40, 0x0a, 0x1d,
+	0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73,
+	0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6b, 0x62, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x19, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x4c, 0x69,
+	0x6d, 0x69, 0x74, 0x73, 0x50, 0x65, 0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4b, 0x62, 0x12, 0x49,
+	0x0a, 0x12, 0x6b, 0x62, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74,
+	0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x6b, 0x62, 0x50, 0x65, 0x72, 0x49,
+	0x6e, 0x70, 0x75, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x4b, 0x0a, 0x13, 0x6b, 0x62, 0x5f,
+	0x70, 0x65, 0x72, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
 	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x6e, 0x6f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x12, 0x47, 0x0a, 0x10,
-	0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x10, 0x6b, 0x62, 0x50, 0x65, 0x72, 0x4f, 0x75, 0x74, 0x70, 0x75,
+	0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x2f, 0x0a, 0x13, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x12, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f,
+	0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x69, 0x6e,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x61, 0x6d, 0x70, 0x6c,
+	0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x3a, 0x0a, 0x19, 0x69, 0x6e, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x63,
+	0x75, 0x72, 0x76, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x17, 0x69, 0x6e, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x43, 0x75,
+	0x72, 0x76, 0x65, 0x12, 0x48, 0x0a, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x63,
+	0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1e, 0x6d,
+	0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+	0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x37, 0x0a,
+	0x18, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x5f,
+	0x70, 0x65, 0x72, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x15, 0x6d, 0x61, 0x78, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x50, 0x65,
+	0x72, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xae, 0x02, 0x0a,
+	0x15, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43,
+	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x47, 0x0a, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74,
+	0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x5f, 0x70, 0x65, 0x72, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x1d, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72,
+	0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x65, 0x72, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12,
+	0x45, 0x0a, 0x0f, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f,
+	0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44,
+	0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0e, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x54, 0x68, 0x72,
+	0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x43, 0x0a, 0x0e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x5f,
+	0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0d, 0x73, 0x6c,
+	0x61, 0x73, 0x68, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x0a, 0x19, 0x75,
+	0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17,
+	0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc9, 0x01,
+	0x0a, 0x15, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x47, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61,
+	0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x6e, 0x65, 0x74, 0x77, 0x6f,
+	0x72, 0x6b, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x74, 0x68, 0x72, 0x65,
+	0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x6e, 0x65, 0x74,
+	0x77, 0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x54, 0x68, 0x72, 0x65,
+	0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x3d, 0x0a, 0x1b, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b,
+	0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x6e, 0x65, 0x74, 0x77,
+	0x6f, 0x72, 0x6b, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4d, 0x69, 0x6e, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09,
+	0x52, 0x11, 0x67, 0x75, 0x61, 0x72, 0x64, 0x69, 0x61, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x8b, 0x01, 0x0a, 0x15, 0x44, 0x65,
+	0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72,
+	0x61, 0x6d, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x5f, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x10, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x64, 0x65, 0x76,
+	0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x19, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x44,
+	0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xd1, 0x02, 0x0a, 0x17, 0x50, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x50, 0x61, 0x72,
+	0x61, 0x6d, 0x73, 0x12, 0x58, 0x0a, 0x29, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x25, 0x6e, 0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x42, 0x0a,
+	0x1d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x09, 0x52, 0x1b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x12, 0x3a, 0x0a, 0x19, 0x75, 0x73, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x75, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x56, 0x0a,
+	0x28, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x6c, 0x6c,
+	0x6f, 0x77, 0x6c, 0x69, 0x73, 0x74, 0x5f, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x5f, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x24, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f,
+	0x77, 0x6c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x5f, 0x0a, 0x19, 0x54,
+	0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x41, 0x63, 0x63, 0x65,
+	0x73, 0x73, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x61, 0x6c, 0x6c, 0x6f,
+	0x77, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x18, 0x61, 0x6c,
+	0x6c, 0x6f, 0x77, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xc8, 0x04, 0x0a,
+	0x10, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d,
+	0x73, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x5f, 0x77, 0x69, 0x6e, 0x64,
+	0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79,
+	0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x12, 0x45, 0x0a, 0x0f, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61,
+	0x6c, 0x5f, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0e, 0x72,
+	0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x12, 0x56, 0x0a,
+	0x18, 0x6e, 0x6f, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x16, 0x6e,
+	0x6f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x65,
+	0x6e, 0x61, 0x6c, 0x74, 0x79, 0x12, 0x47, 0x0a, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x65, 0x12, 0x3d,
+	0x0a, 0x0b, 0x77, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61,
+	0x6c, 0x52, 0x0a, 0x77, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x13, 0x0a,
+	0x05, 0x76, 0x5f, 0x6d, 0x69, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x76, 0x4d,
+	0x69, 0x6e, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63,
-	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x53, 0x68, 0x61, 0x72, 0x65, 0x12, 0x3d, 0x0a, 0x0b, 0x77, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73,
-	0x68, 0x6f, 0x6c, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0a, 0x77, 0x54, 0x68, 0x72, 0x65, 0x73,
-	0x68, 0x6f, 0x6c, 0x64, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x5f, 0x6d, 0x69, 0x6e, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x04, 0x76, 0x4d, 0x69, 0x6e, 0x12, 0x3b, 0x0a, 0x0a, 0x63, 0x61, 0x70,
-	0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x63, 0x61, 0x70,
-	0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x28, 0x0a, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61,
-	0x6c, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64,
-	0x12, 0x66, 0x0a, 0x21, 0x6d, 0x61, 0x78, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x76, 0x6f,
-	0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65,
-	0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x1d, 0x6d, 0x61, 0x78, 0x4d, 0x6f,
-	0x64, 0x65, 0x6c, 0x56, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x50, 0x65,
-	0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x63,
-	0x0a, 0x17, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76,
-	0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d,
-	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a,
-	0x06, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62,
-	0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x3a, 0x04, 0xe8,
-	0xa0, 0x1f, 0x01, 0x22, 0xa9, 0x07, 0x0a, 0x14, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64,
-	0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1d, 0x0a, 0x0a,
-	0x6d, 0x69, 0x6e, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x09, 0x6d, 0x69, 0x6e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6d,
-	0x61, 0x78, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x09, 0x6d, 0x61, 0x78, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x15, 0x6d, 0x61,
-	0x78, 0x5f, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x6d, 0x61, 0x78, 0x45, 0x73,
-	0x63, 0x72, 0x6f, 0x77, 0x73, 0x50, 0x65, 0x72, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x1d, 0x0a,
-	0x0a, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x0d, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x3a, 0x0a, 0x19,
-	0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x5f,
-	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52,
-	0x17, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x6b, 0x65,
-	0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x74,
-	0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x59, 0x0a, 0x11, 0x61, 0x70, 0x70,
-	0x72, 0x6f, 0x76, 0x65, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68,
+	0x69, 0x6d, 0x61, 0x6c, 0x52, 0x09, 0x63, 0x61, 0x70, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12,
+	0x28, 0x0a, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x69,
+	0x61, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x66, 0x0a, 0x21, 0x6d, 0x61, 0x78,
+	0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x76, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f,
+	0x77, 0x65, 0x72, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x09,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d,
+	0x61, 0x6c, 0x52, 0x1d, 0x6d, 0x61, 0x78, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x56, 0x6f, 0x74, 0x69,
+	0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67,
+	0x65, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x63, 0x0a, 0x17, 0x44, 0x65, 0x76, 0x73, 0x68,
 	0x61, 0x72, 0x64, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69,
-	0x6f, 0x6e, 0x52, 0x10, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73,
-	0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x6e, 0x6f, 0x6e, 0x63,
-	0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x4e, 0x6f, 0x6e, 0x63,
-	0x65, 0x12, 0x3a, 0x0a, 0x19, 0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x09,
-	0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x4c, 0x0a,
-	0x23, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x5f, 0x73, 0x65, 0x61, 0x6c, 0x5f, 0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x6e, 0x6f,
-	0x6e, 0x63, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1f, 0x64, 0x65, 0x66, 0x61,
-	0x75, 0x6c, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x65, 0x61, 0x6c,
-	0x47, 0x72, 0x61, 0x63, 0x65, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x64,
-	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x5f, 0x73, 0x65, 0x61, 0x6c, 0x5f, 0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x63, 0x6f,
-	0x6e, 0x64, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75,
-	0x6c, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x65, 0x61, 0x6c, 0x47,
-	0x72, 0x61, 0x63, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63,
-	0x72, 0x65, 0x61, 0x74, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x66,
-	0x65, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x46, 0x65, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x66,
-	0x65, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x0d, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x0b, 0x66, 0x65, 0x65, 0x50, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x12,
-	0x27, 0x0a, 0x0f, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f,
-	0x75, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61,
-	0x6c, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x65, 0x78, 0x65, 0x63,
-	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x0f, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x10, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69,
-	0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x32,
-	0x0a, 0x15, 0x76, 0x6f, 0x74, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64,
-	0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x76,
-	0x6f, 0x74, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x46, 0x61, 0x63, 0x74,
-	0x6f, 0x72, 0x12, 0x45, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x61, 0x75,
-	0x74, 0x6f, 0x5f, 0x73, 0x65, 0x61, 0x6c, 0x5f, 0x65, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x6e, 0x5f,
-	0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1b, 0x64, 0x65,
-	0x66, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x75, 0x74, 0x6f, 0x53, 0x65, 0x61, 0x6c, 0x45, 0x76, 0x65,
-	0x72, 0x79, 0x4e, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22,
-	0x9d, 0x01, 0x0a, 0x09, 0x46, 0x65, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2f, 0x0a,
-	0x14, 0x6d, 0x69, 0x6e, 0x5f, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x6e,
-	0x67, 0x6f, 0x6e, 0x6b, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x6d, 0x69, 0x6e,
-	0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x4e, 0x67, 0x6f, 0x6e, 0x6b, 0x61, 0x12, 0x2e,
-	0x0a, 0x13, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x5f, 0x67, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x62, 0x61, 0x73,
-	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x47, 0x61, 0x73, 0x12, 0x29,
-	0x0a, 0x11, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x63, 0x6f,
-	0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x67, 0x61, 0x73, 0x50, 0x65,
-	0x72, 0x50, 0x6f, 0x63, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x42,
-	0xb9, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x0b, 0x50, 0x61, 0x72,
-	0x61, 0x6d, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61,
-	0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+	0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x16,
+	0x0a, 0x06, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
+	0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0xa9, 0x07, 0x0a,
+	0x14, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x50,
+	0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x69, 0x6e, 0x5f, 0x61, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6d, 0x69, 0x6e, 0x41, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x41, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x15, 0x6d, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x72, 0x6f,
+	0x77, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x12, 0x6d, 0x61, 0x78, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x73, 0x50, 0x65,
+	0x72, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f,
+	0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75,
+	0x70, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64,
+	0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x17, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65,
+	0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69,
+	0x63, 0x65, 0x12, 0x59, 0x0a, 0x11, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x5f, 0x76,
+	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x41, 0x70, 0x70, 0x72,
+	0x6f, 0x76, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x61, 0x70, 0x70,
+	0x72, 0x6f, 0x76, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1b, 0x0a,
+	0x09, 0x6d, 0x61, 0x78, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x08, 0x6d, 0x61, 0x78, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x3a, 0x0a, 0x19, 0x64, 0x65,
+	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x5f,
+	0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x64,
+	0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45,
+	0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x4c, 0x0a, 0x23, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x61, 0x6c,
+	0x5f, 0x67, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x1f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x53, 0x65, 0x61, 0x6c, 0x47, 0x72, 0x61, 0x63, 0x65, 0x4e, 0x6f,
+	0x6e, 0x63, 0x65, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x61, 0x6c, 0x5f, 0x67,
+	0x72, 0x61, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x0b, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x53, 0x65, 0x61, 0x6c, 0x47, 0x72, 0x61, 0x63, 0x65, 0x53, 0x65, 0x63,
+	0x6f, 0x6e, 0x64, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x5f, 0x64,
+	0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x11, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72,
+	0x64, 0x46, 0x65, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x66, 0x65, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f,
+	0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x66, 0x65, 0x65,
+	0x50, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x66, 0x75,
+	0x73, 0x61, 0x6c, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x0e, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75,
+	0x74, 0x12, 0x2b, 0x0a, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74,
+	0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x65, 0x78,
+	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x27,
+	0x0a, 0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x74,
+	0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x52, 0x61, 0x74, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x76, 0x6f, 0x74, 0x65, 0x5f,
+	0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72,
+	0x18, 0x11, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x76, 0x6f, 0x74, 0x65, 0x54, 0x68, 0x72, 0x65,
+	0x73, 0x68, 0x6f, 0x6c, 0x64, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x45, 0x0a, 0x20, 0x64,
+	0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x73, 0x65, 0x61, 0x6c,
+	0x5f, 0x65, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x6e, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x18,
+	0x12, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1b, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x75,
+	0x74, 0x6f, 0x53, 0x65, 0x61, 0x6c, 0x45, 0x76, 0x65, 0x72, 0x79, 0x4e, 0x4e, 0x6f, 0x6e, 0x63,
+	0x65, 0x73, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x22, 0x9d, 0x01, 0x0a, 0x09, 0x46, 0x65, 0x65,
+	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2f, 0x0a, 0x14, 0x6d, 0x69, 0x6e, 0x5f, 0x67, 0x61,
+	0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x6e, 0x67, 0x6f, 0x6e, 0x6b, 0x61, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x6d, 0x69, 0x6e, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63,
+	0x65, 0x4e, 0x67, 0x6f, 0x6e, 0x6b, 0x61, 0x12, 0x2e, 0x0a, 0x13, 0x62, 0x61, 0x73, 0x65, 0x5f,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x67, 0x61, 0x73, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x62, 0x61, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x47, 0x61, 0x73, 0x12, 0x29, 0x0a, 0x11, 0x67, 0x61, 0x73, 0x5f, 0x70,
+	0x65, 0x72, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0e, 0x67, 0x61, 0x73, 0x50, 0x65, 0x72, 0x50, 0x6f, 0x63, 0x43, 0x6f, 0x75,
+	0x6e, 0x74, 0x3a, 0x04, 0xe8, 0xa0, 0x1f, 0x01, 0x42, 0xb9, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x42, 0x0b, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69,
+	0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa,
+	0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14,
+	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -23108,111 +24030,113 @@ func file_inference_inference_params_proto_rawDescGZIP() []byte {
 	return file_inference_inference_params_proto_rawDescData
 }
 
-var file_inference_inference_params_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
+var file_inference_inference_params_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
 var file_inference_inference_params_proto_goTypes = []interface{}{
 	(*Params)(nil),                    // 0: inference.inference.Params
-	(*GenesisOnlyParams)(nil),         // 1: inference.inference.GenesisOnlyParams
-	(*TokenomicsParams)(nil),          // 2: inference.inference.TokenomicsParams
-	(*EpochParams)(nil),               // 3: inference.inference.EpochParams
-	(*ValidationParams)(nil),          // 4: inference.inference.ValidationParams
-	(*PoCModelParams)(nil),            // 5: inference.inference.PoCModelParams
-	(*PoCStatTestParams)(nil),         // 6: inference.inference.PoCStatTestParams
-	(*PoCModelConfig)(nil),            // 7: inference.inference.PoCModelConfig
-	(*PocParams)(nil),                 // 8: inference.inference.PocParams
-	(*Decimal)(nil),                   // 9: inference.inference.Decimal
-	(*CollateralParams)(nil),          // 10: inference.inference.CollateralParams
-	(*BitcoinRewardParams)(nil),       // 11: inference.inference.BitcoinRewardParams
-	(*DynamicPricingParams)(nil),      // 12: inference.inference.DynamicPricingParams
-	(*BandwidthLimitsParams)(nil),     // 13: inference.inference.BandwidthLimitsParams
-	(*ConfirmationPoCParams)(nil),     // 14: inference.inference.ConfirmationPoCParams
-	(*GenesisGuardianParams)(nil),     // 15: inference.inference.GenesisGuardianParams
-	(*DeveloperAccessParams)(nil),     // 16: inference.inference.DeveloperAccessParams
-	(*ParticipantAccessParams)(nil),   // 17: inference.inference.ParticipantAccessParams
-	(*TransferAgentAccessParams)(nil), // 18: inference.inference.TransferAgentAccessParams
-	(*DelegationParams)(nil),          // 19: inference.inference.DelegationParams
-	(*DevshardApprovedVersion)(nil),   // 20: inference.inference.DevshardApprovedVersion
-	(*DevshardEscrowParams)(nil),      // 21: inference.inference.DevshardEscrowParams
-	(*FeeParams)(nil),                 // 22: inference.inference.FeeParams
+	(*MaintenanceParams)(nil),         // 1: inference.inference.MaintenanceParams
+	(*GenesisOnlyParams)(nil),         // 2: inference.inference.GenesisOnlyParams
+	(*TokenomicsParams)(nil),          // 3: inference.inference.TokenomicsParams
+	(*EpochParams)(nil),               // 4: inference.inference.EpochParams
+	(*ValidationParams)(nil),          // 5: inference.inference.ValidationParams
+	(*PoCModelParams)(nil),            // 6: inference.inference.PoCModelParams
+	(*PoCStatTestParams)(nil),         // 7: inference.inference.PoCStatTestParams
+	(*PoCModelConfig)(nil),            // 8: inference.inference.PoCModelConfig
+	(*PocParams)(nil),                 // 9: inference.inference.PocParams
+	(*Decimal)(nil),                   // 10: inference.inference.Decimal
+	(*CollateralParams)(nil),          // 11: inference.inference.CollateralParams
+	(*BitcoinRewardParams)(nil),       // 12: inference.inference.BitcoinRewardParams
+	(*DynamicPricingParams)(nil),      // 13: inference.inference.DynamicPricingParams
+	(*BandwidthLimitsParams)(nil),     // 14: inference.inference.BandwidthLimitsParams
+	(*ConfirmationPoCParams)(nil),     // 15: inference.inference.ConfirmationPoCParams
+	(*GenesisGuardianParams)(nil),     // 16: inference.inference.GenesisGuardianParams
+	(*DeveloperAccessParams)(nil),     // 17: inference.inference.DeveloperAccessParams
+	(*ParticipantAccessParams)(nil),   // 18: inference.inference.ParticipantAccessParams
+	(*TransferAgentAccessParams)(nil), // 19: inference.inference.TransferAgentAccessParams
+	(*DelegationParams)(nil),          // 20: inference.inference.DelegationParams
+	(*DevshardApprovedVersion)(nil),   // 21: inference.inference.DevshardApprovedVersion
+	(*DevshardEscrowParams)(nil),      // 22: inference.inference.DevshardEscrowParams
+	(*FeeParams)(nil),                 // 23: inference.inference.FeeParams
 }
 var file_inference_inference_params_proto_depIdxs = []int32{
-	3,  // 0: inference.inference.Params.epoch_params:type_name -> inference.inference.EpochParams
-	4,  // 1: inference.inference.Params.validation_params:type_name -> inference.inference.ValidationParams
-	8,  // 2: inference.inference.Params.poc_params:type_name -> inference.inference.PocParams
-	2,  // 3: inference.inference.Params.tokenomics_params:type_name -> inference.inference.TokenomicsParams
-	10, // 4: inference.inference.Params.collateral_params:type_name -> inference.inference.CollateralParams
-	11, // 5: inference.inference.Params.bitcoin_reward_params:type_name -> inference.inference.BitcoinRewardParams
-	12, // 6: inference.inference.Params.dynamic_pricing_params:type_name -> inference.inference.DynamicPricingParams
-	13, // 7: inference.inference.Params.bandwidth_limits_params:type_name -> inference.inference.BandwidthLimitsParams
-	14, // 8: inference.inference.Params.confirmation_poc_params:type_name -> inference.inference.ConfirmationPoCParams
-	15, // 9: inference.inference.Params.genesis_guardian_params:type_name -> inference.inference.GenesisGuardianParams
-	16, // 10: inference.inference.Params.developer_access_params:type_name -> inference.inference.DeveloperAccessParams
-	17, // 11: inference.inference.Params.participant_access_params:type_name -> inference.inference.ParticipantAccessParams
-	18, // 12: inference.inference.Params.transfer_agent_access_params:type_name -> inference.inference.TransferAgentAccessParams
-	21, // 13: inference.inference.Params.devshard_escrow_params:type_name -> inference.inference.DevshardEscrowParams
-	22, // 14: inference.inference.Params.fee_params:type_name -> inference.inference.FeeParams
-	19, // 15: inference.inference.Params.delegation_params:type_name -> inference.inference.DelegationParams
-	9,  // 16: inference.inference.GenesisOnlyParams.max_individual_power_percentage:type_name -> inference.inference.Decimal
-	9,  // 17: inference.inference.GenesisOnlyParams.genesis_guardian_multiplier:type_name -> inference.inference.Decimal
-	9,  // 18: inference.inference.TokenomicsParams.subsidy_reduction_interval:type_name -> inference.inference.Decimal
-	9,  // 19: inference.inference.TokenomicsParams.subsidy_reduction_amount:type_name -> inference.inference.Decimal
-	9,  // 20: inference.inference.TokenomicsParams.current_subsidy_percentage:type_name -> inference.inference.Decimal
-	9,  // 21: inference.inference.EpochParams.poc_slot_allocation:type_name -> inference.inference.Decimal
-	9,  // 22: inference.inference.ValidationParams.false_positive_rate:type_name -> inference.inference.Decimal
-	9,  // 23: inference.inference.ValidationParams.pass_value:type_name -> inference.inference.Decimal
-	9,  // 24: inference.inference.ValidationParams.min_validation_average:type_name -> inference.inference.Decimal
-	9,  // 25: inference.inference.ValidationParams.max_validation_average:type_name -> inference.inference.Decimal
-	9,  // 26: inference.inference.ValidationParams.min_validation_halfway:type_name -> inference.inference.Decimal
-	9,  // 27: inference.inference.ValidationParams.miss_percentage_cutoff:type_name -> inference.inference.Decimal
-	9,  // 28: inference.inference.ValidationParams.miss_requests_penalty:type_name -> inference.inference.Decimal
-	9,  // 29: inference.inference.ValidationParams.invalid_reputation_preserve:type_name -> inference.inference.Decimal
-	9,  // 30: inference.inference.ValidationParams.bad_participant_invalidation_rate:type_name -> inference.inference.Decimal
-	9,  // 31: inference.inference.ValidationParams.invalidation_h_threshold:type_name -> inference.inference.Decimal
-	9,  // 32: inference.inference.ValidationParams.downtime_good_percentage:type_name -> inference.inference.Decimal
-	9,  // 33: inference.inference.ValidationParams.downtime_bad_percentage:type_name -> inference.inference.Decimal
-	9,  // 34: inference.inference.ValidationParams.downtime_h_threshold:type_name -> inference.inference.Decimal
-	9,  // 35: inference.inference.ValidationParams.downtime_reputation_preserve:type_name -> inference.inference.Decimal
-	9,  // 36: inference.inference.ValidationParams.quick_failure_threshold:type_name -> inference.inference.Decimal
-	9,  // 37: inference.inference.ValidationParams.binom_test_p0:type_name -> inference.inference.Decimal
-	9,  // 38: inference.inference.PoCModelParams.ffn_dim_multiplier:type_name -> inference.inference.Decimal
-	9,  // 39: inference.inference.PoCModelParams.norm_eps:type_name -> inference.inference.Decimal
-	9,  // 40: inference.inference.PoCModelParams.r_target:type_name -> inference.inference.Decimal
-	9,  // 41: inference.inference.PoCStatTestParams.dist_threshold:type_name -> inference.inference.Decimal
-	9,  // 42: inference.inference.PoCStatTestParams.p_mismatch:type_name -> inference.inference.Decimal
-	9,  // 43: inference.inference.PoCStatTestParams.p_value_threshold:type_name -> inference.inference.Decimal
-	6,  // 44: inference.inference.PoCModelConfig.stat_test:type_name -> inference.inference.PoCStatTestParams
-	9,  // 45: inference.inference.PoCModelConfig.weight_scale_factor:type_name -> inference.inference.Decimal
-	9,  // 46: inference.inference.PocParams.weight_scale_factor:type_name -> inference.inference.Decimal
-	5,  // 47: inference.inference.PocParams.model_params:type_name -> inference.inference.PoCModelParams
-	6,  // 48: inference.inference.PocParams.stat_test:type_name -> inference.inference.PoCStatTestParams
-	7,  // 49: inference.inference.PocParams.models:type_name -> inference.inference.PoCModelConfig
-	9,  // 50: inference.inference.CollateralParams.slash_fraction_invalid:type_name -> inference.inference.Decimal
-	9,  // 51: inference.inference.CollateralParams.slash_fraction_downtime:type_name -> inference.inference.Decimal
-	9,  // 52: inference.inference.CollateralParams.downtime_missed_percentage_threshold:type_name -> inference.inference.Decimal
-	9,  // 53: inference.inference.CollateralParams.base_weight_ratio:type_name -> inference.inference.Decimal
-	9,  // 54: inference.inference.CollateralParams.collateral_per_weight_unit:type_name -> inference.inference.Decimal
-	9,  // 55: inference.inference.BitcoinRewardParams.decay_rate:type_name -> inference.inference.Decimal
-	9,  // 56: inference.inference.BitcoinRewardParams.utilization_bonus_factor:type_name -> inference.inference.Decimal
-	9,  // 57: inference.inference.BitcoinRewardParams.full_coverage_bonus_factor:type_name -> inference.inference.Decimal
-	9,  // 58: inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor:type_name -> inference.inference.Decimal
-	9,  // 59: inference.inference.DynamicPricingParams.stability_zone_lower_bound:type_name -> inference.inference.Decimal
-	9,  // 60: inference.inference.DynamicPricingParams.stability_zone_upper_bound:type_name -> inference.inference.Decimal
-	9,  // 61: inference.inference.DynamicPricingParams.price_elasticity:type_name -> inference.inference.Decimal
-	9,  // 62: inference.inference.BandwidthLimitsParams.kb_per_input_token:type_name -> inference.inference.Decimal
-	9,  // 63: inference.inference.BandwidthLimitsParams.kb_per_output_token:type_name -> inference.inference.Decimal
-	9,  // 64: inference.inference.ConfirmationPoCParams.alpha_threshold:type_name -> inference.inference.Decimal
-	9,  // 65: inference.inference.ConfirmationPoCParams.slash_fraction:type_name -> inference.inference.Decimal
-	9,  // 66: inference.inference.DelegationParams.refusal_penalty:type_name -> inference.inference.Decimal
-	9,  // 67: inference.inference.DelegationParams.no_participation_penalty:type_name -> inference.inference.Decimal
-	9,  // 68: inference.inference.DelegationParams.delegation_share:type_name -> inference.inference.Decimal
-	9,  // 69: inference.inference.DelegationParams.w_threshold:type_name -> inference.inference.Decimal
-	9,  // 70: inference.inference.DelegationParams.cap_factor:type_name -> inference.inference.Decimal
-	9,  // 71: inference.inference.DelegationParams.max_model_voting_power_percentage:type_name -> inference.inference.Decimal
-	20, // 72: inference.inference.DevshardEscrowParams.approved_versions:type_name -> inference.inference.DevshardApprovedVersion
-	73, // [73:73] is the sub-list for method output_type
-	73, // [73:73] is the sub-list for method input_type
-	73, // [73:73] is the sub-list for extension type_name
-	73, // [73:73] is the sub-list for extension extendee
-	0,  // [0:73] is the sub-list for field type_name
+	4,  // 0: inference.inference.Params.epoch_params:type_name -> inference.inference.EpochParams
+	5,  // 1: inference.inference.Params.validation_params:type_name -> inference.inference.ValidationParams
+	9,  // 2: inference.inference.Params.poc_params:type_name -> inference.inference.PocParams
+	3,  // 3: inference.inference.Params.tokenomics_params:type_name -> inference.inference.TokenomicsParams
+	11, // 4: inference.inference.Params.collateral_params:type_name -> inference.inference.CollateralParams
+	12, // 5: inference.inference.Params.bitcoin_reward_params:type_name -> inference.inference.BitcoinRewardParams
+	13, // 6: inference.inference.Params.dynamic_pricing_params:type_name -> inference.inference.DynamicPricingParams
+	14, // 7: inference.inference.Params.bandwidth_limits_params:type_name -> inference.inference.BandwidthLimitsParams
+	15, // 8: inference.inference.Params.confirmation_poc_params:type_name -> inference.inference.ConfirmationPoCParams
+	16, // 9: inference.inference.Params.genesis_guardian_params:type_name -> inference.inference.GenesisGuardianParams
+	17, // 10: inference.inference.Params.developer_access_params:type_name -> inference.inference.DeveloperAccessParams
+	18, // 11: inference.inference.Params.participant_access_params:type_name -> inference.inference.ParticipantAccessParams
+	19, // 12: inference.inference.Params.transfer_agent_access_params:type_name -> inference.inference.TransferAgentAccessParams
+	22, // 13: inference.inference.Params.devshard_escrow_params:type_name -> inference.inference.DevshardEscrowParams
+	23, // 14: inference.inference.Params.fee_params:type_name -> inference.inference.FeeParams
+	20, // 15: inference.inference.Params.delegation_params:type_name -> inference.inference.DelegationParams
+	1,  // 16: inference.inference.Params.maintenance_params:type_name -> inference.inference.MaintenanceParams
+	10, // 17: inference.inference.GenesisOnlyParams.max_individual_power_percentage:type_name -> inference.inference.Decimal
+	10, // 18: inference.inference.GenesisOnlyParams.genesis_guardian_multiplier:type_name -> inference.inference.Decimal
+	10, // 19: inference.inference.TokenomicsParams.subsidy_reduction_interval:type_name -> inference.inference.Decimal
+	10, // 20: inference.inference.TokenomicsParams.subsidy_reduction_amount:type_name -> inference.inference.Decimal
+	10, // 21: inference.inference.TokenomicsParams.current_subsidy_percentage:type_name -> inference.inference.Decimal
+	10, // 22: inference.inference.EpochParams.poc_slot_allocation:type_name -> inference.inference.Decimal
+	10, // 23: inference.inference.ValidationParams.false_positive_rate:type_name -> inference.inference.Decimal
+	10, // 24: inference.inference.ValidationParams.pass_value:type_name -> inference.inference.Decimal
+	10, // 25: inference.inference.ValidationParams.min_validation_average:type_name -> inference.inference.Decimal
+	10, // 26: inference.inference.ValidationParams.max_validation_average:type_name -> inference.inference.Decimal
+	10, // 27: inference.inference.ValidationParams.min_validation_halfway:type_name -> inference.inference.Decimal
+	10, // 28: inference.inference.ValidationParams.miss_percentage_cutoff:type_name -> inference.inference.Decimal
+	10, // 29: inference.inference.ValidationParams.miss_requests_penalty:type_name -> inference.inference.Decimal
+	10, // 30: inference.inference.ValidationParams.invalid_reputation_preserve:type_name -> inference.inference.Decimal
+	10, // 31: inference.inference.ValidationParams.bad_participant_invalidation_rate:type_name -> inference.inference.Decimal
+	10, // 32: inference.inference.ValidationParams.invalidation_h_threshold:type_name -> inference.inference.Decimal
+	10, // 33: inference.inference.ValidationParams.downtime_good_percentage:type_name -> inference.inference.Decimal
+	10, // 34: inference.inference.ValidationParams.downtime_bad_percentage:type_name -> inference.inference.Decimal
+	10, // 35: inference.inference.ValidationParams.downtime_h_threshold:type_name -> inference.inference.Decimal
+	10, // 36: inference.inference.ValidationParams.downtime_reputation_preserve:type_name -> inference.inference.Decimal
+	10, // 37: inference.inference.ValidationParams.quick_failure_threshold:type_name -> inference.inference.Decimal
+	10, // 38: inference.inference.ValidationParams.binom_test_p0:type_name -> inference.inference.Decimal
+	10, // 39: inference.inference.PoCModelParams.ffn_dim_multiplier:type_name -> inference.inference.Decimal
+	10, // 40: inference.inference.PoCModelParams.norm_eps:type_name -> inference.inference.Decimal
+	10, // 41: inference.inference.PoCModelParams.r_target:type_name -> inference.inference.Decimal
+	10, // 42: inference.inference.PoCStatTestParams.dist_threshold:type_name -> inference.inference.Decimal
+	10, // 43: inference.inference.PoCStatTestParams.p_mismatch:type_name -> inference.inference.Decimal
+	10, // 44: inference.inference.PoCStatTestParams.p_value_threshold:type_name -> inference.inference.Decimal
+	7,  // 45: inference.inference.PoCModelConfig.stat_test:type_name -> inference.inference.PoCStatTestParams
+	10, // 46: inference.inference.PoCModelConfig.weight_scale_factor:type_name -> inference.inference.Decimal
+	10, // 47: inference.inference.PocParams.weight_scale_factor:type_name -> inference.inference.Decimal
+	6,  // 48: inference.inference.PocParams.model_params:type_name -> inference.inference.PoCModelParams
+	7,  // 49: inference.inference.PocParams.stat_test:type_name -> inference.inference.PoCStatTestParams
+	8,  // 50: inference.inference.PocParams.models:type_name -> inference.inference.PoCModelConfig
+	10, // 51: inference.inference.CollateralParams.slash_fraction_invalid:type_name -> inference.inference.Decimal
+	10, // 52: inference.inference.CollateralParams.slash_fraction_downtime:type_name -> inference.inference.Decimal
+	10, // 53: inference.inference.CollateralParams.downtime_missed_percentage_threshold:type_name -> inference.inference.Decimal
+	10, // 54: inference.inference.CollateralParams.base_weight_ratio:type_name -> inference.inference.Decimal
+	10, // 55: inference.inference.CollateralParams.collateral_per_weight_unit:type_name -> inference.inference.Decimal
+	10, // 56: inference.inference.BitcoinRewardParams.decay_rate:type_name -> inference.inference.Decimal
+	10, // 57: inference.inference.BitcoinRewardParams.utilization_bonus_factor:type_name -> inference.inference.Decimal
+	10, // 58: inference.inference.BitcoinRewardParams.full_coverage_bonus_factor:type_name -> inference.inference.Decimal
+	10, // 59: inference.inference.BitcoinRewardParams.partial_coverage_bonus_factor:type_name -> inference.inference.Decimal
+	10, // 60: inference.inference.DynamicPricingParams.stability_zone_lower_bound:type_name -> inference.inference.Decimal
+	10, // 61: inference.inference.DynamicPricingParams.stability_zone_upper_bound:type_name -> inference.inference.Decimal
+	10, // 62: inference.inference.DynamicPricingParams.price_elasticity:type_name -> inference.inference.Decimal
+	10, // 63: inference.inference.BandwidthLimitsParams.kb_per_input_token:type_name -> inference.inference.Decimal
+	10, // 64: inference.inference.BandwidthLimitsParams.kb_per_output_token:type_name -> inference.inference.Decimal
+	10, // 65: inference.inference.ConfirmationPoCParams.alpha_threshold:type_name -> inference.inference.Decimal
+	10, // 66: inference.inference.ConfirmationPoCParams.slash_fraction:type_name -> inference.inference.Decimal
+	10, // 67: inference.inference.DelegationParams.refusal_penalty:type_name -> inference.inference.Decimal
+	10, // 68: inference.inference.DelegationParams.no_participation_penalty:type_name -> inference.inference.Decimal
+	10, // 69: inference.inference.DelegationParams.delegation_share:type_name -> inference.inference.Decimal
+	10, // 70: inference.inference.DelegationParams.w_threshold:type_name -> inference.inference.Decimal
+	10, // 71: inference.inference.DelegationParams.cap_factor:type_name -> inference.inference.Decimal
+	10, // 72: inference.inference.DelegationParams.max_model_voting_power_percentage:type_name -> inference.inference.Decimal
+	21, // 73: inference.inference.DevshardEscrowParams.approved_versions:type_name -> inference.inference.DevshardApprovedVersion
+	74, // [74:74] is the sub-list for method output_type
+	74, // [74:74] is the sub-list for method input_type
+	74, // [74:74] is the sub-list for extension type_name
+	74, // [74:74] is the sub-list for extension extendee
+	0,  // [0:74] is the sub-list for field type_name
 }
 
 func init() { file_inference_inference_params_proto_init() }
@@ -23234,7 +24158,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GenesisOnlyParams); i {
+			switch v := v.(*MaintenanceParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23246,7 +24170,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*TokenomicsParams); i {
+			switch v := v.(*GenesisOnlyParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23258,7 +24182,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*EpochParams); i {
+			switch v := v.(*TokenomicsParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23270,7 +24194,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ValidationParams); i {
+			switch v := v.(*EpochParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23282,7 +24206,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCModelParams); i {
+			switch v := v.(*ValidationParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23294,7 +24218,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCStatTestParams); i {
+			switch v := v.(*PoCModelParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23306,7 +24230,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCModelConfig); i {
+			switch v := v.(*PoCStatTestParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23318,7 +24242,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PocParams); i {
+			switch v := v.(*PoCModelConfig); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23330,7 +24254,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Decimal); i {
+			switch v := v.(*PocParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23342,7 +24266,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*CollateralParams); i {
+			switch v := v.(*Decimal); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23354,7 +24278,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BitcoinRewardParams); i {
+			switch v := v.(*CollateralParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23366,7 +24290,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DynamicPricingParams); i {
+			switch v := v.(*BitcoinRewardParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23378,7 +24302,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*BandwidthLimitsParams); i {
+			switch v := v.(*DynamicPricingParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23390,7 +24314,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ConfirmationPoCParams); i {
+			switch v := v.(*BandwidthLimitsParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23402,7 +24326,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GenesisGuardianParams); i {
+			switch v := v.(*ConfirmationPoCParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23414,7 +24338,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DeveloperAccessParams); i {
+			switch v := v.(*GenesisGuardianParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23426,7 +24350,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ParticipantAccessParams); i {
+			switch v := v.(*DeveloperAccessParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23438,7 +24362,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*TransferAgentAccessParams); i {
+			switch v := v.(*ParticipantAccessParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23450,7 +24374,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DelegationParams); i {
+			switch v := v.(*TransferAgentAccessParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23462,7 +24386,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DevshardApprovedVersion); i {
+			switch v := v.(*DelegationParams); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23474,7 +24398,7 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DevshardEscrowParams); i {
+			switch v := v.(*DevshardApprovedVersion); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -23486,6 +24410,18 @@ func file_inference_inference_params_proto_init() {
 			}
 		}
 		file_inference_inference_params_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DevshardEscrowParams); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_params_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*FeeParams); i {
 			case 0:
 				return &v.state
@@ -23504,7 +24440,7 @@ func file_inference_inference_params_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_inference_inference_params_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   23,
+			NumMessages:   24,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/inference-chain/api/inference/inference/poc_delegation.pulsar.go b/inference-chain/api/inference/inference/poc_delegation.pulsar.go
index ecb299cd66..e06d522ac3 100644
--- a/inference-chain/api/inference/inference/poc_delegation.pulsar.go
+++ b/inference-chain/api/inference/inference/poc_delegation.pulsar.go
@@ -4324,6 +4324,1812 @@ func (x *fastReflection_BootstrapDelegationSnapshot) ProtoMethods() *protoiface.
 	}
 }
 
+var (
+	md_DelegationRewardTransfer          protoreflect.MessageDescriptor
+	fd_DelegationRewardTransfer_model_id protoreflect.FieldDescriptor
+	fd_DelegationRewardTransfer_from     protoreflect.FieldDescriptor
+	fd_DelegationRewardTransfer_to       protoreflect.FieldDescriptor
+	fd_DelegationRewardTransfer_share    protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_poc_delegation_proto_init()
+	md_DelegationRewardTransfer = File_inference_inference_poc_delegation_proto.Messages().ByName("DelegationRewardTransfer")
+	fd_DelegationRewardTransfer_model_id = md_DelegationRewardTransfer.Fields().ByName("model_id")
+	fd_DelegationRewardTransfer_from = md_DelegationRewardTransfer.Fields().ByName("from")
+	fd_DelegationRewardTransfer_to = md_DelegationRewardTransfer.Fields().ByName("to")
+	fd_DelegationRewardTransfer_share = md_DelegationRewardTransfer.Fields().ByName("share")
+}
+
+var _ protoreflect.Message = (*fastReflection_DelegationRewardTransfer)(nil)
+
+type fastReflection_DelegationRewardTransfer DelegationRewardTransfer
+
+func (x *DelegationRewardTransfer) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DelegationRewardTransfer)(x)
+}
+
+func (x *DelegationRewardTransfer) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DelegationRewardTransfer_messageType fastReflection_DelegationRewardTransfer_messageType
+var _ protoreflect.MessageType = fastReflection_DelegationRewardTransfer_messageType{}
+
+type fastReflection_DelegationRewardTransfer_messageType struct{}
+
+func (x fastReflection_DelegationRewardTransfer_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DelegationRewardTransfer)(nil)
+}
+func (x fastReflection_DelegationRewardTransfer_messageType) New() protoreflect.Message {
+	return new(fastReflection_DelegationRewardTransfer)
+}
+func (x fastReflection_DelegationRewardTransfer_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationRewardTransfer
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DelegationRewardTransfer) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationRewardTransfer
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DelegationRewardTransfer) Type() protoreflect.MessageType {
+	return _fastReflection_DelegationRewardTransfer_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DelegationRewardTransfer) New() protoreflect.Message {
+	return new(fastReflection_DelegationRewardTransfer)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DelegationRewardTransfer) Interface() protoreflect.ProtoMessage {
+	return (*DelegationRewardTransfer)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DelegationRewardTransfer) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_DelegationRewardTransfer_model_id, value) {
+			return
+		}
+	}
+	if x.From != "" {
+		value := protoreflect.ValueOfString(x.From)
+		if !f(fd_DelegationRewardTransfer_from, value) {
+			return
+		}
+	}
+	if x.To != "" {
+		value := protoreflect.ValueOfString(x.To)
+		if !f(fd_DelegationRewardTransfer_to, value) {
+			return
+		}
+	}
+	if x.Share != nil {
+		value := protoreflect.ValueOfMessage(x.Share.ProtoReflect())
+		if !f(fd_DelegationRewardTransfer_share, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DelegationRewardTransfer) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransfer.model_id":
+		return x.ModelId != ""
+	case "inference.inference.DelegationRewardTransfer.from":
+		return x.From != ""
+	case "inference.inference.DelegationRewardTransfer.to":
+		return x.To != ""
+	case "inference.inference.DelegationRewardTransfer.share":
+		return x.Share != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransfer"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransfer does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransfer) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransfer.model_id":
+		x.ModelId = ""
+	case "inference.inference.DelegationRewardTransfer.from":
+		x.From = ""
+	case "inference.inference.DelegationRewardTransfer.to":
+		x.To = ""
+	case "inference.inference.DelegationRewardTransfer.share":
+		x.Share = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransfer"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransfer does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DelegationRewardTransfer) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.DelegationRewardTransfer.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.DelegationRewardTransfer.from":
+		value := x.From
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.DelegationRewardTransfer.to":
+		value := x.To
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.DelegationRewardTransfer.share":
+		value := x.Share
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransfer"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransfer does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransfer) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransfer.model_id":
+		x.ModelId = value.Interface().(string)
+	case "inference.inference.DelegationRewardTransfer.from":
+		x.From = value.Interface().(string)
+	case "inference.inference.DelegationRewardTransfer.to":
+		x.To = value.Interface().(string)
+	case "inference.inference.DelegationRewardTransfer.share":
+		x.Share = value.Message().Interface().(*Decimal)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransfer"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransfer does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransfer) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransfer.share":
+		if x.Share == nil {
+			x.Share = new(Decimal)
+		}
+		return protoreflect.ValueOfMessage(x.Share.ProtoReflect())
+	case "inference.inference.DelegationRewardTransfer.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.DelegationRewardTransfer is not mutable"))
+	case "inference.inference.DelegationRewardTransfer.from":
+		panic(fmt.Errorf("field from of message inference.inference.DelegationRewardTransfer is not mutable"))
+	case "inference.inference.DelegationRewardTransfer.to":
+		panic(fmt.Errorf("field to of message inference.inference.DelegationRewardTransfer is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransfer"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransfer does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DelegationRewardTransfer) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransfer.model_id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.DelegationRewardTransfer.from":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.DelegationRewardTransfer.to":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.DelegationRewardTransfer.share":
+		m := new(Decimal)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransfer"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransfer does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DelegationRewardTransfer) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.DelegationRewardTransfer", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DelegationRewardTransfer) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransfer) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DelegationRewardTransfer) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DelegationRewardTransfer) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DelegationRewardTransfer)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.From)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.To)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Share != nil {
+			l = options.Size(x.Share)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationRewardTransfer)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Share != nil {
+			encoded, err := options.Marshal(x.Share)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.To) > 0 {
+			i -= len(x.To)
+			copy(dAtA[i:], x.To)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.To)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.From) > 0 {
+			i -= len(x.From)
+			copy(dAtA[i:], x.From)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.From)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationRewardTransfer)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationRewardTransfer: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationRewardTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.From = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.To = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Share", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Share == nil {
+					x.Share = &Decimal{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Share); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_DelegationRewardPenalty                  protoreflect.MessageDescriptor
+	fd_DelegationRewardPenalty_participant      protoreflect.FieldDescriptor
+	fd_DelegationRewardPenalty_penalty_fraction protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_poc_delegation_proto_init()
+	md_DelegationRewardPenalty = File_inference_inference_poc_delegation_proto.Messages().ByName("DelegationRewardPenalty")
+	fd_DelegationRewardPenalty_participant = md_DelegationRewardPenalty.Fields().ByName("participant")
+	fd_DelegationRewardPenalty_penalty_fraction = md_DelegationRewardPenalty.Fields().ByName("penalty_fraction")
+}
+
+var _ protoreflect.Message = (*fastReflection_DelegationRewardPenalty)(nil)
+
+type fastReflection_DelegationRewardPenalty DelegationRewardPenalty
+
+func (x *DelegationRewardPenalty) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DelegationRewardPenalty)(x)
+}
+
+func (x *DelegationRewardPenalty) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DelegationRewardPenalty_messageType fastReflection_DelegationRewardPenalty_messageType
+var _ protoreflect.MessageType = fastReflection_DelegationRewardPenalty_messageType{}
+
+type fastReflection_DelegationRewardPenalty_messageType struct{}
+
+func (x fastReflection_DelegationRewardPenalty_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DelegationRewardPenalty)(nil)
+}
+func (x fastReflection_DelegationRewardPenalty_messageType) New() protoreflect.Message {
+	return new(fastReflection_DelegationRewardPenalty)
+}
+func (x fastReflection_DelegationRewardPenalty_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationRewardPenalty
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DelegationRewardPenalty) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationRewardPenalty
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DelegationRewardPenalty) Type() protoreflect.MessageType {
+	return _fastReflection_DelegationRewardPenalty_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DelegationRewardPenalty) New() protoreflect.Message {
+	return new(fastReflection_DelegationRewardPenalty)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DelegationRewardPenalty) Interface() protoreflect.ProtoMessage {
+	return (*DelegationRewardPenalty)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DelegationRewardPenalty) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_DelegationRewardPenalty_participant, value) {
+			return
+		}
+	}
+	if x.PenaltyFraction != nil {
+		value := protoreflect.ValueOfMessage(x.PenaltyFraction.ProtoReflect())
+		if !f(fd_DelegationRewardPenalty_penalty_fraction, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DelegationRewardPenalty) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardPenalty.participant":
+		return x.Participant != ""
+	case "inference.inference.DelegationRewardPenalty.penalty_fraction":
+		return x.PenaltyFraction != nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardPenalty"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardPenalty does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardPenalty) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardPenalty.participant":
+		x.Participant = ""
+	case "inference.inference.DelegationRewardPenalty.penalty_fraction":
+		x.PenaltyFraction = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardPenalty"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardPenalty does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DelegationRewardPenalty) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.DelegationRewardPenalty.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.DelegationRewardPenalty.penalty_fraction":
+		value := x.PenaltyFraction
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardPenalty"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardPenalty does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardPenalty) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardPenalty.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.DelegationRewardPenalty.penalty_fraction":
+		x.PenaltyFraction = value.Message().Interface().(*Decimal)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardPenalty"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardPenalty does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardPenalty) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardPenalty.penalty_fraction":
+		if x.PenaltyFraction == nil {
+			x.PenaltyFraction = new(Decimal)
+		}
+		return protoreflect.ValueOfMessage(x.PenaltyFraction.ProtoReflect())
+	case "inference.inference.DelegationRewardPenalty.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.DelegationRewardPenalty is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardPenalty"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardPenalty does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DelegationRewardPenalty) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardPenalty.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.DelegationRewardPenalty.penalty_fraction":
+		m := new(Decimal)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardPenalty"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardPenalty does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DelegationRewardPenalty) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.DelegationRewardPenalty", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DelegationRewardPenalty) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardPenalty) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DelegationRewardPenalty) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DelegationRewardPenalty) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DelegationRewardPenalty)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.PenaltyFraction != nil {
+			l = options.Size(x.PenaltyFraction)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationRewardPenalty)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.PenaltyFraction != nil {
+			encoded, err := options.Marshal(x.PenaltyFraction)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationRewardPenalty)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationRewardPenalty: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationRewardPenalty: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PenaltyFraction", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.PenaltyFraction == nil {
+					x.PenaltyFraction = &Decimal{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PenaltyFraction); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_DelegationRewardTransferSnapshot_2_list)(nil)
+
+type _DelegationRewardTransferSnapshot_2_list struct {
+	list *[]*DelegationRewardTransfer
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationRewardTransfer)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationRewardTransfer)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) AppendMutable() protoreflect.Value {
+	v := new(DelegationRewardTransfer)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) NewElement() protoreflect.Value {
+	v := new(DelegationRewardTransfer)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DelegationRewardTransferSnapshot_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_DelegationRewardTransferSnapshot_3_list)(nil)
+
+type _DelegationRewardTransferSnapshot_3_list struct {
+	list *[]*DelegationRewardPenalty
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationRewardPenalty)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DelegationRewardPenalty)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) AppendMutable() protoreflect.Value {
+	v := new(DelegationRewardPenalty)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) NewElement() protoreflect.Value {
+	v := new(DelegationRewardPenalty)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_DelegationRewardTransferSnapshot_3_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_DelegationRewardTransferSnapshot             protoreflect.MessageDescriptor
+	fd_DelegationRewardTransferSnapshot_epoch_index protoreflect.FieldDescriptor
+	fd_DelegationRewardTransferSnapshot_transfers   protoreflect.FieldDescriptor
+	fd_DelegationRewardTransferSnapshot_penalties   protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_poc_delegation_proto_init()
+	md_DelegationRewardTransferSnapshot = File_inference_inference_poc_delegation_proto.Messages().ByName("DelegationRewardTransferSnapshot")
+	fd_DelegationRewardTransferSnapshot_epoch_index = md_DelegationRewardTransferSnapshot.Fields().ByName("epoch_index")
+	fd_DelegationRewardTransferSnapshot_transfers = md_DelegationRewardTransferSnapshot.Fields().ByName("transfers")
+	fd_DelegationRewardTransferSnapshot_penalties = md_DelegationRewardTransferSnapshot.Fields().ByName("penalties")
+}
+
+var _ protoreflect.Message = (*fastReflection_DelegationRewardTransferSnapshot)(nil)
+
+type fastReflection_DelegationRewardTransferSnapshot DelegationRewardTransferSnapshot
+
+func (x *DelegationRewardTransferSnapshot) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_DelegationRewardTransferSnapshot)(x)
+}
+
+func (x *DelegationRewardTransferSnapshot) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[9]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_DelegationRewardTransferSnapshot_messageType fastReflection_DelegationRewardTransferSnapshot_messageType
+var _ protoreflect.MessageType = fastReflection_DelegationRewardTransferSnapshot_messageType{}
+
+type fastReflection_DelegationRewardTransferSnapshot_messageType struct{}
+
+func (x fastReflection_DelegationRewardTransferSnapshot_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_DelegationRewardTransferSnapshot)(nil)
+}
+func (x fastReflection_DelegationRewardTransferSnapshot_messageType) New() protoreflect.Message {
+	return new(fastReflection_DelegationRewardTransferSnapshot)
+}
+func (x fastReflection_DelegationRewardTransferSnapshot_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationRewardTransferSnapshot
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Descriptor() protoreflect.MessageDescriptor {
+	return md_DelegationRewardTransferSnapshot
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Type() protoreflect.MessageType {
+	return _fastReflection_DelegationRewardTransferSnapshot_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_DelegationRewardTransferSnapshot) New() protoreflect.Message {
+	return new(fastReflection_DelegationRewardTransferSnapshot)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Interface() protoreflect.ProtoMessage {
+	return (*DelegationRewardTransferSnapshot)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_DelegationRewardTransferSnapshot_epoch_index, value) {
+			return
+		}
+	}
+	if len(x.Transfers) != 0 {
+		value := protoreflect.ValueOfList(&_DelegationRewardTransferSnapshot_2_list{list: &x.Transfers})
+		if !f(fd_DelegationRewardTransferSnapshot_transfers, value) {
+			return
+		}
+	}
+	if len(x.Penalties) != 0 {
+		value := protoreflect.ValueOfList(&_DelegationRewardTransferSnapshot_3_list{list: &x.Penalties})
+		if !f(fd_DelegationRewardTransferSnapshot_penalties, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransferSnapshot.epoch_index":
+		return x.EpochIndex != uint64(0)
+	case "inference.inference.DelegationRewardTransferSnapshot.transfers":
+		return len(x.Transfers) != 0
+	case "inference.inference.DelegationRewardTransferSnapshot.penalties":
+		return len(x.Penalties) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransferSnapshot"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransferSnapshot does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransferSnapshot.epoch_index":
+		x.EpochIndex = uint64(0)
+	case "inference.inference.DelegationRewardTransferSnapshot.transfers":
+		x.Transfers = nil
+	case "inference.inference.DelegationRewardTransferSnapshot.penalties":
+		x.Penalties = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransferSnapshot"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransferSnapshot does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.DelegationRewardTransferSnapshot.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.DelegationRewardTransferSnapshot.transfers":
+		if len(x.Transfers) == 0 {
+			return protoreflect.ValueOfList(&_DelegationRewardTransferSnapshot_2_list{})
+		}
+		listValue := &_DelegationRewardTransferSnapshot_2_list{list: &x.Transfers}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.DelegationRewardTransferSnapshot.penalties":
+		if len(x.Penalties) == 0 {
+			return protoreflect.ValueOfList(&_DelegationRewardTransferSnapshot_3_list{})
+		}
+		listValue := &_DelegationRewardTransferSnapshot_3_list{list: &x.Penalties}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransferSnapshot"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransferSnapshot does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransferSnapshot.epoch_index":
+		x.EpochIndex = value.Uint()
+	case "inference.inference.DelegationRewardTransferSnapshot.transfers":
+		lv := value.List()
+		clv := lv.(*_DelegationRewardTransferSnapshot_2_list)
+		x.Transfers = *clv.list
+	case "inference.inference.DelegationRewardTransferSnapshot.penalties":
+		lv := value.List()
+		clv := lv.(*_DelegationRewardTransferSnapshot_3_list)
+		x.Penalties = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransferSnapshot"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransferSnapshot does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransferSnapshot) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransferSnapshot.transfers":
+		if x.Transfers == nil {
+			x.Transfers = []*DelegationRewardTransfer{}
+		}
+		value := &_DelegationRewardTransferSnapshot_2_list{list: &x.Transfers}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.DelegationRewardTransferSnapshot.penalties":
+		if x.Penalties == nil {
+			x.Penalties = []*DelegationRewardPenalty{}
+		}
+		value := &_DelegationRewardTransferSnapshot_3_list{list: &x.Penalties}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.DelegationRewardTransferSnapshot.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.DelegationRewardTransferSnapshot is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransferSnapshot"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransferSnapshot does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_DelegationRewardTransferSnapshot) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.DelegationRewardTransferSnapshot.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.DelegationRewardTransferSnapshot.transfers":
+		list := []*DelegationRewardTransfer{}
+		return protoreflect.ValueOfList(&_DelegationRewardTransferSnapshot_2_list{list: &list})
+	case "inference.inference.DelegationRewardTransferSnapshot.penalties":
+		list := []*DelegationRewardPenalty{}
+		return protoreflect.ValueOfList(&_DelegationRewardTransferSnapshot_3_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.DelegationRewardTransferSnapshot"))
+		}
+		panic(fmt.Errorf("message inference.inference.DelegationRewardTransferSnapshot does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_DelegationRewardTransferSnapshot) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.DelegationRewardTransferSnapshot", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_DelegationRewardTransferSnapshot) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_DelegationRewardTransferSnapshot) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_DelegationRewardTransferSnapshot) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_DelegationRewardTransferSnapshot) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*DelegationRewardTransferSnapshot)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
+		if len(x.Transfers) > 0 {
+			for _, e := range x.Transfers {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if len(x.Penalties) > 0 {
+			for _, e := range x.Penalties {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationRewardTransferSnapshot)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Penalties) > 0 {
+			for iNdEx := len(x.Penalties) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Penalties[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x1a
+			}
+		}
+		if len(x.Transfers) > 0 {
+			for iNdEx := len(x.Transfers) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Transfers[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*DelegationRewardTransferSnapshot)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationRewardTransferSnapshot: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: DelegationRewardTransferSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				}
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Transfers", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Transfers = append(x.Transfers, &DelegationRewardTransfer{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Transfers[len(x.Transfers)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Penalties", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Penalties = append(x.Penalties, &DelegationRewardPenalty{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Penalties[len(x.Penalties)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
 var (
 	md_MsgSetPoCDelegation             protoreflect.MessageDescriptor
 	fd_MsgSetPoCDelegation_sender      protoreflect.FieldDescriptor
@@ -4348,7 +6154,7 @@ func (x *MsgSetPoCDelegation) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgSetPoCDelegation) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[7]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[10]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -4890,7 +6696,7 @@ func (x *MsgSetPoCDelegationResponse) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgSetPoCDelegationResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[8]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[11]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -5250,7 +7056,7 @@ func (x *MsgRefusePoCDelegation) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgRefusePoCDelegation) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[9]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[12]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -5730,7 +7536,7 @@ func (x *MsgRefusePoCDelegationResponse) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgRefusePoCDelegationResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[10]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[13]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -6090,7 +7896,7 @@ func (x *MsgDeclarePoCIntent) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgDeclarePoCIntent) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[11]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[14]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -6570,7 +8376,7 @@ func (x *MsgDeclarePoCIntentResponse) ProtoReflect() protoreflect.Message {
 }
 
 func (x *MsgDeclarePoCIntentResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[12]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -6930,7 +8736,7 @@ func (x *QueryPoCDelegationRequest) ProtoReflect() protoreflect.Message {
 }
 
 func (x *QueryPoCDelegationRequest) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[13]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -7569,7 +9375,7 @@ func (x *QueryPoCDelegationResponse) ProtoReflect() protoreflect.Message {
 }
 
 func (x *QueryPoCDelegationResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_poc_delegation_proto_msgTypes[14]
+	mi := &file_inference_inference_poc_delegation_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -8570,6 +10376,159 @@ func (x *BootstrapDelegationSnapshot) GetPreeligibility() []*BootstrapModelPreEl
 	return nil
 }
 
+type DelegationRewardTransfer struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ModelId string   `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	From    string   `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
+	To      string   `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
+	Share   *Decimal `protobuf:"bytes,4,opt,name=share,proto3" json:"share,omitempty"`
+}
+
+func (x *DelegationRewardTransfer) Reset() {
+	*x = DelegationRewardTransfer{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DelegationRewardTransfer) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DelegationRewardTransfer) ProtoMessage() {}
+
+// Deprecated: Use DelegationRewardTransfer.ProtoReflect.Descriptor instead.
+func (*DelegationRewardTransfer) Descriptor() ([]byte, []int) {
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *DelegationRewardTransfer) GetModelId() string {
+	if x != nil {
+		return x.ModelId
+	}
+	return ""
+}
+
+func (x *DelegationRewardTransfer) GetFrom() string {
+	if x != nil {
+		return x.From
+	}
+	return ""
+}
+
+func (x *DelegationRewardTransfer) GetTo() string {
+	if x != nil {
+		return x.To
+	}
+	return ""
+}
+
+func (x *DelegationRewardTransfer) GetShare() *Decimal {
+	if x != nil {
+		return x.Share
+	}
+	return nil
+}
+
+type DelegationRewardPenalty struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Participant     string   `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	PenaltyFraction *Decimal `protobuf:"bytes,2,opt,name=penalty_fraction,json=penaltyFraction,proto3" json:"penalty_fraction,omitempty"`
+}
+
+func (x *DelegationRewardPenalty) Reset() {
+	*x = DelegationRewardPenalty{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DelegationRewardPenalty) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DelegationRewardPenalty) ProtoMessage() {}
+
+// Deprecated: Use DelegationRewardPenalty.ProtoReflect.Descriptor instead.
+func (*DelegationRewardPenalty) Descriptor() ([]byte, []int) {
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *DelegationRewardPenalty) GetParticipant() string {
+	if x != nil {
+		return x.Participant
+	}
+	return ""
+}
+
+func (x *DelegationRewardPenalty) GetPenaltyFraction() *Decimal {
+	if x != nil {
+		return x.PenaltyFraction
+	}
+	return nil
+}
+
+type DelegationRewardTransferSnapshot struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	EpochIndex uint64                      `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	Transfers  []*DelegationRewardTransfer `protobuf:"bytes,2,rep,name=transfers,proto3" json:"transfers,omitempty"`
+	Penalties  []*DelegationRewardPenalty  `protobuf:"bytes,3,rep,name=penalties,proto3" json:"penalties,omitempty"`
+}
+
+func (x *DelegationRewardTransferSnapshot) Reset() {
+	*x = DelegationRewardTransferSnapshot{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DelegationRewardTransferSnapshot) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DelegationRewardTransferSnapshot) ProtoMessage() {}
+
+// Deprecated: Use DelegationRewardTransferSnapshot.ProtoReflect.Descriptor instead.
+func (*DelegationRewardTransferSnapshot) Descriptor() ([]byte, []int) {
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *DelegationRewardTransferSnapshot) GetEpochIndex() uint64 {
+	if x != nil {
+		return x.EpochIndex
+	}
+	return 0
+}
+
+func (x *DelegationRewardTransferSnapshot) GetTransfers() []*DelegationRewardTransfer {
+	if x != nil {
+		return x.Transfers
+	}
+	return nil
+}
+
+func (x *DelegationRewardTransferSnapshot) GetPenalties() []*DelegationRewardPenalty {
+	if x != nil {
+		return x.Penalties
+	}
+	return nil
+}
+
 type MsgSetPoCDelegation struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -8583,7 +10542,7 @@ type MsgSetPoCDelegation struct {
 func (x *MsgSetPoCDelegation) Reset() {
 	*x = MsgSetPoCDelegation{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[7]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[10]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8597,7 +10556,7 @@ func (*MsgSetPoCDelegation) ProtoMessage() {}
 
 // Deprecated: Use MsgSetPoCDelegation.ProtoReflect.Descriptor instead.
 func (*MsgSetPoCDelegation) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{7}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{10}
 }
 
 func (x *MsgSetPoCDelegation) GetSender() string {
@@ -8630,7 +10589,7 @@ type MsgSetPoCDelegationResponse struct {
 func (x *MsgSetPoCDelegationResponse) Reset() {
 	*x = MsgSetPoCDelegationResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[8]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[11]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8644,7 +10603,7 @@ func (*MsgSetPoCDelegationResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSetPoCDelegationResponse.ProtoReflect.Descriptor instead.
 func (*MsgSetPoCDelegationResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{8}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{11}
 }
 
 type MsgRefusePoCDelegation struct {
@@ -8659,7 +10618,7 @@ type MsgRefusePoCDelegation struct {
 func (x *MsgRefusePoCDelegation) Reset() {
 	*x = MsgRefusePoCDelegation{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[9]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[12]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8673,7 +10632,7 @@ func (*MsgRefusePoCDelegation) ProtoMessage() {}
 
 // Deprecated: Use MsgRefusePoCDelegation.ProtoReflect.Descriptor instead.
 func (*MsgRefusePoCDelegation) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{9}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *MsgRefusePoCDelegation) GetSender() string {
@@ -8699,7 +10658,7 @@ type MsgRefusePoCDelegationResponse struct {
 func (x *MsgRefusePoCDelegationResponse) Reset() {
 	*x = MsgRefusePoCDelegationResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[10]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[13]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8713,7 +10672,7 @@ func (*MsgRefusePoCDelegationResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRefusePoCDelegationResponse.ProtoReflect.Descriptor instead.
 func (*MsgRefusePoCDelegationResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{10}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{13}
 }
 
 type MsgDeclarePoCIntent struct {
@@ -8728,7 +10687,7 @@ type MsgDeclarePoCIntent struct {
 func (x *MsgDeclarePoCIntent) Reset() {
 	*x = MsgDeclarePoCIntent{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[11]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8742,7 +10701,7 @@ func (*MsgDeclarePoCIntent) ProtoMessage() {}
 
 // Deprecated: Use MsgDeclarePoCIntent.ProtoReflect.Descriptor instead.
 func (*MsgDeclarePoCIntent) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{11}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{14}
 }
 
 func (x *MsgDeclarePoCIntent) GetSender() string {
@@ -8768,7 +10727,7 @@ type MsgDeclarePoCIntentResponse struct {
 func (x *MsgDeclarePoCIntentResponse) Reset() {
 	*x = MsgDeclarePoCIntentResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[12]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8782,7 +10741,7 @@ func (*MsgDeclarePoCIntentResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgDeclarePoCIntentResponse.ProtoReflect.Descriptor instead.
 func (*MsgDeclarePoCIntentResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{12}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{15}
 }
 
 type QueryPoCDelegationRequest struct {
@@ -8797,7 +10756,7 @@ type QueryPoCDelegationRequest struct {
 func (x *QueryPoCDelegationRequest) Reset() {
 	*x = QueryPoCDelegationRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[13]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8811,7 +10770,7 @@ func (*QueryPoCDelegationRequest) ProtoMessage() {}
 
 // Deprecated: Use QueryPoCDelegationRequest.ProtoReflect.Descriptor instead.
 func (*QueryPoCDelegationRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{13}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *QueryPoCDelegationRequest) GetParticipant() string {
@@ -8841,7 +10800,7 @@ type QueryPoCDelegationResponse struct {
 func (x *QueryPoCDelegationResponse) Reset() {
 	*x = QueryPoCDelegationResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_poc_delegation_proto_msgTypes[14]
+		mi := &file_inference_inference_poc_delegation_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -8855,7 +10814,7 @@ func (*QueryPoCDelegationResponse) ProtoMessage() {}
 
 // Deprecated: Use QueryPoCDelegationResponse.ProtoReflect.Descriptor instead.
 func (*QueryPoCDelegationResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{14}
+	return file_inference_inference_poc_delegation_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *QueryPoCDelegationResponse) GetDelegations() []*PoCDelegation {
@@ -8889,142 +10848,175 @@ var file_inference_inference_poc_delegation_proto_rawDesc = []byte{
 	0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d,
 	0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
 	0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x22, 0x69, 0x0a, 0x0d, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12,
-	0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a,
-	0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x54, 0x6f, 0x22, 0x49,
-	0x0a, 0x0a, 0x50, 0x6f, 0x43, 0x52, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x12, 0x19, 0x0a, 0x08,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x4e, 0x0a, 0x0f, 0x50, 0x6f, 0x43,
-	0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x50, 0x0a, 0x10, 0x4d, 0x6f, 0x64,
-	0x65, 0x6c, 0x56, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x19, 0x0a,
-	0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x76, 0x6f, 0x74, 0x69,
-	0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b,
-	0x76, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x22, 0xc0, 0x01, 0x0a, 0x12,
-	0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
-	0x6f, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x68,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x6e, 0x61,
-	0x70, 0x73, 0x68, 0x6f, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x44, 0x0a, 0x0b, 0x64,
-	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x3b, 0x0a, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x73, 0x18, 0x03, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x52, 0x65, 0x66,
-	0x75, 0x73, 0x61, 0x6c, 0x52, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x73, 0x22, 0xe8,
-	0x02, 0x0a, 0x1c, 0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x4d, 0x6f, 0x64, 0x65,
-	0x6c, 0x50, 0x72, 0x65, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12,
-	0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x72,
-	0x65, 0x5f, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
-	0x52, 0x0b, 0x70, 0x72, 0x65, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x12, 0x34, 0x0a,
-	0x16, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x74, 0x68,
-	0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x6d,
-	0x65, 0x65, 0x74, 0x73, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68,
-	0x6f, 0x6c, 0x64, 0x12, 0x1e, 0x0a, 0x0b, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x76, 0x5f, 0x6d,
-	0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x56,
-	0x4d, 0x69, 0x6e, 0x12, 0x2d, 0x0a, 0x12, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x72, 0x65, 0x61,
-	0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x11, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69,
-	0x74, 0x79, 0x12, 0x2a, 0x0a, 0x11, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x6f, 0x73,
-	0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x69,
-	0x6e, 0x74, 0x65, 0x6e, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x23,
-	0x0a, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
-	0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x57, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x6c, 0x65,
-	0x5f, 0x76, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x08, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x14, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x6f,
-	0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x22, 0xd9, 0x02, 0x0a, 0x1b, 0x42, 0x6f,
-	0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6e, 0x61,
-	0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x0e, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x12, 0x44, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f,
-	0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64, 0x65, 0x6c,
-	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x69, 0x6e, 0x74, 0x65,
-	0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x50, 0x6f, 0x43, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52,
-	0x07, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x74, 0x6f, 0x74, 0x61,
-	0x6c, 0x5f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4e, 0x65, 0x74,
-	0x77, 0x6f, 0x72, 0x6b, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x59, 0x0a, 0x0e, 0x70, 0x72,
-	0x65, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72,
-	0x61, 0x70, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x65, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62,
-	0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62,
-	0x69, 0x6c, 0x69, 0x74, 0x79, 0x22, 0x76, 0x0a, 0x13, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50,
-	0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06,
-	0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65,
-	0x6e, 0x64, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12,
+	0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x69, 0x0a, 0x0d, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49,
+	0x64, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x12,
 	0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03,
 	0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x54, 0x6f,
-	0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x1d, 0x0a,
-	0x1b, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x58, 0x0a, 0x16,
-	0x4d, 0x73, 0x67, 0x52, 0x65, 0x66, 0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65,
-	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x19,
-	0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a, 0x06,
-	0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x20, 0x0a, 0x1e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x66,
-	0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x55, 0x0a, 0x13, 0x4d, 0x73, 0x67, 0x44,
-	0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12,
-	0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x49, 0x64, 0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22,
-	0x1d, 0x0a, 0x1b, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43,
-	0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x58,
-	0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x19, 0x0a,
-	0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0xdf, 0x01, 0x0a, 0x1a, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a,
-	0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x52, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c,
-	0x52, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x69, 0x6e,
+	0x22, 0x49, 0x0a, 0x0a, 0x50, 0x6f, 0x43, 0x52, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x12, 0x19,
+	0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x4e, 0x0a, 0x0f, 0x50,
+	0x6f, 0x43, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x19,
+	0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x50, 0x0a, 0x10, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x56, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12,
+	0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x76, 0x6f,
+	0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x0b, 0x76, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x22, 0xc0, 0x01,
+	0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
+	0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x44, 0x0a,
+	0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x73, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x52,
+	0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x52, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x73,
+	0x22, 0xe8, 0x02, 0x0a, 0x1c, 0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x4d, 0x6f,
+	0x64, 0x65, 0x6c, 0x50, 0x72, 0x65, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c,
+	0x70, 0x72, 0x65, 0x5f, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0b, 0x70, 0x72, 0x65, 0x45, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x12,
+	0x34, 0x0a, 0x16, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f,
+	0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x14, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x54, 0x68, 0x72, 0x65,
+	0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x1e, 0x0a, 0x0b, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x76,
+	0x5f, 0x6d, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6d, 0x65, 0x65, 0x74,
+	0x73, 0x56, 0x4d, 0x69, 0x6e, 0x12, 0x2d, 0x0a, 0x12, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x5f, 0x72,
+	0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x11, 0x6d, 0x65, 0x65, 0x74, 0x73, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x79, 0x12, 0x2a, 0x0a, 0x11, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x68,
+	0x6f, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x0f, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+	0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x57,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62,
+	0x6c, 0x65, 0x5f, 0x76, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x6c, 0x65,
+	0x56, 0x6f, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x22, 0xd9, 0x02, 0x0a, 0x1b,
+	0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73,
+	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x12, 0x44, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64,
+	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x69, 0x6e,
 	0x74, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x50, 0x6f, 0x43, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x6e,
-	0x74, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0xc0, 0x01, 0x0a, 0x17, 0x63,
-	0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x12, 0x50, 0x6f, 0x63, 0x44, 0x65, 0x6c, 0x65, 0x67,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f,
-	0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02,
-	0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65,
-	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x74, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x74, 0x6f,
+	0x74, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x77, 0x65, 0x69, 0x67,
+	0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4e,
+	0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x59, 0x0a, 0x0e,
+	0x70, 0x72, 0x65, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x6f, 0x6f, 0x74, 0x73,
+	0x74, 0x72, 0x61, 0x70, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x65, 0x45, 0x6c, 0x69, 0x67,
+	0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x65, 0x6c, 0x69, 0x67,
+	0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x22, 0x8d, 0x01, 0x0a, 0x18, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x54, 0x72, 0x61, 0x6e,
+	0x73, 0x66, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12,
+	0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66,
+	0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x02, 0x74, 0x6f, 0x12, 0x32, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x65, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c,
+	0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x65, 0x22, 0x84, 0x01, 0x0a, 0x17, 0x44, 0x65, 0x6c, 0x65,
+	0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x6e, 0x61,
+	0x6c, 0x74, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79,
+	0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0f, 0x70,
+	0x65, 0x6e, 0x61, 0x6c, 0x74, 0x79, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xdc,
+	0x01, 0x0a, 0x20, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x77,
+	0x61, 0x72, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64,
+	0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49,
+	0x6e, 0x64, 0x65, 0x78, 0x12, 0x4b, 0x0a, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x54, 0x72,
+	0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x09, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72,
+	0x73, 0x12, 0x4a, 0x0a, 0x09, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x69, 0x65, 0x73, 0x18, 0x03,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x6e, 0x61, 0x6c,
+	0x74, 0x79, 0x52, 0x09, 0x70, 0x65, 0x6e, 0x61, 0x6c, 0x74, 0x69, 0x65, 0x73, 0x22, 0x76, 0x0a,
+	0x13, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x54, 0x6f, 0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a, 0x06, 0x73,
+	0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x1d, 0x0a, 0x1b, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50,
+	0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x58, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x66, 0x75, 0x73,
+	0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16,
+	0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
+	0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f,
+	0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49,
+	0x64, 0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x20,
+	0x0a, 0x1e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x66, 0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x55, 0x0a, 0x13, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f,
+	0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65,
+	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12,
+	0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a,
+	0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x1d, 0x0a, 0x1b, 0x4d, 0x73, 0x67, 0x44, 0x65,
+	0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x58, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+	0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64,
+	0x22, 0xdf, 0x01, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c,
+	0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x44, 0x0a, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x44, 0x65,
+	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3b, 0x0a, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c,
+	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f,
+	0x43, 0x52, 0x65, 0x66, 0x75, 0x73, 0x61, 0x6c, 0x52, 0x08, 0x72, 0x65, 0x66, 0x75, 0x73, 0x61,
+	0x6c, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x44, 0x69, 0x72,
+	0x65, 0x63, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x74, 0x73, 0x42, 0xc0, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x12,
+	0x50, 0x6f, 0x63, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e,
+	0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58,
+	0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
+	0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -9039,38 +11031,46 @@ func file_inference_inference_poc_delegation_proto_rawDescGZIP() []byte {
 	return file_inference_inference_poc_delegation_proto_rawDescData
 }
 
-var file_inference_inference_poc_delegation_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
+var file_inference_inference_poc_delegation_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
 var file_inference_inference_poc_delegation_proto_goTypes = []interface{}{
-	(*PoCDelegation)(nil),                  // 0: inference.inference.PoCDelegation
-	(*PoCRefusal)(nil),                     // 1: inference.inference.PoCRefusal
-	(*PoCDirectIntent)(nil),                // 2: inference.inference.PoCDirectIntent
-	(*ModelVotingPower)(nil),               // 3: inference.inference.ModelVotingPower
-	(*DelegationSnapshot)(nil),             // 4: inference.inference.DelegationSnapshot
-	(*BootstrapModelPreEligibility)(nil),   // 5: inference.inference.BootstrapModelPreEligibility
-	(*BootstrapDelegationSnapshot)(nil),    // 6: inference.inference.BootstrapDelegationSnapshot
-	(*MsgSetPoCDelegation)(nil),            // 7: inference.inference.MsgSetPoCDelegation
-	(*MsgSetPoCDelegationResponse)(nil),    // 8: inference.inference.MsgSetPoCDelegationResponse
-	(*MsgRefusePoCDelegation)(nil),         // 9: inference.inference.MsgRefusePoCDelegation
-	(*MsgRefusePoCDelegationResponse)(nil), // 10: inference.inference.MsgRefusePoCDelegationResponse
-	(*MsgDeclarePoCIntent)(nil),            // 11: inference.inference.MsgDeclarePoCIntent
-	(*MsgDeclarePoCIntentResponse)(nil),    // 12: inference.inference.MsgDeclarePoCIntentResponse
-	(*QueryPoCDelegationRequest)(nil),      // 13: inference.inference.QueryPoCDelegationRequest
-	(*QueryPoCDelegationResponse)(nil),     // 14: inference.inference.QueryPoCDelegationResponse
+	(*PoCDelegation)(nil),                    // 0: inference.inference.PoCDelegation
+	(*PoCRefusal)(nil),                       // 1: inference.inference.PoCRefusal
+	(*PoCDirectIntent)(nil),                  // 2: inference.inference.PoCDirectIntent
+	(*ModelVotingPower)(nil),                 // 3: inference.inference.ModelVotingPower
+	(*DelegationSnapshot)(nil),               // 4: inference.inference.DelegationSnapshot
+	(*BootstrapModelPreEligibility)(nil),     // 5: inference.inference.BootstrapModelPreEligibility
+	(*BootstrapDelegationSnapshot)(nil),      // 6: inference.inference.BootstrapDelegationSnapshot
+	(*DelegationRewardTransfer)(nil),         // 7: inference.inference.DelegationRewardTransfer
+	(*DelegationRewardPenalty)(nil),          // 8: inference.inference.DelegationRewardPenalty
+	(*DelegationRewardTransferSnapshot)(nil), // 9: inference.inference.DelegationRewardTransferSnapshot
+	(*MsgSetPoCDelegation)(nil),              // 10: inference.inference.MsgSetPoCDelegation
+	(*MsgSetPoCDelegationResponse)(nil),      // 11: inference.inference.MsgSetPoCDelegationResponse
+	(*MsgRefusePoCDelegation)(nil),           // 12: inference.inference.MsgRefusePoCDelegation
+	(*MsgRefusePoCDelegationResponse)(nil),   // 13: inference.inference.MsgRefusePoCDelegationResponse
+	(*MsgDeclarePoCIntent)(nil),              // 14: inference.inference.MsgDeclarePoCIntent
+	(*MsgDeclarePoCIntentResponse)(nil),      // 15: inference.inference.MsgDeclarePoCIntentResponse
+	(*QueryPoCDelegationRequest)(nil),        // 16: inference.inference.QueryPoCDelegationRequest
+	(*QueryPoCDelegationResponse)(nil),       // 17: inference.inference.QueryPoCDelegationResponse
+	(*Decimal)(nil),                          // 18: inference.inference.Decimal
 }
 var file_inference_inference_poc_delegation_proto_depIdxs = []int32{
-	0, // 0: inference.inference.DelegationSnapshot.delegations:type_name -> inference.inference.PoCDelegation
-	1, // 1: inference.inference.DelegationSnapshot.refusals:type_name -> inference.inference.PoCRefusal
-	0, // 2: inference.inference.BootstrapDelegationSnapshot.delegations:type_name -> inference.inference.PoCDelegation
-	2, // 3: inference.inference.BootstrapDelegationSnapshot.intents:type_name -> inference.inference.PoCDirectIntent
-	5, // 4: inference.inference.BootstrapDelegationSnapshot.preeligibility:type_name -> inference.inference.BootstrapModelPreEligibility
-	0, // 5: inference.inference.QueryPoCDelegationResponse.delegations:type_name -> inference.inference.PoCDelegation
-	1, // 6: inference.inference.QueryPoCDelegationResponse.refusals:type_name -> inference.inference.PoCRefusal
-	2, // 7: inference.inference.QueryPoCDelegationResponse.intents:type_name -> inference.inference.PoCDirectIntent
-	8, // [8:8] is the sub-list for method output_type
-	8, // [8:8] is the sub-list for method input_type
-	8, // [8:8] is the sub-list for extension type_name
-	8, // [8:8] is the sub-list for extension extendee
-	0, // [0:8] is the sub-list for field type_name
+	0,  // 0: inference.inference.DelegationSnapshot.delegations:type_name -> inference.inference.PoCDelegation
+	1,  // 1: inference.inference.DelegationSnapshot.refusals:type_name -> inference.inference.PoCRefusal
+	0,  // 2: inference.inference.BootstrapDelegationSnapshot.delegations:type_name -> inference.inference.PoCDelegation
+	2,  // 3: inference.inference.BootstrapDelegationSnapshot.intents:type_name -> inference.inference.PoCDirectIntent
+	5,  // 4: inference.inference.BootstrapDelegationSnapshot.preeligibility:type_name -> inference.inference.BootstrapModelPreEligibility
+	18, // 5: inference.inference.DelegationRewardTransfer.share:type_name -> inference.inference.Decimal
+	18, // 6: inference.inference.DelegationRewardPenalty.penalty_fraction:type_name -> inference.inference.Decimal
+	7,  // 7: inference.inference.DelegationRewardTransferSnapshot.transfers:type_name -> inference.inference.DelegationRewardTransfer
+	8,  // 8: inference.inference.DelegationRewardTransferSnapshot.penalties:type_name -> inference.inference.DelegationRewardPenalty
+	0,  // 9: inference.inference.QueryPoCDelegationResponse.delegations:type_name -> inference.inference.PoCDelegation
+	1,  // 10: inference.inference.QueryPoCDelegationResponse.refusals:type_name -> inference.inference.PoCRefusal
+	2,  // 11: inference.inference.QueryPoCDelegationResponse.intents:type_name -> inference.inference.PoCDirectIntent
+	12, // [12:12] is the sub-list for method output_type
+	12, // [12:12] is the sub-list for method input_type
+	12, // [12:12] is the sub-list for extension type_name
+	12, // [12:12] is the sub-list for extension extendee
+	0,  // [0:12] is the sub-list for field type_name
 }
 
 func init() { file_inference_inference_poc_delegation_proto_init() }
@@ -9078,6 +11078,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 	if File_inference_inference_poc_delegation_proto != nil {
 		return
 	}
+	file_inference_inference_params_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_inference_inference_poc_delegation_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*PoCDelegation); i {
@@ -9164,7 +11165,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSetPoCDelegation); i {
+			switch v := v.(*DelegationRewardTransfer); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9176,7 +11177,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSetPoCDelegationResponse); i {
+			switch v := v.(*DelegationRewardPenalty); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9188,7 +11189,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRefusePoCDelegation); i {
+			switch v := v.(*DelegationRewardTransferSnapshot); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9200,7 +11201,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRefusePoCDelegationResponse); i {
+			switch v := v.(*MsgSetPoCDelegation); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9212,7 +11213,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgDeclarePoCIntent); i {
+			switch v := v.(*MsgSetPoCDelegationResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9224,7 +11225,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgDeclarePoCIntentResponse); i {
+			switch v := v.(*MsgRefusePoCDelegation); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9236,7 +11237,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPoCDelegationRequest); i {
+			switch v := v.(*MsgRefusePoCDelegationResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -9248,6 +11249,42 @@ func file_inference_inference_poc_delegation_proto_init() {
 			}
 		}
 		file_inference_inference_poc_delegation_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgDeclarePoCIntent); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_poc_delegation_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgDeclarePoCIntentResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_poc_delegation_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryPoCDelegationRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_poc_delegation_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*QueryPoCDelegationResponse); i {
 			case 0:
 				return &v.state
@@ -9266,7 +11303,7 @@ func file_inference_inference_poc_delegation_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_inference_inference_poc_delegation_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   15,
+			NumMessages:   18,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/inference-chain/api/inference/inference/pruning_state.pulsar.go b/inference-chain/api/inference/inference/pruning_state.pulsar.go
index a3217e7ede..7b051ba2de 100644
--- a/inference-chain/api/inference/inference/pruning_state.pulsar.go
+++ b/inference-chain/api/inference/inference/pruning_state.pulsar.go
@@ -23,6 +23,7 @@ var (
 	fd_PruningState_mlnode_weight_distributions_pruned_epoch protoreflect.FieldDescriptor
 	fd_PruningState_poc_validations_v2_pruned_epoch          protoreflect.FieldDescriptor
 	fd_PruningState_poc_validation_snapshots_pruned_epoch    protoreflect.FieldDescriptor
+	fd_PruningState_claim_recipients_pruned_epoch            protoreflect.FieldDescriptor
 )
 
 func init() {
@@ -37,6 +38,7 @@ func init() {
 	fd_PruningState_mlnode_weight_distributions_pruned_epoch = md_PruningState.Fields().ByName("mlnode_weight_distributions_pruned_epoch")
 	fd_PruningState_poc_validations_v2_pruned_epoch = md_PruningState.Fields().ByName("poc_validations_v2_pruned_epoch")
 	fd_PruningState_poc_validation_snapshots_pruned_epoch = md_PruningState.Fields().ByName("poc_validation_snapshots_pruned_epoch")
+	fd_PruningState_claim_recipients_pruned_epoch = md_PruningState.Fields().ByName("claim_recipients_pruned_epoch")
 }
 
 var _ protoreflect.Message = (*fastReflection_PruningState)(nil)
@@ -158,6 +160,12 @@ func (x *fastReflection_PruningState) Range(f func(protoreflect.FieldDescriptor,
 			return
 		}
 	}
+	if x.ClaimRecipientsPrunedEpoch != int64(0) {
+		value := protoreflect.ValueOfInt64(x.ClaimRecipientsPrunedEpoch)
+		if !f(fd_PruningState_claim_recipients_pruned_epoch, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -191,6 +199,8 @@ func (x *fastReflection_PruningState) Has(fd protoreflect.FieldDescriptor) bool
 		return x.PocValidationsV2PrunedEpoch != int64(0)
 	case "inference.inference.PruningState.poc_validation_snapshots_pruned_epoch":
 		return x.PocValidationSnapshotsPrunedEpoch != int64(0)
+	case "inference.inference.PruningState.claim_recipients_pruned_epoch":
+		return x.ClaimRecipientsPrunedEpoch != int64(0)
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
@@ -225,6 +235,8 @@ func (x *fastReflection_PruningState) Clear(fd protoreflect.FieldDescriptor) {
 		x.PocValidationsV2PrunedEpoch = int64(0)
 	case "inference.inference.PruningState.poc_validation_snapshots_pruned_epoch":
 		x.PocValidationSnapshotsPrunedEpoch = int64(0)
+	case "inference.inference.PruningState.claim_recipients_pruned_epoch":
+		x.ClaimRecipientsPrunedEpoch = int64(0)
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
@@ -268,6 +280,9 @@ func (x *fastReflection_PruningState) Get(descriptor protoreflect.FieldDescripto
 	case "inference.inference.PruningState.poc_validation_snapshots_pruned_epoch":
 		value := x.PocValidationSnapshotsPrunedEpoch
 		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.PruningState.claim_recipients_pruned_epoch":
+		value := x.ClaimRecipientsPrunedEpoch
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
@@ -306,6 +321,8 @@ func (x *fastReflection_PruningState) Set(fd protoreflect.FieldDescriptor, value
 		x.PocValidationsV2PrunedEpoch = value.Int()
 	case "inference.inference.PruningState.poc_validation_snapshots_pruned_epoch":
 		x.PocValidationSnapshotsPrunedEpoch = value.Int()
+	case "inference.inference.PruningState.claim_recipients_pruned_epoch":
+		x.ClaimRecipientsPrunedEpoch = value.Int()
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
@@ -344,6 +361,8 @@ func (x *fastReflection_PruningState) Mutable(fd protoreflect.FieldDescriptor) p
 		panic(fmt.Errorf("field poc_validations_v2_pruned_epoch of message inference.inference.PruningState is not mutable"))
 	case "inference.inference.PruningState.poc_validation_snapshots_pruned_epoch":
 		panic(fmt.Errorf("field poc_validation_snapshots_pruned_epoch of message inference.inference.PruningState is not mutable"))
+	case "inference.inference.PruningState.claim_recipients_pruned_epoch":
+		panic(fmt.Errorf("field claim_recipients_pruned_epoch of message inference.inference.PruningState is not mutable"))
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
@@ -375,6 +394,8 @@ func (x *fastReflection_PruningState) NewField(fd protoreflect.FieldDescriptor)
 		return protoreflect.ValueOfInt64(int64(0))
 	case "inference.inference.PruningState.poc_validation_snapshots_pruned_epoch":
 		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.PruningState.claim_recipients_pruned_epoch":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
 			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PruningState"))
@@ -471,6 +492,9 @@ func (x *fastReflection_PruningState) ProtoMethods() *protoiface.Methods {
 		if x.PocValidationSnapshotsPrunedEpoch != 0 {
 			n += 1 + runtime.Sov(uint64(x.PocValidationSnapshotsPrunedEpoch))
 		}
+		if x.ClaimRecipientsPrunedEpoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.ClaimRecipientsPrunedEpoch))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -500,6 +524,11 @@ func (x *fastReflection_PruningState) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.ClaimRecipientsPrunedEpoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ClaimRecipientsPrunedEpoch))
+			i--
+			dAtA[i] = 0x50
+		}
 		if x.PocValidationSnapshotsPrunedEpoch != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocValidationSnapshotsPrunedEpoch))
 			i--
@@ -765,6 +794,25 @@ func (x *fastReflection_PruningState) ProtoMethods() *protoiface.Methods {
 						break
 					}
 				}
+			case 10:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClaimRecipientsPrunedEpoch", wireType)
+				}
+				x.ClaimRecipientsPrunedEpoch = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ClaimRecipientsPrunedEpoch |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -827,6 +875,7 @@ type PruningState struct {
 	MlnodeWeightDistributionsPrunedEpoch int64 `protobuf:"varint,7,opt,name=mlnode_weight_distributions_pruned_epoch,json=mlnodeWeightDistributionsPrunedEpoch,proto3" json:"mlnode_weight_distributions_pruned_epoch,omitempty"`
 	PocValidationsV2PrunedEpoch          int64 `protobuf:"varint,8,opt,name=poc_validations_v2_pruned_epoch,json=pocValidationsV2PrunedEpoch,proto3" json:"poc_validations_v2_pruned_epoch,omitempty"`
 	PocValidationSnapshotsPrunedEpoch    int64 `protobuf:"varint,9,opt,name=poc_validation_snapshots_pruned_epoch,json=pocValidationSnapshotsPrunedEpoch,proto3" json:"poc_validation_snapshots_pruned_epoch,omitempty"`
+	ClaimRecipientsPrunedEpoch           int64 `protobuf:"varint,10,opt,name=claim_recipients_pruned_epoch,json=claimRecipientsPrunedEpoch,proto3" json:"claim_recipients_pruned_epoch,omitempty"`
 }
 
 func (x *PruningState) Reset() {
@@ -912,13 +961,20 @@ func (x *PruningState) GetPocValidationSnapshotsPrunedEpoch() int64 {
 	return 0
 }
 
+func (x *PruningState) GetClaimRecipientsPrunedEpoch() int64 {
+	if x != nil {
+		return x.ClaimRecipientsPrunedEpoch
+	}
+	return 0
+}
+
 var File_inference_inference_pruning_state_proto protoreflect.FileDescriptor
 
 var file_inference_inference_pruning_state_proto_rawDesc = []byte{
 	0x0a, 0x27, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74,
 	0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x90,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x22, 0xd3,
 	0x05, 0x0a, 0x0c, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12,
 	0x37, 0x0a, 0x18, 0x70, 0x6f, 0x63, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x5f, 0x70,
 	0x72, 0x75, 0x6e, 0x65, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28,
@@ -958,21 +1014,25 @@ var file_inference_inference_pruning_state_proto_rawDesc = []byte{
 	0x70, 0x73, 0x68, 0x6f, 0x74, 0x73, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x5f, 0x65, 0x70,
 	0x6f, 0x63, 0x68, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x21, 0x70, 0x6f, 0x63, 0x56, 0x61,
 	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
-	0x73, 0x50, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x13, 0x73, 0x75,
-	0x62, 0x6e, 0x65, 0x74, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x42, 0xbf, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x11, 0x50,
-	0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f,
-	0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f,
-	0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02,
-	0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x73, 0x50, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x41, 0x0a, 0x1d,
+	0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73,
+	0x5f, 0x70, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x0a, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x1a, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69,
+	0x65, 0x6e, 0x74, 0x73, 0x50, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52,
+	0x13, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x5f, 0x70, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x5f, 0x65,
+	0x70, 0x6f, 0x63, 0x68, 0x42, 0xbf, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x42, 0x11, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x72,
+	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b,
+	0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49,
+	0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f,
+	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea,
+	0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/inference-chain/api/inference/inference/query.pulsar.go b/inference-chain/api/inference/inference/query.pulsar.go
index c7005eef6c..fba17b0046 100644
--- a/inference-chain/api/inference/inference/query.pulsar.go
+++ b/inference-chain/api/inference/inference/query.pulsar.go
@@ -10164,27 +10164,25 @@ func (x *fastReflection_QueryAllSettleAmountResponse) ProtoMethods() *protoiface
 }
 
 var (
-	md_QueryGetEpochGroupValidationsRequest             protoreflect.MessageDescriptor
-	fd_QueryGetEpochGroupValidationsRequest_participant protoreflect.FieldDescriptor
-	fd_QueryGetEpochGroupValidationsRequest_epoch_index protoreflect.FieldDescriptor
+	md_QueryEstimateBitcoinRewardRequest             protoreflect.MessageDescriptor
+	fd_QueryEstimateBitcoinRewardRequest_participant protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetEpochGroupValidationsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochGroupValidationsRequest")
-	fd_QueryGetEpochGroupValidationsRequest_participant = md_QueryGetEpochGroupValidationsRequest.Fields().ByName("participant")
-	fd_QueryGetEpochGroupValidationsRequest_epoch_index = md_QueryGetEpochGroupValidationsRequest.Fields().ByName("epoch_index")
+	md_QueryEstimateBitcoinRewardRequest = File_inference_inference_query_proto.Messages().ByName("QueryEstimateBitcoinRewardRequest")
+	fd_QueryEstimateBitcoinRewardRequest_participant = md_QueryEstimateBitcoinRewardRequest.Fields().ByName("participant")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupValidationsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryEstimateBitcoinRewardRequest)(nil)
 
-type fastReflection_QueryGetEpochGroupValidationsRequest QueryGetEpochGroupValidationsRequest
+type fastReflection_QueryEstimateBitcoinRewardRequest QueryEstimateBitcoinRewardRequest
 
-func (x *QueryGetEpochGroupValidationsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetEpochGroupValidationsRequest)(x)
+func (x *QueryEstimateBitcoinRewardRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEstimateBitcoinRewardRequest)(x)
 }
 
-func (x *QueryGetEpochGroupValidationsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryEstimateBitcoinRewardRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[22]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -10196,43 +10194,43 @@ func (x *QueryGetEpochGroupValidationsRequest) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetEpochGroupValidationsRequest_messageType fastReflection_QueryGetEpochGroupValidationsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupValidationsRequest_messageType{}
+var _fastReflection_QueryEstimateBitcoinRewardRequest_messageType fastReflection_QueryEstimateBitcoinRewardRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEstimateBitcoinRewardRequest_messageType{}
 
-type fastReflection_QueryGetEpochGroupValidationsRequest_messageType struct{}
+type fastReflection_QueryEstimateBitcoinRewardRequest_messageType struct{}
 
-func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetEpochGroupValidationsRequest)(nil)
+func (x fastReflection_QueryEstimateBitcoinRewardRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEstimateBitcoinRewardRequest)(nil)
 }
-func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetEpochGroupValidationsRequest)
+func (x fastReflection_QueryEstimateBitcoinRewardRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEstimateBitcoinRewardRequest)
 }
-func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetEpochGroupValidationsRequest
+func (x fastReflection_QueryEstimateBitcoinRewardRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEstimateBitcoinRewardRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetEpochGroupValidationsRequest
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEstimateBitcoinRewardRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetEpochGroupValidationsRequest_messageType
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEstimateBitcoinRewardRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetEpochGroupValidationsRequest)
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryEstimateBitcoinRewardRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetEpochGroupValidationsRequest)(x)
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryEstimateBitcoinRewardRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -10240,16 +10238,10 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Participant != "" {
 		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_QueryGetEpochGroupValidationsRequest_participant, value) {
-			return
-		}
-	}
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryGetEpochGroupValidationsRequest_epoch_index, value) {
+		if !f(fd_QueryEstimateBitcoinRewardRequest_participant, value) {
 			return
 		}
 	}
@@ -10266,17 +10258,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+	case "inference.inference.QueryEstimateBitcoinRewardRequest.participant":
 		return x.Participant != ""
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
-		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10286,17 +10276,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+	case "inference.inference.QueryEstimateBitcoinRewardRequest.participant":
 		x.Participant = ""
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
-		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10306,19 +10294,16 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+	case "inference.inference.QueryEstimateBitcoinRewardRequest.participant":
 		value := x.Participant
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -10332,17 +10317,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+	case "inference.inference.QueryEstimateBitcoinRewardRequest.participant":
 		x.Participant = value.Interface().(string)
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
-		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10356,44 +10339,40 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.QueryGetEpochGroupValidationsRequest is not mutable"))
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryGetEpochGroupValidationsRequest is not mutable"))
+	case "inference.inference.QueryEstimateBitcoinRewardRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryEstimateBitcoinRewardRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+	case "inference.inference.QueryEstimateBitcoinRewardRequest.participant":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochGroupValidationsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEstimateBitcoinRewardRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -10401,7 +10380,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -10412,7 +10391,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -10424,7 +10403,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) IsValid() bool {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -10434,9 +10413,9 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEstimateBitcoinRewardRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
+		x := input.Message.Interface().(*QueryEstimateBitcoinRewardRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10452,9 +10431,6 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -10465,7 +10441,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
+		x := input.Message.Interface().(*QueryEstimateBitcoinRewardRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10484,11 +10460,6 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
-			i--
-			dAtA[i] = 0x10
-		}
 		if len(x.Participant) > 0 {
 			i -= len(x.Participant)
 			copy(dAtA[i:], x.Participant)
@@ -10507,7 +10478,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
+		x := input.Message.Interface().(*QueryEstimateBitcoinRewardRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10539,10 +10510,10 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEstimateBitcoinRewardRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEstimateBitcoinRewardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -10577,25 +10548,6 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 				}
 				x.Participant = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-				}
-				x.EpochIndex = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -10632,25 +10584,25 @@ func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *pr
 }
 
 var (
-	md_QueryGetEpochGroupValidationsResponse                         protoreflect.MessageDescriptor
-	fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations protoreflect.FieldDescriptor
+	md_QueryEstimateBitcoinRewardResponse               protoreflect.MessageDescriptor
+	fd_QueryEstimateBitcoinRewardResponse_settle_amount protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetEpochGroupValidationsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochGroupValidationsResponse")
-	fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations = md_QueryGetEpochGroupValidationsResponse.Fields().ByName("epoch_group_validations")
+	md_QueryEstimateBitcoinRewardResponse = File_inference_inference_query_proto.Messages().ByName("QueryEstimateBitcoinRewardResponse")
+	fd_QueryEstimateBitcoinRewardResponse_settle_amount = md_QueryEstimateBitcoinRewardResponse.Fields().ByName("settle_amount")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupValidationsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryEstimateBitcoinRewardResponse)(nil)
 
-type fastReflection_QueryGetEpochGroupValidationsResponse QueryGetEpochGroupValidationsResponse
+type fastReflection_QueryEstimateBitcoinRewardResponse QueryEstimateBitcoinRewardResponse
 
-func (x *QueryGetEpochGroupValidationsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetEpochGroupValidationsResponse)(x)
+func (x *QueryEstimateBitcoinRewardResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEstimateBitcoinRewardResponse)(x)
 }
 
-func (x *QueryGetEpochGroupValidationsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryEstimateBitcoinRewardResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[23]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -10662,43 +10614,43 @@ func (x *QueryGetEpochGroupValidationsResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetEpochGroupValidationsResponse_messageType fastReflection_QueryGetEpochGroupValidationsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupValidationsResponse_messageType{}
+var _fastReflection_QueryEstimateBitcoinRewardResponse_messageType fastReflection_QueryEstimateBitcoinRewardResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEstimateBitcoinRewardResponse_messageType{}
 
-type fastReflection_QueryGetEpochGroupValidationsResponse_messageType struct{}
+type fastReflection_QueryEstimateBitcoinRewardResponse_messageType struct{}
 
-func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetEpochGroupValidationsResponse)(nil)
+func (x fastReflection_QueryEstimateBitcoinRewardResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEstimateBitcoinRewardResponse)(nil)
 }
-func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetEpochGroupValidationsResponse)
+func (x fastReflection_QueryEstimateBitcoinRewardResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEstimateBitcoinRewardResponse)
 }
-func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetEpochGroupValidationsResponse
+func (x fastReflection_QueryEstimateBitcoinRewardResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEstimateBitcoinRewardResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetEpochGroupValidationsResponse
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEstimateBitcoinRewardResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetEpochGroupValidationsResponse_messageType
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEstimateBitcoinRewardResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetEpochGroupValidationsResponse)
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryEstimateBitcoinRewardResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetEpochGroupValidationsResponse)(x)
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryEstimateBitcoinRewardResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -10706,10 +10658,10 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochGroupValidations != nil {
-		value := protoreflect.ValueOfMessage(x.EpochGroupValidations.ProtoReflect())
-		if !f(fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations, value) {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.SettleAmount != nil {
+		value := protoreflect.ValueOfMessage(x.SettleAmount.ProtoReflect())
+		if !f(fd_QueryEstimateBitcoinRewardResponse_settle_amount, value) {
 			return
 		}
 	}
@@ -10726,15 +10678,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
-		return x.EpochGroupValidations != nil
+	case "inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount":
+		return x.SettleAmount != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10744,15 +10696,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
-		x.EpochGroupValidations = nil
+	case "inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount":
+		x.SettleAmount = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10762,16 +10714,16 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
-		value := x.EpochGroupValidations
+	case "inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount":
+		value := x.SettleAmount
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -10785,15 +10737,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
-		x.EpochGroupValidations = value.Message().Interface().(*EpochGroupValidations)
+	case "inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount":
+		x.SettleAmount = value.Message().Interface().(*SettleAmount)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10807,44 +10759,44 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
-		if x.EpochGroupValidations == nil {
-			x.EpochGroupValidations = new(EpochGroupValidations)
+	case "inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount":
+		if x.SettleAmount == nil {
+			x.SettleAmount = new(SettleAmount)
 		}
-		return protoreflect.ValueOfMessage(x.EpochGroupValidations.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.SettleAmount.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
-		m := new(EpochGroupValidations)
+	case "inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount":
+		m := new(SettleAmount)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEstimateBitcoinRewardResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEstimateBitcoinRewardResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochGroupValidationsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEstimateBitcoinRewardResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -10852,7 +10804,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -10863,7 +10815,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -10875,7 +10827,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) IsValid() bool {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -10885,9 +10837,9 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEstimateBitcoinRewardResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
+		x := input.Message.Interface().(*QueryEstimateBitcoinRewardResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10899,8 +10851,8 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
-		if x.EpochGroupValidations != nil {
-			l = options.Size(x.EpochGroupValidations)
+		if x.SettleAmount != nil {
+			l = options.Size(x.SettleAmount)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -10913,7 +10865,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
+		x := input.Message.Interface().(*QueryEstimateBitcoinRewardResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10932,8 +10884,8 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochGroupValidations != nil {
-			encoded, err := options.Marshal(x.EpochGroupValidations)
+		if x.SettleAmount != nil {
+			encoded, err := options.Marshal(x.SettleAmount)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10957,7 +10909,7 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
+		x := input.Message.Interface().(*QueryEstimateBitcoinRewardResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -10989,15 +10941,15 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEstimateBitcoinRewardResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEstimateBitcoinRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochGroupValidations", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SettleAmount", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -11024,10 +10976,10 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.EpochGroupValidations == nil {
-					x.EpochGroupValidations = &EpochGroupValidations{}
+				if x.SettleAmount == nil {
+					x.SettleAmount = &SettleAmount{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupValidations); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SettleAmount); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -11067,25 +11019,27 @@ func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *p
 }
 
 var (
-	md_QueryAllEpochGroupValidationsRequest            protoreflect.MessageDescriptor
-	fd_QueryAllEpochGroupValidationsRequest_pagination protoreflect.FieldDescriptor
+	md_QueryGetEpochGroupValidationsRequest             protoreflect.MessageDescriptor
+	fd_QueryGetEpochGroupValidationsRequest_participant protoreflect.FieldDescriptor
+	fd_QueryGetEpochGroupValidationsRequest_epoch_index protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllEpochGroupValidationsRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochGroupValidationsRequest")
-	fd_QueryAllEpochGroupValidationsRequest_pagination = md_QueryAllEpochGroupValidationsRequest.Fields().ByName("pagination")
+	md_QueryGetEpochGroupValidationsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochGroupValidationsRequest")
+	fd_QueryGetEpochGroupValidationsRequest_participant = md_QueryGetEpochGroupValidationsRequest.Fields().ByName("participant")
+	fd_QueryGetEpochGroupValidationsRequest_epoch_index = md_QueryGetEpochGroupValidationsRequest.Fields().ByName("epoch_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupValidationsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupValidationsRequest)(nil)
 
-type fastReflection_QueryAllEpochGroupValidationsRequest QueryAllEpochGroupValidationsRequest
+type fastReflection_QueryGetEpochGroupValidationsRequest QueryGetEpochGroupValidationsRequest
 
-func (x *QueryAllEpochGroupValidationsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochGroupValidationsRequest)(x)
+func (x *QueryGetEpochGroupValidationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetEpochGroupValidationsRequest)(x)
 }
 
-func (x *QueryAllEpochGroupValidationsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetEpochGroupValidationsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[24]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -11097,43 +11051,43 @@ func (x *QueryAllEpochGroupValidationsRequest) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllEpochGroupValidationsRequest_messageType fastReflection_QueryAllEpochGroupValidationsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupValidationsRequest_messageType{}
+var _fastReflection_QueryGetEpochGroupValidationsRequest_messageType fastReflection_QueryGetEpochGroupValidationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupValidationsRequest_messageType{}
 
-type fastReflection_QueryAllEpochGroupValidationsRequest_messageType struct{}
+type fastReflection_QueryGetEpochGroupValidationsRequest_messageType struct{}
 
-func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochGroupValidationsRequest)(nil)
+func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetEpochGroupValidationsRequest)(nil)
 }
-func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochGroupValidationsRequest)
+func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetEpochGroupValidationsRequest)
 }
-func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochGroupValidationsRequest
+func (x fastReflection_QueryGetEpochGroupValidationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetEpochGroupValidationsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochGroupValidationsRequest
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetEpochGroupValidationsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllEpochGroupValidationsRequest_messageType
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetEpochGroupValidationsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochGroupValidationsRequest)
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetEpochGroupValidationsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllEpochGroupValidationsRequest)(x)
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetEpochGroupValidationsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -11141,10 +11095,16 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllEpochGroupValidationsRequest_pagination, value) {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryGetEpochGroupValidationsRequest_participant, value) {
+			return
+		}
+	}
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_QueryGetEpochGroupValidationsRequest_epoch_index, value) {
 			return
 		}
 	}
@@ -11161,15 +11121,17 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+		return x.Participant != ""
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
+		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11179,15 +11141,17 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+		x.Participant = ""
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
+		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11197,16 +11161,19 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -11220,15 +11187,17 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
+		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11242,44 +11211,44 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryGetEpochGroupValidationsRequest is not mutable"))
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryGetEpochGroupValidationsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryGetEpochGroupValidationsRequest.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochGroupValidationsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochGroupValidationsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -11287,7 +11256,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -11298,7 +11267,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -11310,7 +11279,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) IsValid() bool {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -11320,9 +11289,9 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetEpochGroupValidationsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
+		x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11334,10 +11303,13 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		l = len(x.Participant)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -11348,7 +11320,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
+		x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11367,17 +11339,15 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -11392,7 +11362,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
+		x := input.Message.Interface().(*QueryGetEpochGroupValidationsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11424,17 +11394,17 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -11444,28 +11414,43 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -11501,79 +11486,26 @@ func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *pr
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllEpochGroupValidationsResponse_1_list)(nil)
-
-type _QueryAllEpochGroupValidationsResponse_1_list struct {
-	list *[]*EpochGroupValidations
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*EpochGroupValidations)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*EpochGroupValidations)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(EpochGroupValidations)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(EpochGroupValidations)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllEpochGroupValidationsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryAllEpochGroupValidationsResponse                         protoreflect.MessageDescriptor
-	fd_QueryAllEpochGroupValidationsResponse_epoch_group_validations protoreflect.FieldDescriptor
-	fd_QueryAllEpochGroupValidationsResponse_pagination              protoreflect.FieldDescriptor
+	md_QueryGetEpochGroupValidationsResponse                         protoreflect.MessageDescriptor
+	fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllEpochGroupValidationsResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochGroupValidationsResponse")
-	fd_QueryAllEpochGroupValidationsResponse_epoch_group_validations = md_QueryAllEpochGroupValidationsResponse.Fields().ByName("epoch_group_validations")
-	fd_QueryAllEpochGroupValidationsResponse_pagination = md_QueryAllEpochGroupValidationsResponse.Fields().ByName("pagination")
+	md_QueryGetEpochGroupValidationsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetEpochGroupValidationsResponse")
+	fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations = md_QueryGetEpochGroupValidationsResponse.Fields().ByName("epoch_group_validations")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupValidationsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetEpochGroupValidationsResponse)(nil)
 
-type fastReflection_QueryAllEpochGroupValidationsResponse QueryAllEpochGroupValidationsResponse
+type fastReflection_QueryGetEpochGroupValidationsResponse QueryGetEpochGroupValidationsResponse
 
-func (x *QueryAllEpochGroupValidationsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochGroupValidationsResponse)(x)
+func (x *QueryGetEpochGroupValidationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetEpochGroupValidationsResponse)(x)
 }
 
-func (x *QueryAllEpochGroupValidationsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetEpochGroupValidationsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[25]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -11585,43 +11517,43 @@ func (x *QueryAllEpochGroupValidationsResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllEpochGroupValidationsResponse_messageType fastReflection_QueryAllEpochGroupValidationsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupValidationsResponse_messageType{}
+var _fastReflection_QueryGetEpochGroupValidationsResponse_messageType fastReflection_QueryGetEpochGroupValidationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetEpochGroupValidationsResponse_messageType{}
 
-type fastReflection_QueryAllEpochGroupValidationsResponse_messageType struct{}
+type fastReflection_QueryGetEpochGroupValidationsResponse_messageType struct{}
 
-func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochGroupValidationsResponse)(nil)
+func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetEpochGroupValidationsResponse)(nil)
 }
-func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochGroupValidationsResponse)
+func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetEpochGroupValidationsResponse)
 }
-func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochGroupValidationsResponse
+func (x fastReflection_QueryGetEpochGroupValidationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetEpochGroupValidationsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochGroupValidationsResponse
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetEpochGroupValidationsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllEpochGroupValidationsResponse_messageType
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetEpochGroupValidationsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochGroupValidationsResponse)
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetEpochGroupValidationsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllEpochGroupValidationsResponse)(x)
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetEpochGroupValidationsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -11629,16 +11561,10 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.EpochGroupValidations) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllEpochGroupValidationsResponse_1_list{list: &x.EpochGroupValidations})
-		if !f(fd_QueryAllEpochGroupValidationsResponse_epoch_group_validations, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllEpochGroupValidationsResponse_pagination, value) {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochGroupValidations != nil {
+		value := protoreflect.ValueOfMessage(x.EpochGroupValidations.ProtoReflect())
+		if !f(fd_QueryGetEpochGroupValidationsResponse_epoch_group_validations, value) {
 			return
 		}
 	}
@@ -11655,17 +11581,15 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
-		return len(x.EpochGroupValidations) != 0
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
+		return x.EpochGroupValidations != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11675,17 +11599,15 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
 		x.EpochGroupValidations = nil
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11695,22 +11617,16 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
-		if len(x.EpochGroupValidations) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllEpochGroupValidationsResponse_1_list{})
-		}
-		listValue := &_QueryAllEpochGroupValidationsResponse_1_list{list: &x.EpochGroupValidations}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
+		value := x.EpochGroupValidations
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -11724,19 +11640,15 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
-		lv := value.List()
-		clv := lv.(*_QueryAllEpochGroupValidationsResponse_1_list)
-		x.EpochGroupValidations = *clv.list
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
+		x.EpochGroupValidations = value.Message().Interface().(*EpochGroupValidations)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11750,53 +11662,44 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
 		if x.EpochGroupValidations == nil {
-			x.EpochGroupValidations = []*EpochGroupValidations{}
-		}
-		value := &_QueryAllEpochGroupValidationsResponse_1_list{list: &x.EpochGroupValidations}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
+			x.EpochGroupValidations = new(EpochGroupValidations)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.EpochGroupValidations.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
-		list := []*EpochGroupValidations{}
-		return protoreflect.ValueOfList(&_QueryAllEpochGroupValidationsResponse_1_list{list: &list})
-	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
-		m := new(v1beta1.PageResponse)
+	case "inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations":
+		m := new(EpochGroupValidations)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochGroupValidationsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetEpochGroupValidationsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -11804,7 +11707,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -11815,7 +11718,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -11827,7 +11730,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) IsValid() bool {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -11837,9 +11740,9 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetEpochGroupValidationsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
+		x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11851,14 +11754,8 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
-		if len(x.EpochGroupValidations) > 0 {
-			for _, e := range x.EpochGroupValidations {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.EpochGroupValidations != nil {
+			l = options.Size(x.EpochGroupValidations)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -11871,7 +11768,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
+		x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11890,8 +11787,8 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.EpochGroupValidations != nil {
+			encoded, err := options.Marshal(x.EpochGroupValidations)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11902,23 +11799,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.EpochGroupValidations) > 0 {
-			for iNdEx := len(x.EpochGroupValidations) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.EpochGroupValidations[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -11931,7 +11812,7 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
+		x := input.Message.Interface().(*QueryGetEpochGroupValidationsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11963,10 +11844,10 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -11998,44 +11879,10 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.EpochGroupValidations = append(x.EpochGroupValidations, &EpochGroupValidations{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupValidations[len(x.EpochGroupValidations)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
+				if x.EpochGroupValidations == nil {
+					x.EpochGroupValidations = &EpochGroupValidations{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupValidations); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -12075,25 +11922,25 @@ func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *p
 }
 
 var (
-	md_QueryPocBatchesForStageRequest              protoreflect.MessageDescriptor
-	fd_QueryPocBatchesForStageRequest_block_height protoreflect.FieldDescriptor
+	md_QueryAllEpochGroupValidationsRequest            protoreflect.MessageDescriptor
+	fd_QueryAllEpochGroupValidationsRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPocBatchesForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryPocBatchesForStageRequest")
-	fd_QueryPocBatchesForStageRequest_block_height = md_QueryPocBatchesForStageRequest.Fields().ByName("block_height")
+	md_QueryAllEpochGroupValidationsRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochGroupValidationsRequest")
+	fd_QueryAllEpochGroupValidationsRequest_pagination = md_QueryAllEpochGroupValidationsRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPocBatchesForStageRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupValidationsRequest)(nil)
 
-type fastReflection_QueryPocBatchesForStageRequest QueryPocBatchesForStageRequest
+type fastReflection_QueryAllEpochGroupValidationsRequest QueryAllEpochGroupValidationsRequest
 
-func (x *QueryPocBatchesForStageRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPocBatchesForStageRequest)(x)
+func (x *QueryAllEpochGroupValidationsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochGroupValidationsRequest)(x)
 }
 
-func (x *QueryPocBatchesForStageRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllEpochGroupValidationsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[26]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -12105,43 +11952,43 @@ func (x *QueryPocBatchesForStageRequest) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPocBatchesForStageRequest_messageType fastReflection_QueryPocBatchesForStageRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPocBatchesForStageRequest_messageType{}
+var _fastReflection_QueryAllEpochGroupValidationsRequest_messageType fastReflection_QueryAllEpochGroupValidationsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupValidationsRequest_messageType{}
 
-type fastReflection_QueryPocBatchesForStageRequest_messageType struct{}
+type fastReflection_QueryAllEpochGroupValidationsRequest_messageType struct{}
 
-func (x fastReflection_QueryPocBatchesForStageRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPocBatchesForStageRequest)(nil)
+func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochGroupValidationsRequest)(nil)
 }
-func (x fastReflection_QueryPocBatchesForStageRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPocBatchesForStageRequest)
+func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochGroupValidationsRequest)
 }
-func (x fastReflection_QueryPocBatchesForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocBatchesForStageRequest
+func (x fastReflection_QueryAllEpochGroupValidationsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochGroupValidationsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocBatchesForStageRequest
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochGroupValidationsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPocBatchesForStageRequest_messageType
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllEpochGroupValidationsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPocBatchesForStageRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPocBatchesForStageRequest)
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochGroupValidationsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPocBatchesForStageRequest)(x)
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllEpochGroupValidationsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -12149,10 +11996,10 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) Interface() protoreflect
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.BlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.BlockHeight)
-		if !f(fd_QueryPocBatchesForStageRequest_block_height, value) {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllEpochGroupValidationsRequest_pagination, value) {
 			return
 		}
 	}
@@ -12169,15 +12016,15 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) Range(f func(protoreflec
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
-		return x.BlockHeight != int64(0)
+	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12187,15 +12034,15 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) Has(fd protoreflect.Fiel
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
-		x.BlockHeight = int64(0)
+	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12205,16 +12052,16 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) Clear(fd protoreflect.Fi
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -12228,15 +12075,15 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) Get(descriptor protorefl
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
-		x.BlockHeight = value.Int()
+	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12250,40 +12097,44 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) Set(fd protoreflect.Fiel
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryPocBatchesForStageRequest is not mutable"))
+	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPocBatchesForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryAllEpochGroupValidationsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPocBatchesForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocBatchesForStageRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochGroupValidationsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -12291,7 +12142,7 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) WhichOneof(d protoreflec
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPocBatchesForStageRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -12302,7 +12153,7 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) GetUnknown() protoreflec
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -12314,7 +12165,7 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) SetUnknown(fields protor
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPocBatchesForStageRequest) IsValid() bool {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -12324,9 +12175,9 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllEpochGroupValidationsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
+		x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12338,8 +12189,9 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 		var n int
 		var l int
 		_ = l
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -12351,7 +12203,7 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
+		x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12370,10 +12222,19 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -12386,7 +12247,7 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
+		x := input.Message.Interface().(*QueryAllEpochGroupValidationsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12418,17 +12279,17 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				x.BlockHeight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -12438,12 +12299,29 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= int64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			default:
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
 				if err != nil {
@@ -12478,77 +12356,79 @@ func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoifa
 	}
 }
 
-var _ protoreflect.List = (*_QueryPocBatchesForStageResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryAllEpochGroupValidationsResponse_1_list)(nil)
 
-type _QueryPocBatchesForStageResponse_1_list struct {
-	list *[]*PoCBatchesWithParticipants
+type _QueryAllEpochGroupValidationsResponse_1_list struct {
+	list *[]*EpochGroupValidations
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) Len() int {
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCBatchesWithParticipants)
+	concreteValue := valueUnwrapped.Interface().(*EpochGroupValidations)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCBatchesWithParticipants)
+	concreteValue := valueUnwrapped.Interface().(*EpochGroupValidations)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(PoCBatchesWithParticipants)
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(EpochGroupValidations)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) Truncate(n int) {
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) NewElement() protoreflect.Value {
-	v := new(PoCBatchesWithParticipants)
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(EpochGroupValidations)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryPocBatchesForStageResponse_1_list) IsValid() bool {
+func (x *_QueryAllEpochGroupValidationsResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryPocBatchesForStageResponse           protoreflect.MessageDescriptor
-	fd_QueryPocBatchesForStageResponse_poc_batch protoreflect.FieldDescriptor
+	md_QueryAllEpochGroupValidationsResponse                         protoreflect.MessageDescriptor
+	fd_QueryAllEpochGroupValidationsResponse_epoch_group_validations protoreflect.FieldDescriptor
+	fd_QueryAllEpochGroupValidationsResponse_pagination              protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPocBatchesForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryPocBatchesForStageResponse")
-	fd_QueryPocBatchesForStageResponse_poc_batch = md_QueryPocBatchesForStageResponse.Fields().ByName("poc_batch")
+	md_QueryAllEpochGroupValidationsResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochGroupValidationsResponse")
+	fd_QueryAllEpochGroupValidationsResponse_epoch_group_validations = md_QueryAllEpochGroupValidationsResponse.Fields().ByName("epoch_group_validations")
+	fd_QueryAllEpochGroupValidationsResponse_pagination = md_QueryAllEpochGroupValidationsResponse.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPocBatchesForStageResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochGroupValidationsResponse)(nil)
 
-type fastReflection_QueryPocBatchesForStageResponse QueryPocBatchesForStageResponse
+type fastReflection_QueryAllEpochGroupValidationsResponse QueryAllEpochGroupValidationsResponse
 
-func (x *QueryPocBatchesForStageResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPocBatchesForStageResponse)(x)
+func (x *QueryAllEpochGroupValidationsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochGroupValidationsResponse)(x)
 }
 
-func (x *QueryPocBatchesForStageResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllEpochGroupValidationsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[27]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -12560,43 +12440,43 @@ func (x *QueryPocBatchesForStageResponse) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPocBatchesForStageResponse_messageType fastReflection_QueryPocBatchesForStageResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPocBatchesForStageResponse_messageType{}
+var _fastReflection_QueryAllEpochGroupValidationsResponse_messageType fastReflection_QueryAllEpochGroupValidationsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochGroupValidationsResponse_messageType{}
 
-type fastReflection_QueryPocBatchesForStageResponse_messageType struct{}
+type fastReflection_QueryAllEpochGroupValidationsResponse_messageType struct{}
 
-func (x fastReflection_QueryPocBatchesForStageResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPocBatchesForStageResponse)(nil)
+func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochGroupValidationsResponse)(nil)
 }
-func (x fastReflection_QueryPocBatchesForStageResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPocBatchesForStageResponse)
+func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochGroupValidationsResponse)
 }
-func (x fastReflection_QueryPocBatchesForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocBatchesForStageResponse
+func (x fastReflection_QueryAllEpochGroupValidationsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochGroupValidationsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocBatchesForStageResponse
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochGroupValidationsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPocBatchesForStageResponse_messageType
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllEpochGroupValidationsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPocBatchesForStageResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPocBatchesForStageResponse)
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochGroupValidationsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPocBatchesForStageResponse)(x)
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllEpochGroupValidationsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -12604,10 +12484,16 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.PocBatch) != 0 {
-		value := protoreflect.ValueOfList(&_QueryPocBatchesForStageResponse_1_list{list: &x.PocBatch})
-		if !f(fd_QueryPocBatchesForStageResponse_poc_batch, value) {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.EpochGroupValidations) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllEpochGroupValidationsResponse_1_list{list: &x.EpochGroupValidations})
+		if !f(fd_QueryAllEpochGroupValidationsResponse_epoch_group_validations, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllEpochGroupValidationsResponse_pagination, value) {
 			return
 		}
 	}
@@ -12624,15 +12510,17 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
-		return len(x.PocBatch) != 0
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+		return len(x.EpochGroupValidations) != 0
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12642,15 +12530,17 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
-		x.PocBatch = nil
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+		x.EpochGroupValidations = nil
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12660,19 +12550,22 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
-		if len(x.PocBatch) == 0 {
-			return protoreflect.ValueOfList(&_QueryPocBatchesForStageResponse_1_list{})
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+		if len(x.EpochGroupValidations) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllEpochGroupValidationsResponse_1_list{})
 		}
-		listValue := &_QueryPocBatchesForStageResponse_1_list{list: &x.PocBatch}
+		listValue := &_QueryAllEpochGroupValidationsResponse_1_list{list: &x.EpochGroupValidations}
 		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -12686,17 +12579,19 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
 		lv := value.List()
-		clv := lv.(*_QueryPocBatchesForStageResponse_1_list)
-		x.PocBatch = *clv.list
+		clv := lv.(*_QueryAllEpochGroupValidationsResponse_1_list)
+		x.EpochGroupValidations = *clv.list
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12710,45 +12605,53 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
-		if x.PocBatch == nil {
-			x.PocBatch = []*PoCBatchesWithParticipants{}
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+		if x.EpochGroupValidations == nil {
+			x.EpochGroupValidations = []*EpochGroupValidations{}
 		}
-		value := &_QueryPocBatchesForStageResponse_1_list{list: &x.PocBatch}
+		value := &_QueryAllEpochGroupValidationsResponse_1_list{list: &x.EpochGroupValidations}
 		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPocBatchesForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
-		list := []*PoCBatchesWithParticipants{}
-		return protoreflect.ValueOfList(&_QueryPocBatchesForStageResponse_1_list{list: &list})
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations":
+		list := []*EpochGroupValidations{}
+		return protoreflect.ValueOfList(&_QueryAllEpochGroupValidationsResponse_1_list{list: &list})
+	case "inference.inference.QueryAllEpochGroupValidationsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochGroupValidationsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochGroupValidationsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPocBatchesForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocBatchesForStageResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochGroupValidationsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -12756,7 +12659,7 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPocBatchesForStageResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -12767,7 +12670,7 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocBatchesForStageResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -12779,7 +12682,7 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPocBatchesForStageResponse) IsValid() bool {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -12789,9 +12692,9 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllEpochGroupValidationsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
+		x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12803,12 +12706,16 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 		var n int
 		var l int
 		_ = l
-		if len(x.PocBatch) > 0 {
-			for _, e := range x.PocBatch {
+		if len(x.EpochGroupValidations) > 0 {
+			for _, e := range x.EpochGroupValidations {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
 		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -12819,7 +12726,7 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
+		x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12838,9 +12745,23 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.PocBatch) > 0 {
-			for iNdEx := len(x.PocBatch) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.PocBatch[iNdEx])
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.EpochGroupValidations) > 0 {
+			for iNdEx := len(x.EpochGroupValidations) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.EpochGroupValidations[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12865,7 +12786,7 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
+		x := input.Message.Interface().(*QueryAllEpochGroupValidationsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12897,15 +12818,15 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochGroupValidations", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -12932,8 +12853,44 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.PocBatch = append(x.PocBatch, &PoCBatchesWithParticipants{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocBatch[len(x.PocBatch)-1]); err != nil {
+				x.EpochGroupValidations = append(x.EpochGroupValidations, &EpochGroupValidations{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupValidations[len(x.EpochGroupValidations)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -12972,83 +12929,26 @@ func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoif
 	}
 }
 
-var _ protoreflect.List = (*_PoCBatchesWithParticipants_4_list)(nil)
-
-type _PoCBatchesWithParticipants_4_list struct {
-	list *[]*PoCBatch
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCBatch)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCBatch)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) AppendMutable() protoreflect.Value {
-	v := new(PoCBatch)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) NewElement() protoreflect.Value {
-	v := new(PoCBatch)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_PoCBatchesWithParticipants_4_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_PoCBatchesWithParticipants             protoreflect.MessageDescriptor
-	fd_PoCBatchesWithParticipants_participant protoreflect.FieldDescriptor
-	fd_PoCBatchesWithParticipants_pub_key     protoreflect.FieldDescriptor
-	fd_PoCBatchesWithParticipants_hex_pub_key protoreflect.FieldDescriptor
-	fd_PoCBatchesWithParticipants_poc_batch   protoreflect.FieldDescriptor
+	md_QueryPocBatchesForStageRequest              protoreflect.MessageDescriptor
+	fd_QueryPocBatchesForStageRequest_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_PoCBatchesWithParticipants = File_inference_inference_query_proto.Messages().ByName("PoCBatchesWithParticipants")
-	fd_PoCBatchesWithParticipants_participant = md_PoCBatchesWithParticipants.Fields().ByName("participant")
-	fd_PoCBatchesWithParticipants_pub_key = md_PoCBatchesWithParticipants.Fields().ByName("pub_key")
-	fd_PoCBatchesWithParticipants_hex_pub_key = md_PoCBatchesWithParticipants.Fields().ByName("hex_pub_key")
-	fd_PoCBatchesWithParticipants_poc_batch = md_PoCBatchesWithParticipants.Fields().ByName("poc_batch")
+	md_QueryPocBatchesForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryPocBatchesForStageRequest")
+	fd_QueryPocBatchesForStageRequest_block_height = md_QueryPocBatchesForStageRequest.Fields().ByName("block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_PoCBatchesWithParticipants)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPocBatchesForStageRequest)(nil)
 
-type fastReflection_PoCBatchesWithParticipants PoCBatchesWithParticipants
+type fastReflection_QueryPocBatchesForStageRequest QueryPocBatchesForStageRequest
 
-func (x *PoCBatchesWithParticipants) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_PoCBatchesWithParticipants)(x)
+func (x *QueryPocBatchesForStageRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPocBatchesForStageRequest)(x)
 }
 
-func (x *PoCBatchesWithParticipants) slowProtoReflect() protoreflect.Message {
+func (x *QueryPocBatchesForStageRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[28]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -13060,43 +12960,43 @@ func (x *PoCBatchesWithParticipants) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_PoCBatchesWithParticipants_messageType fastReflection_PoCBatchesWithParticipants_messageType
-var _ protoreflect.MessageType = fastReflection_PoCBatchesWithParticipants_messageType{}
+var _fastReflection_QueryPocBatchesForStageRequest_messageType fastReflection_QueryPocBatchesForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocBatchesForStageRequest_messageType{}
 
-type fastReflection_PoCBatchesWithParticipants_messageType struct{}
+type fastReflection_QueryPocBatchesForStageRequest_messageType struct{}
 
-func (x fastReflection_PoCBatchesWithParticipants_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_PoCBatchesWithParticipants)(nil)
+func (x fastReflection_QueryPocBatchesForStageRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPocBatchesForStageRequest)(nil)
 }
-func (x fastReflection_PoCBatchesWithParticipants_messageType) New() protoreflect.Message {
-	return new(fastReflection_PoCBatchesWithParticipants)
+func (x fastReflection_QueryPocBatchesForStageRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPocBatchesForStageRequest)
 }
-func (x fastReflection_PoCBatchesWithParticipants_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCBatchesWithParticipants
+func (x fastReflection_QueryPocBatchesForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocBatchesForStageRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_PoCBatchesWithParticipants) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCBatchesWithParticipants
+func (x *fastReflection_QueryPocBatchesForStageRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocBatchesForStageRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_PoCBatchesWithParticipants) Type() protoreflect.MessageType {
-	return _fastReflection_PoCBatchesWithParticipants_messageType
+func (x *fastReflection_QueryPocBatchesForStageRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPocBatchesForStageRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_PoCBatchesWithParticipants) New() protoreflect.Message {
-	return new(fastReflection_PoCBatchesWithParticipants)
+func (x *fastReflection_QueryPocBatchesForStageRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPocBatchesForStageRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_PoCBatchesWithParticipants) Interface() protoreflect.ProtoMessage {
-	return (*PoCBatchesWithParticipants)(x)
+func (x *fastReflection_QueryPocBatchesForStageRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPocBatchesForStageRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -13104,28 +13004,10 @@ func (x *fastReflection_PoCBatchesWithParticipants) Interface() protoreflect.Pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_PoCBatchesWithParticipants) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Participant != "" {
-		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_PoCBatchesWithParticipants_participant, value) {
-			return
-		}
-	}
-	if x.PubKey != "" {
-		value := protoreflect.ValueOfString(x.PubKey)
-		if !f(fd_PoCBatchesWithParticipants_pub_key, value) {
-			return
-		}
-	}
-	if x.HexPubKey != "" {
-		value := protoreflect.ValueOfString(x.HexPubKey)
-		if !f(fd_PoCBatchesWithParticipants_hex_pub_key, value) {
-			return
-		}
-	}
-	if len(x.PocBatch) != 0 {
-		value := protoreflect.ValueOfList(&_PoCBatchesWithParticipants_4_list{list: &x.PocBatch})
-		if !f(fd_PoCBatchesWithParticipants_poc_batch, value) {
+func (x *fastReflection_QueryPocBatchesForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_QueryPocBatchesForStageRequest_block_height, value) {
 			return
 		}
 	}
@@ -13142,21 +13024,15 @@ func (x *fastReflection_PoCBatchesWithParticipants) Range(f func(protoreflect.Fi
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_PoCBatchesWithParticipants) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPocBatchesForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.PoCBatchesWithParticipants.participant":
-		return x.Participant != ""
-	case "inference.inference.PoCBatchesWithParticipants.pub_key":
-		return x.PubKey != ""
-	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
-		return x.HexPubKey != ""
-	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
-		return len(x.PocBatch) != 0
+	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
+		return x.BlockHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13166,21 +13042,15 @@ func (x *fastReflection_PoCBatchesWithParticipants) Has(fd protoreflect.FieldDes
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCBatchesWithParticipants) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPocBatchesForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.PoCBatchesWithParticipants.participant":
-		x.Participant = ""
-	case "inference.inference.PoCBatchesWithParticipants.pub_key":
-		x.PubKey = ""
-	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
-		x.HexPubKey = ""
-	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
-		x.PocBatch = nil
+	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
+		x.BlockHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13190,28 +13060,16 @@ func (x *fastReflection_PoCBatchesWithParticipants) Clear(fd protoreflect.FieldD
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_PoCBatchesWithParticipants) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocBatchesForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.PoCBatchesWithParticipants.participant":
-		value := x.Participant
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCBatchesWithParticipants.pub_key":
-		value := x.PubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
-		value := x.HexPubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
-		if len(x.PocBatch) == 0 {
-			return protoreflect.ValueOfList(&_PoCBatchesWithParticipants_4_list{})
-		}
-		listValue := &_PoCBatchesWithParticipants_4_list{list: &x.PocBatch}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -13225,23 +13083,15 @@ func (x *fastReflection_PoCBatchesWithParticipants) Get(descriptor protoreflect.
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCBatchesWithParticipants) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPocBatchesForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.PoCBatchesWithParticipants.participant":
-		x.Participant = value.Interface().(string)
-	case "inference.inference.PoCBatchesWithParticipants.pub_key":
-		x.PubKey = value.Interface().(string)
-	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
-		x.HexPubKey = value.Interface().(string)
-	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
-		lv := value.List()
-		clv := lv.(*_PoCBatchesWithParticipants_4_list)
-		x.PocBatch = *clv.list
+	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
+		x.BlockHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13255,57 +13105,40 @@ func (x *fastReflection_PoCBatchesWithParticipants) Set(fd protoreflect.FieldDes
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCBatchesWithParticipants) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocBatchesForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
-		if x.PocBatch == nil {
-			x.PocBatch = []*PoCBatch{}
-		}
-		value := &_PoCBatchesWithParticipants_4_list{list: &x.PocBatch}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.PoCBatchesWithParticipants.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.PoCBatchesWithParticipants is not mutable"))
-	case "inference.inference.PoCBatchesWithParticipants.pub_key":
-		panic(fmt.Errorf("field pub_key of message inference.inference.PoCBatchesWithParticipants is not mutable"))
-	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
-		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCBatchesWithParticipants is not mutable"))
+	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryPocBatchesForStageRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_PoCBatchesWithParticipants) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocBatchesForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCBatchesWithParticipants.participant":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCBatchesWithParticipants.pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
-		list := []*PoCBatch{}
-		return protoreflect.ValueOfList(&_PoCBatchesWithParticipants_4_list{list: &list})
+	case "inference.inference.QueryPocBatchesForStageRequest.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_PoCBatchesWithParticipants) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPocBatchesForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCBatchesWithParticipants", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocBatchesForStageRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -13313,7 +13146,7 @@ func (x *fastReflection_PoCBatchesWithParticipants) WhichOneof(d protoreflect.On
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_PoCBatchesWithParticipants) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPocBatchesForStageRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -13324,7 +13157,7 @@ func (x *fastReflection_PoCBatchesWithParticipants) GetUnknown() protoreflect.Ra
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCBatchesWithParticipants) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPocBatchesForStageRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -13336,7 +13169,7 @@ func (x *fastReflection_PoCBatchesWithParticipants) SetUnknown(fields protorefle
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_PoCBatchesWithParticipants) IsValid() bool {
+func (x *fastReflection_QueryPocBatchesForStageRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -13346,9 +13179,9 @@ func (x *fastReflection_PoCBatchesWithParticipants) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPocBatchesForStageRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*PoCBatchesWithParticipants)
+		x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13360,23 +13193,8 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 		var n int
 		var l int
 		_ = l
-		l = len(x.Participant)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.PubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.HexPubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.PocBatch) > 0 {
-			for _, e := range x.PocBatch {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -13388,7 +13206,7 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*PoCBatchesWithParticipants)
+		x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13407,42 +13225,10 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.PocBatch) > 0 {
-			for iNdEx := len(x.PocBatch) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.PocBatch[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x22
-			}
-		}
-		if len(x.HexPubKey) > 0 {
-			i -= len(x.HexPubKey)
-			copy(dAtA[i:], x.HexPubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.PubKey) > 0 {
-			i -= len(x.PubKey)
-			copy(dAtA[i:], x.PubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Participant) > 0 {
-			i -= len(x.Participant)
-			copy(dAtA[i:], x.Participant)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -13455,7 +13241,7 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*PoCBatchesWithParticipants)
+		x := input.Message.Interface().(*QueryPocBatchesForStageRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13487,113 +13273,17 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCBatchesWithParticipants: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCBatchesWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Participant = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HexPubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				var msglen int
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -13603,26 +13293,11 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.BlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PocBatch = append(x.PocBatch, &PoCBatch{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocBatch[len(x.PocBatch)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -13658,26 +13333,77 @@ func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.M
 	}
 }
 
+var _ protoreflect.List = (*_QueryPocBatchesForStageResponse_1_list)(nil)
+
+type _QueryPocBatchesForStageResponse_1_list struct {
+	list *[]*PoCBatchesWithParticipants
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCBatchesWithParticipants)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCBatchesWithParticipants)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(PoCBatchesWithParticipants)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) NewElement() protoreflect.Value {
+	v := new(PoCBatchesWithParticipants)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryPocBatchesForStageResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryPocValidationsForStageRequest              protoreflect.MessageDescriptor
-	fd_QueryPocValidationsForStageRequest_block_height protoreflect.FieldDescriptor
+	md_QueryPocBatchesForStageResponse           protoreflect.MessageDescriptor
+	fd_QueryPocBatchesForStageResponse_poc_batch protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPocValidationsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryPocValidationsForStageRequest")
-	fd_QueryPocValidationsForStageRequest_block_height = md_QueryPocValidationsForStageRequest.Fields().ByName("block_height")
+	md_QueryPocBatchesForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryPocBatchesForStageResponse")
+	fd_QueryPocBatchesForStageResponse_poc_batch = md_QueryPocBatchesForStageResponse.Fields().ByName("poc_batch")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPocValidationsForStageRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPocBatchesForStageResponse)(nil)
 
-type fastReflection_QueryPocValidationsForStageRequest QueryPocValidationsForStageRequest
+type fastReflection_QueryPocBatchesForStageResponse QueryPocBatchesForStageResponse
 
-func (x *QueryPocValidationsForStageRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPocValidationsForStageRequest)(x)
+func (x *QueryPocBatchesForStageResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPocBatchesForStageResponse)(x)
 }
 
-func (x *QueryPocValidationsForStageRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPocBatchesForStageResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[29]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -13689,43 +13415,43 @@ func (x *QueryPocValidationsForStageRequest) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPocValidationsForStageRequest_messageType fastReflection_QueryPocValidationsForStageRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPocValidationsForStageRequest_messageType{}
+var _fastReflection_QueryPocBatchesForStageResponse_messageType fastReflection_QueryPocBatchesForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocBatchesForStageResponse_messageType{}
 
-type fastReflection_QueryPocValidationsForStageRequest_messageType struct{}
+type fastReflection_QueryPocBatchesForStageResponse_messageType struct{}
 
-func (x fastReflection_QueryPocValidationsForStageRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPocValidationsForStageRequest)(nil)
+func (x fastReflection_QueryPocBatchesForStageResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPocBatchesForStageResponse)(nil)
 }
-func (x fastReflection_QueryPocValidationsForStageRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPocValidationsForStageRequest)
+func (x fastReflection_QueryPocBatchesForStageResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPocBatchesForStageResponse)
 }
-func (x fastReflection_QueryPocValidationsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocValidationsForStageRequest
+func (x fastReflection_QueryPocBatchesForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocBatchesForStageResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocValidationsForStageRequest
+func (x *fastReflection_QueryPocBatchesForStageResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocBatchesForStageResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPocValidationsForStageRequest_messageType
+func (x *fastReflection_QueryPocBatchesForStageResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPocBatchesForStageResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPocValidationsForStageRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPocValidationsForStageRequest)
+func (x *fastReflection_QueryPocBatchesForStageResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPocBatchesForStageResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPocValidationsForStageRequest)(x)
+func (x *fastReflection_QueryPocBatchesForStageResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPocBatchesForStageResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -13733,10 +13459,10 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.BlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.BlockHeight)
-		if !f(fd_QueryPocValidationsForStageRequest_block_height, value) {
+func (x *fastReflection_QueryPocBatchesForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.PocBatch) != 0 {
+		value := protoreflect.ValueOfList(&_QueryPocBatchesForStageResponse_1_list{list: &x.PocBatch})
+		if !f(fd_QueryPocBatchesForStageResponse_poc_batch, value) {
 			return
 		}
 	}
@@ -13753,15 +13479,15 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPocBatchesForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
-		return x.BlockHeight != int64(0)
+	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+		return len(x.PocBatch) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13771,15 +13497,15 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPocBatchesForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
-		x.BlockHeight = int64(0)
+	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+		x.PocBatch = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13789,16 +13515,19 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocBatchesForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+		if len(x.PocBatch) == 0 {
+			return protoreflect.ValueOfList(&_QueryPocBatchesForStageResponse_1_list{})
+		}
+		listValue := &_QueryPocBatchesForStageResponse_1_list{list: &x.PocBatch}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -13812,15 +13541,17 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPocBatchesForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
-		x.BlockHeight = value.Int()
+	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+		lv := value.List()
+		clv := lv.(*_QueryPocBatchesForStageResponse_1_list)
+		x.PocBatch = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13834,40 +13565,45 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocBatchesForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryPocValidationsForStageRequest is not mutable"))
+	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+		if x.PocBatch == nil {
+			x.PocBatch = []*PoCBatchesWithParticipants{}
+		}
+		value := &_QueryPocBatchesForStageResponse_1_list{list: &x.PocBatch}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPocValidationsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocBatchesForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryPocBatchesForStageResponse.poc_batch":
+		list := []*PoCBatchesWithParticipants{}
+		return protoreflect.ValueOfList(&_QueryPocBatchesForStageResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocBatchesForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocBatchesForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPocValidationsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPocBatchesForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocValidationsForStageRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocBatchesForStageResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -13875,7 +13611,7 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPocValidationsForStageRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPocBatchesForStageResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -13886,7 +13622,7 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPocBatchesForStageResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -13898,7 +13634,7 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPocValidationsForStageRequest) IsValid() bool {
+func (x *fastReflection_QueryPocBatchesForStageResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -13908,9 +13644,9 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPocBatchesForStageResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
+		x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13922,8 +13658,11 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if len(x.PocBatch) > 0 {
+			for _, e := range x.PocBatch {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -13935,7 +13674,7 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
+		x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13954,10 +13693,21 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
-			i--
-			dAtA[i] = 0x8
+		if len(x.PocBatch) > 0 {
+			for iNdEx := len(x.PocBatch) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.PocBatch[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -13970,7 +13720,7 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
+		x := input.Message.Interface().(*QueryPocBatchesForStageResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14002,17 +13752,17 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocBatchesForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
 				}
-				x.BlockHeight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -14022,11 +13772,26 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= int64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.PocBatch = append(x.PocBatch, &PoCBatchesWithParticipants{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocBatch[len(x.PocBatch)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -14062,77 +13827,83 @@ func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *prot
 	}
 }
 
-var _ protoreflect.List = (*_QueryPocValidationsForStageResponse_1_list)(nil)
+var _ protoreflect.List = (*_PoCBatchesWithParticipants_4_list)(nil)
 
-type _QueryPocValidationsForStageResponse_1_list struct {
-	list *[]*PoCValidationsWithParticipants
+type _PoCBatchesWithParticipants_4_list struct {
+	list *[]*PoCBatch
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) Len() int {
+func (x *_PoCBatchesWithParticipants_4_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_PoCBatchesWithParticipants_4_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_PoCBatchesWithParticipants_4_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipants)
+	concreteValue := valueUnwrapped.Interface().(*PoCBatch)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) Append(value protoreflect.Value) {
+func (x *_PoCBatchesWithParticipants_4_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipants)
+	concreteValue := valueUnwrapped.Interface().(*PoCBatch)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(PoCValidationsWithParticipants)
+func (x *_PoCBatchesWithParticipants_4_list) AppendMutable() protoreflect.Value {
+	v := new(PoCBatch)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) Truncate(n int) {
+func (x *_PoCBatchesWithParticipants_4_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) NewElement() protoreflect.Value {
-	v := new(PoCValidationsWithParticipants)
+func (x *_PoCBatchesWithParticipants_4_list) NewElement() protoreflect.Value {
+	v := new(PoCBatch)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryPocValidationsForStageResponse_1_list) IsValid() bool {
+func (x *_PoCBatchesWithParticipants_4_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryPocValidationsForStageResponse                protoreflect.MessageDescriptor
-	fd_QueryPocValidationsForStageResponse_poc_validation protoreflect.FieldDescriptor
+	md_PoCBatchesWithParticipants             protoreflect.MessageDescriptor
+	fd_PoCBatchesWithParticipants_participant protoreflect.FieldDescriptor
+	fd_PoCBatchesWithParticipants_pub_key     protoreflect.FieldDescriptor
+	fd_PoCBatchesWithParticipants_hex_pub_key protoreflect.FieldDescriptor
+	fd_PoCBatchesWithParticipants_poc_batch   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPocValidationsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryPocValidationsForStageResponse")
-	fd_QueryPocValidationsForStageResponse_poc_validation = md_QueryPocValidationsForStageResponse.Fields().ByName("poc_validation")
+	md_PoCBatchesWithParticipants = File_inference_inference_query_proto.Messages().ByName("PoCBatchesWithParticipants")
+	fd_PoCBatchesWithParticipants_participant = md_PoCBatchesWithParticipants.Fields().ByName("participant")
+	fd_PoCBatchesWithParticipants_pub_key = md_PoCBatchesWithParticipants.Fields().ByName("pub_key")
+	fd_PoCBatchesWithParticipants_hex_pub_key = md_PoCBatchesWithParticipants.Fields().ByName("hex_pub_key")
+	fd_PoCBatchesWithParticipants_poc_batch = md_PoCBatchesWithParticipants.Fields().ByName("poc_batch")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPocValidationsForStageResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_PoCBatchesWithParticipants)(nil)
 
-type fastReflection_QueryPocValidationsForStageResponse QueryPocValidationsForStageResponse
+type fastReflection_PoCBatchesWithParticipants PoCBatchesWithParticipants
 
-func (x *QueryPocValidationsForStageResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPocValidationsForStageResponse)(x)
+func (x *PoCBatchesWithParticipants) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_PoCBatchesWithParticipants)(x)
 }
 
-func (x *QueryPocValidationsForStageResponse) slowProtoReflect() protoreflect.Message {
+func (x *PoCBatchesWithParticipants) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[30]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -14144,43 +13915,43 @@ func (x *QueryPocValidationsForStageResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPocValidationsForStageResponse_messageType fastReflection_QueryPocValidationsForStageResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPocValidationsForStageResponse_messageType{}
+var _fastReflection_PoCBatchesWithParticipants_messageType fastReflection_PoCBatchesWithParticipants_messageType
+var _ protoreflect.MessageType = fastReflection_PoCBatchesWithParticipants_messageType{}
 
-type fastReflection_QueryPocValidationsForStageResponse_messageType struct{}
+type fastReflection_PoCBatchesWithParticipants_messageType struct{}
 
-func (x fastReflection_QueryPocValidationsForStageResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPocValidationsForStageResponse)(nil)
+func (x fastReflection_PoCBatchesWithParticipants_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_PoCBatchesWithParticipants)(nil)
 }
-func (x fastReflection_QueryPocValidationsForStageResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPocValidationsForStageResponse)
+func (x fastReflection_PoCBatchesWithParticipants_messageType) New() protoreflect.Message {
+	return new(fastReflection_PoCBatchesWithParticipants)
 }
-func (x fastReflection_QueryPocValidationsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocValidationsForStageResponse
+func (x fastReflection_PoCBatchesWithParticipants_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCBatchesWithParticipants
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocValidationsForStageResponse
+func (x *fastReflection_PoCBatchesWithParticipants) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCBatchesWithParticipants
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPocValidationsForStageResponse_messageType
+func (x *fastReflection_PoCBatchesWithParticipants) Type() protoreflect.MessageType {
+	return _fastReflection_PoCBatchesWithParticipants_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPocValidationsForStageResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPocValidationsForStageResponse)
+func (x *fastReflection_PoCBatchesWithParticipants) New() protoreflect.Message {
+	return new(fastReflection_PoCBatchesWithParticipants)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPocValidationsForStageResponse)(x)
+func (x *fastReflection_PoCBatchesWithParticipants) Interface() protoreflect.ProtoMessage {
+	return (*PoCBatchesWithParticipants)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -14188,10 +13959,28 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.PocValidation) != 0 {
-		value := protoreflect.ValueOfList(&_QueryPocValidationsForStageResponse_1_list{list: &x.PocValidation})
-		if !f(fd_QueryPocValidationsForStageResponse_poc_validation, value) {
+func (x *fastReflection_PoCBatchesWithParticipants) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_PoCBatchesWithParticipants_participant, value) {
+			return
+		}
+	}
+	if x.PubKey != "" {
+		value := protoreflect.ValueOfString(x.PubKey)
+		if !f(fd_PoCBatchesWithParticipants_pub_key, value) {
+			return
+		}
+	}
+	if x.HexPubKey != "" {
+		value := protoreflect.ValueOfString(x.HexPubKey)
+		if !f(fd_PoCBatchesWithParticipants_hex_pub_key, value) {
+			return
+		}
+	}
+	if len(x.PocBatch) != 0 {
+		value := protoreflect.ValueOfList(&_PoCBatchesWithParticipants_4_list{list: &x.PocBatch})
+		if !f(fd_PoCBatchesWithParticipants_poc_batch, value) {
 			return
 		}
 	}
@@ -14208,15 +13997,21 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_PoCBatchesWithParticipants) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
-		return len(x.PocValidation) != 0
+	case "inference.inference.PoCBatchesWithParticipants.participant":
+		return x.Participant != ""
+	case "inference.inference.PoCBatchesWithParticipants.pub_key":
+		return x.PubKey != ""
+	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
+		return x.HexPubKey != ""
+	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
+		return len(x.PocBatch) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14226,15 +14021,21 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_PoCBatchesWithParticipants) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
-		x.PocValidation = nil
+	case "inference.inference.PoCBatchesWithParticipants.participant":
+		x.Participant = ""
+	case "inference.inference.PoCBatchesWithParticipants.pub_key":
+		x.PubKey = ""
+	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
+		x.HexPubKey = ""
+	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
+		x.PocBatch = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14244,19 +14045,28 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCBatchesWithParticipants) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
-		if len(x.PocValidation) == 0 {
-			return protoreflect.ValueOfList(&_QueryPocValidationsForStageResponse_1_list{})
+	case "inference.inference.PoCBatchesWithParticipants.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCBatchesWithParticipants.pub_key":
+		value := x.PubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
+		value := x.HexPubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
+		if len(x.PocBatch) == 0 {
+			return protoreflect.ValueOfList(&_PoCBatchesWithParticipants_4_list{})
 		}
-		listValue := &_QueryPocValidationsForStageResponse_1_list{list: &x.PocValidation}
+		listValue := &_PoCBatchesWithParticipants_4_list{list: &x.PocBatch}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -14270,17 +14080,23 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_PoCBatchesWithParticipants) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+	case "inference.inference.PoCBatchesWithParticipants.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.PoCBatchesWithParticipants.pub_key":
+		x.PubKey = value.Interface().(string)
+	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
+		x.HexPubKey = value.Interface().(string)
+	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
 		lv := value.List()
-		clv := lv.(*_QueryPocValidationsForStageResponse_1_list)
-		x.PocValidation = *clv.list
+		clv := lv.(*_PoCBatchesWithParticipants_4_list)
+		x.PocBatch = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14294,45 +14110,57 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCBatchesWithParticipants) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
-		if x.PocValidation == nil {
-			x.PocValidation = []*PoCValidationsWithParticipants{}
+	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
+		if x.PocBatch == nil {
+			x.PocBatch = []*PoCBatch{}
 		}
-		value := &_QueryPocValidationsForStageResponse_1_list{list: &x.PocValidation}
+		value := &_PoCBatchesWithParticipants_4_list{list: &x.PocBatch}
 		return protoreflect.ValueOfList(value)
+	case "inference.inference.PoCBatchesWithParticipants.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.PoCBatchesWithParticipants is not mutable"))
+	case "inference.inference.PoCBatchesWithParticipants.pub_key":
+		panic(fmt.Errorf("field pub_key of message inference.inference.PoCBatchesWithParticipants is not mutable"))
+	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
+		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCBatchesWithParticipants is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPocValidationsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCBatchesWithParticipants) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
-		list := []*PoCValidationsWithParticipants{}
-		return protoreflect.ValueOfList(&_QueryPocValidationsForStageResponse_1_list{list: &list})
+	case "inference.inference.PoCBatchesWithParticipants.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCBatchesWithParticipants.pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCBatchesWithParticipants.hex_pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCBatchesWithParticipants.poc_batch":
+		list := []*PoCBatch{}
+		return protoreflect.ValueOfList(&_PoCBatchesWithParticipants_4_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCBatchesWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCBatchesWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPocValidationsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_PoCBatchesWithParticipants) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocValidationsForStageResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCBatchesWithParticipants", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -14340,7 +14168,7 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPocValidationsForStageResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_PoCBatchesWithParticipants) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -14351,7 +14179,7 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocValidationsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_PoCBatchesWithParticipants) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -14363,7 +14191,7 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPocValidationsForStageResponse) IsValid() bool {
+func (x *fastReflection_PoCBatchesWithParticipants) IsValid() bool {
 	return x != nil
 }
 
@@ -14373,9 +14201,9 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_PoCBatchesWithParticipants) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
+		x := input.Message.Interface().(*PoCBatchesWithParticipants)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14387,8 +14215,20 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 		var n int
 		var l int
 		_ = l
-		if len(x.PocValidation) > 0 {
-			for _, e := range x.PocValidation {
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.PubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.HexPubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.PocBatch) > 0 {
+			for _, e := range x.PocBatch {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -14403,7 +14243,7 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
+		x := input.Message.Interface().(*PoCBatchesWithParticipants)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14422,9 +14262,9 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.PocValidation) > 0 {
-			for iNdEx := len(x.PocValidation) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.PocValidation[iNdEx])
+		if len(x.PocBatch) > 0 {
+			for iNdEx := len(x.PocBatch) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.PocBatch[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14435,9 +14275,30 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 				copy(dAtA[i:], encoded)
 				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 				i--
-				dAtA[i] = 0xa
+				dAtA[i] = 0x22
 			}
 		}
+		if len(x.HexPubKey) > 0 {
+			i -= len(x.HexPubKey)
+			copy(dAtA[i:], x.HexPubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.PubKey) > 0 {
+			i -= len(x.PubKey)
+			copy(dAtA[i:], x.PubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -14449,7 +14310,7 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
+		x := input.Message.Interface().(*PoCBatchesWithParticipants)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14481,15 +14342,111 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCBatchesWithParticipants: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCBatchesWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.PubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.HexPubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -14516,8 +14473,8 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.PocValidation = append(x.PocValidation, &PoCValidationsWithParticipants{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
+				x.PocBatch = append(x.PocBatch, &PoCBatch{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocBatch[len(x.PocBatch)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -14556,83 +14513,26 @@ func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *pro
 	}
 }
 
-var _ protoreflect.List = (*_PoCValidationsWithParticipants_4_list)(nil)
-
-type _PoCValidationsWithParticipants_4_list struct {
-	list *[]*PoCValidation
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidation)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidation)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) AppendMutable() protoreflect.Value {
-	v := new(PoCValidation)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) NewElement() protoreflect.Value {
-	v := new(PoCValidation)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_PoCValidationsWithParticipants_4_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_PoCValidationsWithParticipants                protoreflect.MessageDescriptor
-	fd_PoCValidationsWithParticipants_participant    protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipants_pub_key        protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipants_hex_pub_key    protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipants_poc_validation protoreflect.FieldDescriptor
+	md_QueryPocValidationsForStageRequest              protoreflect.MessageDescriptor
+	fd_QueryPocValidationsForStageRequest_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_PoCValidationsWithParticipants = File_inference_inference_query_proto.Messages().ByName("PoCValidationsWithParticipants")
-	fd_PoCValidationsWithParticipants_participant = md_PoCValidationsWithParticipants.Fields().ByName("participant")
-	fd_PoCValidationsWithParticipants_pub_key = md_PoCValidationsWithParticipants.Fields().ByName("pub_key")
-	fd_PoCValidationsWithParticipants_hex_pub_key = md_PoCValidationsWithParticipants.Fields().ByName("hex_pub_key")
-	fd_PoCValidationsWithParticipants_poc_validation = md_PoCValidationsWithParticipants.Fields().ByName("poc_validation")
+	md_QueryPocValidationsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryPocValidationsForStageRequest")
+	fd_QueryPocValidationsForStageRequest_block_height = md_QueryPocValidationsForStageRequest.Fields().ByName("block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_PoCValidationsWithParticipants)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPocValidationsForStageRequest)(nil)
 
-type fastReflection_PoCValidationsWithParticipants PoCValidationsWithParticipants
+type fastReflection_QueryPocValidationsForStageRequest QueryPocValidationsForStageRequest
 
-func (x *PoCValidationsWithParticipants) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_PoCValidationsWithParticipants)(x)
+func (x *QueryPocValidationsForStageRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPocValidationsForStageRequest)(x)
 }
 
-func (x *PoCValidationsWithParticipants) slowProtoReflect() protoreflect.Message {
+func (x *QueryPocValidationsForStageRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[31]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -14644,43 +14544,43 @@ func (x *PoCValidationsWithParticipants) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_PoCValidationsWithParticipants_messageType fastReflection_PoCValidationsWithParticipants_messageType
-var _ protoreflect.MessageType = fastReflection_PoCValidationsWithParticipants_messageType{}
+var _fastReflection_QueryPocValidationsForStageRequest_messageType fastReflection_QueryPocValidationsForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocValidationsForStageRequest_messageType{}
 
-type fastReflection_PoCValidationsWithParticipants_messageType struct{}
+type fastReflection_QueryPocValidationsForStageRequest_messageType struct{}
 
-func (x fastReflection_PoCValidationsWithParticipants_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_PoCValidationsWithParticipants)(nil)
+func (x fastReflection_QueryPocValidationsForStageRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPocValidationsForStageRequest)(nil)
 }
-func (x fastReflection_PoCValidationsWithParticipants_messageType) New() protoreflect.Message {
-	return new(fastReflection_PoCValidationsWithParticipants)
+func (x fastReflection_QueryPocValidationsForStageRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPocValidationsForStageRequest)
 }
-func (x fastReflection_PoCValidationsWithParticipants_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCValidationsWithParticipants
+func (x fastReflection_QueryPocValidationsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocValidationsForStageRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_PoCValidationsWithParticipants) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCValidationsWithParticipants
+func (x *fastReflection_QueryPocValidationsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocValidationsForStageRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_PoCValidationsWithParticipants) Type() protoreflect.MessageType {
-	return _fastReflection_PoCValidationsWithParticipants_messageType
+func (x *fastReflection_QueryPocValidationsForStageRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPocValidationsForStageRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_PoCValidationsWithParticipants) New() protoreflect.Message {
-	return new(fastReflection_PoCValidationsWithParticipants)
+func (x *fastReflection_QueryPocValidationsForStageRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPocValidationsForStageRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_PoCValidationsWithParticipants) Interface() protoreflect.ProtoMessage {
-	return (*PoCValidationsWithParticipants)(x)
+func (x *fastReflection_QueryPocValidationsForStageRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPocValidationsForStageRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -14688,28 +14588,10 @@ func (x *fastReflection_PoCValidationsWithParticipants) Interface() protoreflect
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_PoCValidationsWithParticipants) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Participant != "" {
-		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_PoCValidationsWithParticipants_participant, value) {
-			return
-		}
-	}
-	if x.PubKey != "" {
-		value := protoreflect.ValueOfString(x.PubKey)
-		if !f(fd_PoCValidationsWithParticipants_pub_key, value) {
-			return
-		}
-	}
-	if x.HexPubKey != "" {
-		value := protoreflect.ValueOfString(x.HexPubKey)
-		if !f(fd_PoCValidationsWithParticipants_hex_pub_key, value) {
-			return
-		}
-	}
-	if len(x.PocValidation) != 0 {
-		value := protoreflect.ValueOfList(&_PoCValidationsWithParticipants_4_list{list: &x.PocValidation})
-		if !f(fd_PoCValidationsWithParticipants_poc_validation, value) {
+func (x *fastReflection_QueryPocValidationsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_QueryPocValidationsForStageRequest_block_height, value) {
 			return
 		}
 	}
@@ -14726,21 +14608,15 @@ func (x *fastReflection_PoCValidationsWithParticipants) Range(f func(protoreflec
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_PoCValidationsWithParticipants) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPocValidationsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipants.participant":
-		return x.Participant != ""
-	case "inference.inference.PoCValidationsWithParticipants.pub_key":
-		return x.PubKey != ""
-	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
-		return x.HexPubKey != ""
-	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
-		return len(x.PocValidation) != 0
+	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
+		return x.BlockHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14750,21 +14626,15 @@ func (x *fastReflection_PoCValidationsWithParticipants) Has(fd protoreflect.Fiel
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipants) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPocValidationsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipants.participant":
-		x.Participant = ""
-	case "inference.inference.PoCValidationsWithParticipants.pub_key":
-		x.PubKey = ""
-	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
-		x.HexPubKey = ""
-	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
-		x.PocValidation = nil
+	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
+		x.BlockHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14774,28 +14644,16 @@ func (x *fastReflection_PoCValidationsWithParticipants) Clear(fd protoreflect.Fi
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_PoCValidationsWithParticipants) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocValidationsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.PoCValidationsWithParticipants.participant":
-		value := x.Participant
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCValidationsWithParticipants.pub_key":
-		value := x.PubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
-		value := x.HexPubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
-		if len(x.PocValidation) == 0 {
-			return protoreflect.ValueOfList(&_PoCValidationsWithParticipants_4_list{})
-		}
-		listValue := &_PoCValidationsWithParticipants_4_list{list: &x.PocValidation}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -14809,23 +14667,15 @@ func (x *fastReflection_PoCValidationsWithParticipants) Get(descriptor protorefl
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipants) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPocValidationsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipants.participant":
-		x.Participant = value.Interface().(string)
-	case "inference.inference.PoCValidationsWithParticipants.pub_key":
-		x.PubKey = value.Interface().(string)
-	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
-		x.HexPubKey = value.Interface().(string)
-	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
-		lv := value.List()
-		clv := lv.(*_PoCValidationsWithParticipants_4_list)
-		x.PocValidation = *clv.list
+	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
+		x.BlockHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14839,57 +14689,40 @@ func (x *fastReflection_PoCValidationsWithParticipants) Set(fd protoreflect.Fiel
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipants) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocValidationsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
-		if x.PocValidation == nil {
-			x.PocValidation = []*PoCValidation{}
-		}
-		value := &_PoCValidationsWithParticipants_4_list{list: &x.PocValidation}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.PoCValidationsWithParticipants.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.PoCValidationsWithParticipants is not mutable"))
-	case "inference.inference.PoCValidationsWithParticipants.pub_key":
-		panic(fmt.Errorf("field pub_key of message inference.inference.PoCValidationsWithParticipants is not mutable"))
-	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
-		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCValidationsWithParticipants is not mutable"))
+	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryPocValidationsForStageRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_PoCValidationsWithParticipants) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocValidationsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipants.participant":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCValidationsWithParticipants.pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
-		list := []*PoCValidation{}
-		return protoreflect.ValueOfList(&_PoCValidationsWithParticipants_4_list{list: &list})
+	case "inference.inference.QueryPocValidationsForStageRequest.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_PoCValidationsWithParticipants) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPocValidationsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCValidationsWithParticipants", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocValidationsForStageRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -14897,7 +14730,7 @@ func (x *fastReflection_PoCValidationsWithParticipants) WhichOneof(d protoreflec
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_PoCValidationsWithParticipants) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPocValidationsForStageRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -14908,7 +14741,7 @@ func (x *fastReflection_PoCValidationsWithParticipants) GetUnknown() protoreflec
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipants) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPocValidationsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -14920,7 +14753,7 @@ func (x *fastReflection_PoCValidationsWithParticipants) SetUnknown(fields protor
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_PoCValidationsWithParticipants) IsValid() bool {
+func (x *fastReflection_QueryPocValidationsForStageRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -14930,9 +14763,9 @@ func (x *fastReflection_PoCValidationsWithParticipants) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPocValidationsForStageRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*PoCValidationsWithParticipants)
+		x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14944,23 +14777,8 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 		var n int
 		var l int
 		_ = l
-		l = len(x.Participant)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.PubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.HexPubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.PocValidation) > 0 {
-			for _, e := range x.PocValidation {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -14972,7 +14790,7 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*PoCValidationsWithParticipants)
+		x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14991,42 +14809,10 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.PocValidation) > 0 {
-			for iNdEx := len(x.PocValidation) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.PocValidation[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x22
-			}
-		}
-		if len(x.HexPubKey) > 0 {
-			i -= len(x.HexPubKey)
-			copy(dAtA[i:], x.HexPubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.PubKey) > 0 {
-			i -= len(x.PubKey)
-			copy(dAtA[i:], x.PubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Participant) > 0 {
-			i -= len(x.Participant)
-			copy(dAtA[i:], x.Participant)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -15039,7 +14825,7 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*PoCValidationsWithParticipants)
+		x := input.Message.Interface().(*QueryPocValidationsForStageRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15071,113 +14857,17 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipants: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Participant = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HexPubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				var msglen int
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -15187,26 +14877,11 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.BlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PocValidation = append(x.PocValidation, &PoCValidation{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -15242,26 +14917,77 @@ func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoifa
 	}
 }
 
+var _ protoreflect.List = (*_QueryPocValidationsForStageResponse_1_list)(nil)
+
+type _QueryPocValidationsForStageResponse_1_list struct {
+	list *[]*PoCValidationsWithParticipants
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipants)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipants)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(PoCValidationsWithParticipants)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) NewElement() protoreflect.Value {
+	v := new(PoCValidationsWithParticipants)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryPocValidationsForStageResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryPocV2ValidationsForStageRequest              protoreflect.MessageDescriptor
-	fd_QueryPocV2ValidationsForStageRequest_block_height protoreflect.FieldDescriptor
+	md_QueryPocValidationsForStageResponse                protoreflect.MessageDescriptor
+	fd_QueryPocValidationsForStageResponse_poc_validation protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPocV2ValidationsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryPocV2ValidationsForStageRequest")
-	fd_QueryPocV2ValidationsForStageRequest_block_height = md_QueryPocV2ValidationsForStageRequest.Fields().ByName("block_height")
+	md_QueryPocValidationsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryPocValidationsForStageResponse")
+	fd_QueryPocValidationsForStageResponse_poc_validation = md_QueryPocValidationsForStageResponse.Fields().ByName("poc_validation")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPocV2ValidationsForStageRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPocValidationsForStageResponse)(nil)
 
-type fastReflection_QueryPocV2ValidationsForStageRequest QueryPocV2ValidationsForStageRequest
+type fastReflection_QueryPocValidationsForStageResponse QueryPocValidationsForStageResponse
 
-func (x *QueryPocV2ValidationsForStageRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPocV2ValidationsForStageRequest)(x)
+func (x *QueryPocValidationsForStageResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPocValidationsForStageResponse)(x)
 }
 
-func (x *QueryPocV2ValidationsForStageRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPocValidationsForStageResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[32]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -15273,43 +14999,43 @@ func (x *QueryPocV2ValidationsForStageRequest) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPocV2ValidationsForStageRequest_messageType fastReflection_QueryPocV2ValidationsForStageRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPocV2ValidationsForStageRequest_messageType{}
+var _fastReflection_QueryPocValidationsForStageResponse_messageType fastReflection_QueryPocValidationsForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocValidationsForStageResponse_messageType{}
 
-type fastReflection_QueryPocV2ValidationsForStageRequest_messageType struct{}
+type fastReflection_QueryPocValidationsForStageResponse_messageType struct{}
 
-func (x fastReflection_QueryPocV2ValidationsForStageRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPocV2ValidationsForStageRequest)(nil)
+func (x fastReflection_QueryPocValidationsForStageResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPocValidationsForStageResponse)(nil)
 }
-func (x fastReflection_QueryPocV2ValidationsForStageRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPocV2ValidationsForStageRequest)
+func (x fastReflection_QueryPocValidationsForStageResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPocValidationsForStageResponse)
 }
-func (x fastReflection_QueryPocV2ValidationsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocV2ValidationsForStageRequest
+func (x fastReflection_QueryPocValidationsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocValidationsForStageResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocV2ValidationsForStageRequest
+func (x *fastReflection_QueryPocValidationsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocValidationsForStageResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPocV2ValidationsForStageRequest_messageType
+func (x *fastReflection_QueryPocValidationsForStageResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPocValidationsForStageResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPocV2ValidationsForStageRequest)
+func (x *fastReflection_QueryPocValidationsForStageResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPocValidationsForStageResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPocV2ValidationsForStageRequest)(x)
+func (x *fastReflection_QueryPocValidationsForStageResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPocValidationsForStageResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -15317,10 +15043,10 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.BlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.BlockHeight)
-		if !f(fd_QueryPocV2ValidationsForStageRequest_block_height, value) {
+func (x *fastReflection_QueryPocValidationsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.PocValidation) != 0 {
+		value := protoreflect.ValueOfList(&_QueryPocValidationsForStageResponse_1_list{list: &x.PocValidation})
+		if !f(fd_QueryPocValidationsForStageResponse_poc_validation, value) {
 			return
 		}
 	}
@@ -15337,15 +15063,15 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPocValidationsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
-		return x.BlockHeight != int64(0)
+	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+		return len(x.PocValidation) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15355,15 +15081,15 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPocValidationsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
-		x.BlockHeight = int64(0)
+	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+		x.PocValidation = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15373,16 +15099,19 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocValidationsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+		if len(x.PocValidation) == 0 {
+			return protoreflect.ValueOfList(&_QueryPocValidationsForStageResponse_1_list{})
+		}
+		listValue := &_QueryPocValidationsForStageResponse_1_list{list: &x.PocValidation}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -15396,15 +15125,17 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPocValidationsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
-		x.BlockHeight = value.Int()
+	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+		lv := value.List()
+		clv := lv.(*_QueryPocValidationsForStageResponse_1_list)
+		x.PocValidation = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15418,40 +15149,45 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocValidationsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryPocV2ValidationsForStageRequest is not mutable"))
+	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+		if x.PocValidation == nil {
+			x.PocValidation = []*PoCValidationsWithParticipants{}
+		}
+		value := &_QueryPocValidationsForStageResponse_1_list{list: &x.PocValidation}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocValidationsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryPocValidationsForStageResponse.poc_validation":
+		list := []*PoCValidationsWithParticipants{}
+		return protoreflect.ValueOfList(&_QueryPocValidationsForStageResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPocValidationsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocV2ValidationsForStageRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocValidationsForStageResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -15459,7 +15195,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPocValidationsForStageResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -15470,7 +15206,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPocValidationsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -15482,7 +15218,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) IsValid() bool {
+func (x *fastReflection_QueryPocValidationsForStageResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -15492,9 +15228,9 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPocValidationsForStageResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPocV2ValidationsForStageRequest)
+		x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15506,8 +15242,11 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 		var n int
 		var l int
 		_ = l
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if len(x.PocValidation) > 0 {
+			for _, e := range x.PocValidation {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -15519,7 +15258,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocV2ValidationsForStageRequest)
+		x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15538,15 +15277,26 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
-			i--
-			dAtA[i] = 0x8
-		}
-		if input.Buf != nil {
-			input.Buf = append(input.Buf, dAtA...)
-		} else {
-			input.Buf = dAtA
+		if len(x.PocValidation) > 0 {
+			for iNdEx := len(x.PocValidation) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.PocValidation[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
 		}
 		return protoiface.MarshalOutput{
 			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15554,7 +15304,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocV2ValidationsForStageRequest)
+		x := input.Message.Interface().(*QueryPocValidationsForStageResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15586,17 +15336,17 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
 				}
-				x.BlockHeight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -15606,11 +15356,26 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= int64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.PocValidation = append(x.PocValidation, &PoCValidationsWithParticipants{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -15646,77 +15411,83 @@ func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *pr
 	}
 }
 
-var _ protoreflect.List = (*_QueryPocV2ValidationsForStageResponse_1_list)(nil)
+var _ protoreflect.List = (*_PoCValidationsWithParticipants_4_list)(nil)
 
-type _QueryPocV2ValidationsForStageResponse_1_list struct {
-	list *[]*PoCValidationsWithParticipantsV2
+type _PoCValidationsWithParticipants_4_list struct {
+	list *[]*PoCValidation
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) Len() int {
+func (x *_PoCValidationsWithParticipants_4_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_PoCValidationsWithParticipants_4_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_PoCValidationsWithParticipants_4_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipantsV2)
+	concreteValue := valueUnwrapped.Interface().(*PoCValidation)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) Append(value protoreflect.Value) {
+func (x *_PoCValidationsWithParticipants_4_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipantsV2)
+	concreteValue := valueUnwrapped.Interface().(*PoCValidation)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(PoCValidationsWithParticipantsV2)
+func (x *_PoCValidationsWithParticipants_4_list) AppendMutable() protoreflect.Value {
+	v := new(PoCValidation)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) Truncate(n int) {
+func (x *_PoCValidationsWithParticipants_4_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) NewElement() protoreflect.Value {
-	v := new(PoCValidationsWithParticipantsV2)
+func (x *_PoCValidationsWithParticipants_4_list) NewElement() protoreflect.Value {
+	v := new(PoCValidation)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryPocV2ValidationsForStageResponse_1_list) IsValid() bool {
+func (x *_PoCValidationsWithParticipants_4_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryPocV2ValidationsForStageResponse                protoreflect.MessageDescriptor
-	fd_QueryPocV2ValidationsForStageResponse_poc_validation protoreflect.FieldDescriptor
+	md_PoCValidationsWithParticipants                protoreflect.MessageDescriptor
+	fd_PoCValidationsWithParticipants_participant    protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipants_pub_key        protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipants_hex_pub_key    protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipants_poc_validation protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPocV2ValidationsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryPocV2ValidationsForStageResponse")
-	fd_QueryPocV2ValidationsForStageResponse_poc_validation = md_QueryPocV2ValidationsForStageResponse.Fields().ByName("poc_validation")
+	md_PoCValidationsWithParticipants = File_inference_inference_query_proto.Messages().ByName("PoCValidationsWithParticipants")
+	fd_PoCValidationsWithParticipants_participant = md_PoCValidationsWithParticipants.Fields().ByName("participant")
+	fd_PoCValidationsWithParticipants_pub_key = md_PoCValidationsWithParticipants.Fields().ByName("pub_key")
+	fd_PoCValidationsWithParticipants_hex_pub_key = md_PoCValidationsWithParticipants.Fields().ByName("hex_pub_key")
+	fd_PoCValidationsWithParticipants_poc_validation = md_PoCValidationsWithParticipants.Fields().ByName("poc_validation")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPocV2ValidationsForStageResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_PoCValidationsWithParticipants)(nil)
 
-type fastReflection_QueryPocV2ValidationsForStageResponse QueryPocV2ValidationsForStageResponse
+type fastReflection_PoCValidationsWithParticipants PoCValidationsWithParticipants
 
-func (x *QueryPocV2ValidationsForStageResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPocV2ValidationsForStageResponse)(x)
+func (x *PoCValidationsWithParticipants) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_PoCValidationsWithParticipants)(x)
 }
 
-func (x *QueryPocV2ValidationsForStageResponse) slowProtoReflect() protoreflect.Message {
+func (x *PoCValidationsWithParticipants) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[33]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -15728,43 +15499,43 @@ func (x *QueryPocV2ValidationsForStageResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPocV2ValidationsForStageResponse_messageType fastReflection_QueryPocV2ValidationsForStageResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPocV2ValidationsForStageResponse_messageType{}
+var _fastReflection_PoCValidationsWithParticipants_messageType fastReflection_PoCValidationsWithParticipants_messageType
+var _ protoreflect.MessageType = fastReflection_PoCValidationsWithParticipants_messageType{}
 
-type fastReflection_QueryPocV2ValidationsForStageResponse_messageType struct{}
+type fastReflection_PoCValidationsWithParticipants_messageType struct{}
 
-func (x fastReflection_QueryPocV2ValidationsForStageResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPocV2ValidationsForStageResponse)(nil)
+func (x fastReflection_PoCValidationsWithParticipants_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_PoCValidationsWithParticipants)(nil)
 }
-func (x fastReflection_QueryPocV2ValidationsForStageResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPocV2ValidationsForStageResponse)
+func (x fastReflection_PoCValidationsWithParticipants_messageType) New() protoreflect.Message {
+	return new(fastReflection_PoCValidationsWithParticipants)
 }
-func (x fastReflection_QueryPocV2ValidationsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocV2ValidationsForStageResponse
+func (x fastReflection_PoCValidationsWithParticipants_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCValidationsWithParticipants
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPocV2ValidationsForStageResponse
+func (x *fastReflection_PoCValidationsWithParticipants) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCValidationsWithParticipants
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPocV2ValidationsForStageResponse_messageType
+func (x *fastReflection_PoCValidationsWithParticipants) Type() protoreflect.MessageType {
+	return _fastReflection_PoCValidationsWithParticipants_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPocV2ValidationsForStageResponse)
+func (x *fastReflection_PoCValidationsWithParticipants) New() protoreflect.Message {
+	return new(fastReflection_PoCValidationsWithParticipants)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPocV2ValidationsForStageResponse)(x)
+func (x *fastReflection_PoCValidationsWithParticipants) Interface() protoreflect.ProtoMessage {
+	return (*PoCValidationsWithParticipants)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -15772,10 +15543,28 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_PoCValidationsWithParticipants) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_PoCValidationsWithParticipants_participant, value) {
+			return
+		}
+	}
+	if x.PubKey != "" {
+		value := protoreflect.ValueOfString(x.PubKey)
+		if !f(fd_PoCValidationsWithParticipants_pub_key, value) {
+			return
+		}
+	}
+	if x.HexPubKey != "" {
+		value := protoreflect.ValueOfString(x.HexPubKey)
+		if !f(fd_PoCValidationsWithParticipants_hex_pub_key, value) {
+			return
+		}
+	}
 	if len(x.PocValidation) != 0 {
-		value := protoreflect.ValueOfList(&_QueryPocV2ValidationsForStageResponse_1_list{list: &x.PocValidation})
-		if !f(fd_QueryPocV2ValidationsForStageResponse_poc_validation, value) {
+		value := protoreflect.ValueOfList(&_PoCValidationsWithParticipants_4_list{list: &x.PocValidation})
+		if !f(fd_PoCValidationsWithParticipants_poc_validation, value) {
 			return
 		}
 	}
@@ -15792,15 +15581,21 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_PoCValidationsWithParticipants) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+	case "inference.inference.PoCValidationsWithParticipants.participant":
+		return x.Participant != ""
+	case "inference.inference.PoCValidationsWithParticipants.pub_key":
+		return x.PubKey != ""
+	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
+		return x.HexPubKey != ""
+	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
 		return len(x.PocValidation) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15810,15 +15605,21 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_PoCValidationsWithParticipants) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+	case "inference.inference.PoCValidationsWithParticipants.participant":
+		x.Participant = ""
+	case "inference.inference.PoCValidationsWithParticipants.pub_key":
+		x.PubKey = ""
+	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
+		x.HexPubKey = ""
+	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
 		x.PocValidation = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15828,19 +15629,28 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCValidationsWithParticipants) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+	case "inference.inference.PoCValidationsWithParticipants.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCValidationsWithParticipants.pub_key":
+		value := x.PubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
+		value := x.HexPubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
 		if len(x.PocValidation) == 0 {
-			return protoreflect.ValueOfList(&_QueryPocV2ValidationsForStageResponse_1_list{})
+			return protoreflect.ValueOfList(&_PoCValidationsWithParticipants_4_list{})
 		}
-		listValue := &_QueryPocV2ValidationsForStageResponse_1_list{list: &x.PocValidation}
+		listValue := &_PoCValidationsWithParticipants_4_list{list: &x.PocValidation}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -15854,17 +15664,23 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_PoCValidationsWithParticipants) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+	case "inference.inference.PoCValidationsWithParticipants.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.PoCValidationsWithParticipants.pub_key":
+		x.PubKey = value.Interface().(string)
+	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
+		x.HexPubKey = value.Interface().(string)
+	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
 		lv := value.List()
-		clv := lv.(*_QueryPocV2ValidationsForStageResponse_1_list)
+		clv := lv.(*_PoCValidationsWithParticipants_4_list)
 		x.PocValidation = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15878,45 +15694,57 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCValidationsWithParticipants) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
 		if x.PocValidation == nil {
-			x.PocValidation = []*PoCValidationsWithParticipantsV2{}
+			x.PocValidation = []*PoCValidation{}
 		}
-		value := &_QueryPocV2ValidationsForStageResponse_1_list{list: &x.PocValidation}
+		value := &_PoCValidationsWithParticipants_4_list{list: &x.PocValidation}
 		return protoreflect.ValueOfList(value)
+	case "inference.inference.PoCValidationsWithParticipants.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.PoCValidationsWithParticipants is not mutable"))
+	case "inference.inference.PoCValidationsWithParticipants.pub_key":
+		panic(fmt.Errorf("field pub_key of message inference.inference.PoCValidationsWithParticipants is not mutable"))
+	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
+		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCValidationsWithParticipants is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCValidationsWithParticipants) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
-		list := []*PoCValidationsWithParticipantsV2{}
-		return protoreflect.ValueOfList(&_QueryPocV2ValidationsForStageResponse_1_list{list: &list})
+	case "inference.inference.PoCValidationsWithParticipants.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCValidationsWithParticipants.pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCValidationsWithParticipants.hex_pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCValidationsWithParticipants.poc_validation":
+		list := []*PoCValidation{}
+		return protoreflect.ValueOfList(&_PoCValidationsWithParticipants_4_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipants"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipants does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_PoCValidationsWithParticipants) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocV2ValidationsForStageResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCValidationsWithParticipants", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -15924,7 +15752,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_PoCValidationsWithParticipants) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -15935,7 +15763,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_PoCValidationsWithParticipants) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -15947,7 +15775,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) IsValid() bool {
+func (x *fastReflection_PoCValidationsWithParticipants) IsValid() bool {
 	return x != nil
 }
 
@@ -15957,9 +15785,9 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_PoCValidationsWithParticipants) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPocV2ValidationsForStageResponse)
+		x := input.Message.Interface().(*PoCValidationsWithParticipants)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15971,6 +15799,18 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.PubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.HexPubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if len(x.PocValidation) > 0 {
 			for _, e := range x.PocValidation {
 				l = options.Size(e)
@@ -15987,7 +15827,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocV2ValidationsForStageResponse)
+		x := input.Message.Interface().(*PoCValidationsWithParticipants)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16019,9 +15859,30 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 				copy(dAtA[i:], encoded)
 				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 				i--
-				dAtA[i] = 0xa
+				dAtA[i] = 0x22
 			}
 		}
+		if len(x.HexPubKey) > 0 {
+			i -= len(x.HexPubKey)
+			copy(dAtA[i:], x.HexPubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.PubKey) > 0 {
+			i -= len(x.PubKey)
+			copy(dAtA[i:], x.PubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -16033,7 +15894,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPocV2ValidationsForStageResponse)
+		x := input.Message.Interface().(*PoCValidationsWithParticipants)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16065,13 +15926,109 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipants: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.PubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.HexPubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
 				if wireType != 2 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
 				}
@@ -16100,7 +16057,7 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.PocValidation = append(x.PocValidation, &PoCValidationsWithParticipantsV2{})
+				x.PocValidation = append(x.PocValidation, &PoCValidation{})
 				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
@@ -16140,85 +16097,26 @@ func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *p
 	}
 }
 
-var _ protoreflect.List = (*_PoCValidationsWithParticipantsV2_4_list)(nil)
-
-type _PoCValidationsWithParticipantsV2_4_list struct {
-	list *[]*PoCValidationV2
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationV2)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationV2)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) AppendMutable() protoreflect.Value {
-	v := new(PoCValidationV2)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) NewElement() protoreflect.Value {
-	v := new(PoCValidationV2)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_PoCValidationsWithParticipantsV2_4_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_PoCValidationsWithParticipantsV2                protoreflect.MessageDescriptor
-	fd_PoCValidationsWithParticipantsV2_participant    protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipantsV2_pub_key        protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipantsV2_hex_pub_key    protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipantsV2_poc_validation protoreflect.FieldDescriptor
-	fd_PoCValidationsWithParticipantsV2_model_id       protoreflect.FieldDescriptor
+	md_QueryPocV2ValidationsForStageRequest              protoreflect.MessageDescriptor
+	fd_QueryPocV2ValidationsForStageRequest_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_PoCValidationsWithParticipantsV2 = File_inference_inference_query_proto.Messages().ByName("PoCValidationsWithParticipantsV2")
-	fd_PoCValidationsWithParticipantsV2_participant = md_PoCValidationsWithParticipantsV2.Fields().ByName("participant")
-	fd_PoCValidationsWithParticipantsV2_pub_key = md_PoCValidationsWithParticipantsV2.Fields().ByName("pub_key")
-	fd_PoCValidationsWithParticipantsV2_hex_pub_key = md_PoCValidationsWithParticipantsV2.Fields().ByName("hex_pub_key")
-	fd_PoCValidationsWithParticipantsV2_poc_validation = md_PoCValidationsWithParticipantsV2.Fields().ByName("poc_validation")
-	fd_PoCValidationsWithParticipantsV2_model_id = md_PoCValidationsWithParticipantsV2.Fields().ByName("model_id")
+	md_QueryPocV2ValidationsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryPocV2ValidationsForStageRequest")
+	fd_QueryPocV2ValidationsForStageRequest_block_height = md_QueryPocV2ValidationsForStageRequest.Fields().ByName("block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_PoCValidationsWithParticipantsV2)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPocV2ValidationsForStageRequest)(nil)
 
-type fastReflection_PoCValidationsWithParticipantsV2 PoCValidationsWithParticipantsV2
+type fastReflection_QueryPocV2ValidationsForStageRequest QueryPocV2ValidationsForStageRequest
 
-func (x *PoCValidationsWithParticipantsV2) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_PoCValidationsWithParticipantsV2)(x)
+func (x *QueryPocV2ValidationsForStageRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPocV2ValidationsForStageRequest)(x)
 }
 
-func (x *PoCValidationsWithParticipantsV2) slowProtoReflect() protoreflect.Message {
+func (x *QueryPocV2ValidationsForStageRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[34]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -16230,43 +16128,43 @@ func (x *PoCValidationsWithParticipantsV2) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_PoCValidationsWithParticipantsV2_messageType fastReflection_PoCValidationsWithParticipantsV2_messageType
-var _ protoreflect.MessageType = fastReflection_PoCValidationsWithParticipantsV2_messageType{}
+var _fastReflection_QueryPocV2ValidationsForStageRequest_messageType fastReflection_QueryPocV2ValidationsForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocV2ValidationsForStageRequest_messageType{}
 
-type fastReflection_PoCValidationsWithParticipantsV2_messageType struct{}
+type fastReflection_QueryPocV2ValidationsForStageRequest_messageType struct{}
 
-func (x fastReflection_PoCValidationsWithParticipantsV2_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_PoCValidationsWithParticipantsV2)(nil)
+func (x fastReflection_QueryPocV2ValidationsForStageRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPocV2ValidationsForStageRequest)(nil)
 }
-func (x fastReflection_PoCValidationsWithParticipantsV2_messageType) New() protoreflect.Message {
-	return new(fastReflection_PoCValidationsWithParticipantsV2)
+func (x fastReflection_QueryPocV2ValidationsForStageRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPocV2ValidationsForStageRequest)
 }
-func (x fastReflection_PoCValidationsWithParticipantsV2_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCValidationsWithParticipantsV2
+func (x fastReflection_QueryPocV2ValidationsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocV2ValidationsForStageRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCValidationsWithParticipantsV2
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocV2ValidationsForStageRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Type() protoreflect.MessageType {
-	return _fastReflection_PoCValidationsWithParticipantsV2_messageType
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPocV2ValidationsForStageRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) New() protoreflect.Message {
-	return new(fastReflection_PoCValidationsWithParticipantsV2)
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPocV2ValidationsForStageRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Interface() protoreflect.ProtoMessage {
-	return (*PoCValidationsWithParticipantsV2)(x)
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPocV2ValidationsForStageRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -16274,34 +16172,10 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Participant != "" {
-		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_PoCValidationsWithParticipantsV2_participant, value) {
-			return
-		}
-	}
-	if x.PubKey != "" {
-		value := protoreflect.ValueOfString(x.PubKey)
-		if !f(fd_PoCValidationsWithParticipantsV2_pub_key, value) {
-			return
-		}
-	}
-	if x.HexPubKey != "" {
-		value := protoreflect.ValueOfString(x.HexPubKey)
-		if !f(fd_PoCValidationsWithParticipantsV2_hex_pub_key, value) {
-			return
-		}
-	}
-	if len(x.PocValidation) != 0 {
-		value := protoreflect.ValueOfList(&_PoCValidationsWithParticipantsV2_4_list{list: &x.PocValidation})
-		if !f(fd_PoCValidationsWithParticipantsV2_poc_validation, value) {
-			return
-		}
-	}
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_PoCValidationsWithParticipantsV2_model_id, value) {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_QueryPocV2ValidationsForStageRequest_block_height, value) {
 			return
 		}
 	}
@@ -16318,23 +16192,15 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
-		return x.Participant != ""
-	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
-		return x.PubKey != ""
-	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
-		return x.HexPubKey != ""
-	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
-		return len(x.PocValidation) != 0
-	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
-		return x.ModelId != ""
+	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
+		return x.BlockHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16344,23 +16210,15 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
-		x.Participant = ""
-	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
-		x.PubKey = ""
-	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
-		x.HexPubKey = ""
-	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
-		x.PocValidation = nil
-	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
-		x.ModelId = ""
+	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
+		x.BlockHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16370,31 +16228,16 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
-		value := x.Participant
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
-		value := x.PubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
-		value := x.HexPubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
-		if len(x.PocValidation) == 0 {
-			return protoreflect.ValueOfList(&_PoCValidationsWithParticipantsV2_4_list{})
-		}
-		listValue := &_PoCValidationsWithParticipantsV2_4_list{list: &x.PocValidation}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -16408,25 +16251,15 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
-		x.Participant = value.Interface().(string)
-	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
-		x.PubKey = value.Interface().(string)
-	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
-		x.HexPubKey = value.Interface().(string)
-	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
-		lv := value.List()
-		clv := lv.(*_PoCValidationsWithParticipantsV2_4_list)
-		x.PocValidation = *clv.list
-	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
-		x.ModelId = value.Interface().(string)
+	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
+		x.BlockHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16440,61 +16273,40 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
-		if x.PocValidation == nil {
-			x.PocValidation = []*PoCValidationV2{}
-		}
-		value := &_PoCValidationsWithParticipantsV2_4_list{list: &x.PocValidation}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
-	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
-		panic(fmt.Errorf("field pub_key of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
-	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
-		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
-	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
+	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryPocV2ValidationsForStageRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
-		list := []*PoCValidationV2{}
-		return protoreflect.ValueOfList(&_PoCValidationsWithParticipantsV2_4_list{list: &list})
-	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryPocV2ValidationsForStageRequest.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCValidationsWithParticipantsV2", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocV2ValidationsForStageRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -16502,7 +16314,7 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -16513,7 +16325,7 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -16525,7 +16337,7 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) IsValid() bool {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -16535,9 +16347,9 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPocV2ValidationsForStageRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*PoCValidationsWithParticipantsV2)
+		x := input.Message.Interface().(*QueryPocV2ValidationsForStageRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16549,27 +16361,8 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
-		l = len(x.Participant)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.PubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.HexPubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.PocValidation) > 0 {
-			for _, e := range x.PocValidation {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -16581,7 +16374,7 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*PoCValidationsWithParticipantsV2)
+		x := input.Message.Interface().(*QueryPocV2ValidationsForStageRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16600,49 +16393,10 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.PocValidation) > 0 {
-			for iNdEx := len(x.PocValidation) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.PocValidation[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x22
-			}
-		}
-		if len(x.HexPubKey) > 0 {
-			i -= len(x.HexPubKey)
-			copy(dAtA[i:], x.HexPubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.PubKey) > 0 {
-			i -= len(x.PubKey)
-			copy(dAtA[i:], x.PubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Participant) > 0 {
-			i -= len(x.Participant)
-			copy(dAtA[i:], x.Participant)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -16655,7 +16409,7 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*PoCValidationsWithParticipantsV2)
+		x := input.Message.Interface().(*QueryPocV2ValidationsForStageRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16687,147 +16441,17 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipantsV2: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipantsV2: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Participant = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HexPubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PocValidation = append(x.PocValidation, &PoCValidationV2{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				var stringLen uint64
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -16837,24 +16461,11 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.BlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -16890,30 +16501,77 @@ func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoi
 	}
 }
 
+var _ protoreflect.List = (*_QueryPocV2ValidationsForStageResponse_1_list)(nil)
+
+type _QueryPocV2ValidationsForStageResponse_1_list struct {
+	list *[]*PoCValidationsWithParticipantsV2
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipantsV2)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationsWithParticipantsV2)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(PoCValidationsWithParticipantsV2)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) NewElement() protoreflect.Value {
+	v := new(PoCValidationsWithParticipantsV2)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryPocV2ValidationsForStageResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryPoCV2StoreCommitRequest                              protoreflect.MessageDescriptor
-	fd_QueryPoCV2StoreCommitRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
-	fd_QueryPoCV2StoreCommitRequest_participant_address          protoreflect.FieldDescriptor
-	fd_QueryPoCV2StoreCommitRequest_model_id                     protoreflect.FieldDescriptor
+	md_QueryPocV2ValidationsForStageResponse                protoreflect.MessageDescriptor
+	fd_QueryPocV2ValidationsForStageResponse_poc_validation protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPoCV2StoreCommitRequest = File_inference_inference_query_proto.Messages().ByName("QueryPoCV2StoreCommitRequest")
-	fd_QueryPoCV2StoreCommitRequest_poc_stage_start_block_height = md_QueryPoCV2StoreCommitRequest.Fields().ByName("poc_stage_start_block_height")
-	fd_QueryPoCV2StoreCommitRequest_participant_address = md_QueryPoCV2StoreCommitRequest.Fields().ByName("participant_address")
-	fd_QueryPoCV2StoreCommitRequest_model_id = md_QueryPoCV2StoreCommitRequest.Fields().ByName("model_id")
+	md_QueryPocV2ValidationsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryPocV2ValidationsForStageResponse")
+	fd_QueryPocV2ValidationsForStageResponse_poc_validation = md_QueryPocV2ValidationsForStageResponse.Fields().ByName("poc_validation")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPoCV2StoreCommitRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPocV2ValidationsForStageResponse)(nil)
 
-type fastReflection_QueryPoCV2StoreCommitRequest QueryPoCV2StoreCommitRequest
+type fastReflection_QueryPocV2ValidationsForStageResponse QueryPocV2ValidationsForStageResponse
 
-func (x *QueryPoCV2StoreCommitRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPoCV2StoreCommitRequest)(x)
+func (x *QueryPocV2ValidationsForStageResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPocV2ValidationsForStageResponse)(x)
 }
 
-func (x *QueryPoCV2StoreCommitRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPocV2ValidationsForStageResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[35]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -16925,43 +16583,43 @@ func (x *QueryPoCV2StoreCommitRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPoCV2StoreCommitRequest_messageType fastReflection_QueryPoCV2StoreCommitRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPoCV2StoreCommitRequest_messageType{}
+var _fastReflection_QueryPocV2ValidationsForStageResponse_messageType fastReflection_QueryPocV2ValidationsForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPocV2ValidationsForStageResponse_messageType{}
 
-type fastReflection_QueryPoCV2StoreCommitRequest_messageType struct{}
+type fastReflection_QueryPocV2ValidationsForStageResponse_messageType struct{}
 
-func (x fastReflection_QueryPoCV2StoreCommitRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPoCV2StoreCommitRequest)(nil)
+func (x fastReflection_QueryPocV2ValidationsForStageResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPocV2ValidationsForStageResponse)(nil)
 }
-func (x fastReflection_QueryPoCV2StoreCommitRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCV2StoreCommitRequest)
+func (x fastReflection_QueryPocV2ValidationsForStageResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPocV2ValidationsForStageResponse)
 }
-func (x fastReflection_QueryPoCV2StoreCommitRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCV2StoreCommitRequest
+func (x fastReflection_QueryPocV2ValidationsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocV2ValidationsForStageResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCV2StoreCommitRequest
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPocV2ValidationsForStageResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPoCV2StoreCommitRequest_messageType
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPocV2ValidationsForStageResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCV2StoreCommitRequest)
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPocV2ValidationsForStageResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPoCV2StoreCommitRequest)(x)
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPocV2ValidationsForStageResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -16969,22 +16627,10 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.PocStageStartBlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_QueryPoCV2StoreCommitRequest_poc_stage_start_block_height, value) {
-			return
-		}
-	}
-	if x.ParticipantAddress != "" {
-		value := protoreflect.ValueOfString(x.ParticipantAddress)
-		if !f(fd_QueryPoCV2StoreCommitRequest_participant_address, value) {
-			return
-		}
-	}
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_QueryPoCV2StoreCommitRequest_model_id, value) {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.PocValidation) != 0 {
+		value := protoreflect.ValueOfList(&_QueryPocV2ValidationsForStageResponse_1_list{list: &x.PocValidation})
+		if !f(fd_QueryPocV2ValidationsForStageResponse_poc_validation, value) {
 			return
 		}
 	}
@@ -17001,19 +16647,15 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
-		return x.PocStageStartBlockHeight != int64(0)
-	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
-		return x.ParticipantAddress != ""
-	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
-		return x.ModelId != ""
+	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+		return len(x.PocValidation) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17023,19 +16665,15 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
-		x.PocStageStartBlockHeight = int64(0)
-	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
-		x.ParticipantAddress = ""
-	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
-		x.ModelId = ""
+	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+		x.PocValidation = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17045,22 +16683,19 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
-		value := x.PocStageStartBlockHeight
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
-		value := x.ParticipantAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+		if len(x.PocValidation) == 0 {
+			return protoreflect.ValueOfList(&_QueryPocV2ValidationsForStageResponse_1_list{})
+		}
+		listValue := &_QueryPocV2ValidationsForStageResponse_1_list{list: &x.PocValidation}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -17074,19 +16709,17 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
-		x.PocStageStartBlockHeight = value.Int()
-	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
-		x.ParticipantAddress = value.Interface().(string)
-	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
-		x.ModelId = value.Interface().(string)
+	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+		lv := value.List()
+		clv := lv.(*_QueryPocV2ValidationsForStageResponse_1_list)
+		x.PocValidation = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17100,48 +16733,45 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryPoCV2StoreCommitRequest is not mutable"))
-	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
-		panic(fmt.Errorf("field participant_address of message inference.inference.QueryPoCV2StoreCommitRequest is not mutable"))
-	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.QueryPoCV2StoreCommitRequest is not mutable"))
+	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+		if x.PocValidation == nil {
+			x.PocValidation = []*PoCValidationsWithParticipantsV2{}
+		}
+		value := &_QueryPocV2ValidationsForStageResponse_1_list{list: &x.PocValidation}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation":
+		list := []*PoCValidationsWithParticipantsV2{}
+		return protoreflect.ValueOfList(&_QueryPocV2ValidationsForStageResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPocV2ValidationsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPocV2ValidationsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCV2StoreCommitRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPocV2ValidationsForStageResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -17149,7 +16779,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -17160,7 +16790,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -17172,7 +16802,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) IsValid() bool {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -17182,9 +16812,9 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPocV2ValidationsForStageResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPoCV2StoreCommitRequest)
+		x := input.Message.Interface().(*QueryPocV2ValidationsForStageResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17196,16 +16826,11 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 		var n int
 		var l int
 		_ = l
-		if x.PocStageStartBlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
-		}
-		l = len(x.ParticipantAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.PocValidation) > 0 {
+			for _, e := range x.PocValidation {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -17217,7 +16842,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCV2StoreCommitRequest)
+		x := input.Message.Interface().(*QueryPocV2ValidationsForStageResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17236,24 +16861,21 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.ParticipantAddress) > 0 {
-			i -= len(x.ParticipantAddress)
-			copy(dAtA[i:], x.ParticipantAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantAddress)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if x.PocStageStartBlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
-			i--
-			dAtA[i] = 0x8
+		if len(x.PocValidation) > 0 {
+			for iNdEx := len(x.PocValidation) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.PocValidation[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -17266,7 +16888,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCV2StoreCommitRequest)
+		x := input.Message.Interface().(*QueryPocV2ValidationsForStageResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17298,36 +16920,17 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
-				}
-				x.PocStageStartBlockHeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.PocStageStartBlockHeight |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -17337,55 +16940,25 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ParticipantAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				x.PocValidation = append(x.PocValidation, &PoCValidationsWithParticipantsV2{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -17422,30 +16995,85 @@ func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface
 	}
 }
 
+var _ protoreflect.List = (*_PoCValidationsWithParticipantsV2_4_list)(nil)
+
+type _PoCValidationsWithParticipantsV2_4_list struct {
+	list *[]*PoCValidationV2
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationV2)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationV2)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) AppendMutable() protoreflect.Value {
+	v := new(PoCValidationV2)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) NewElement() protoreflect.Value {
+	v := new(PoCValidationV2)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_PoCValidationsWithParticipantsV2_4_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryPoCV2StoreCommitResponse           protoreflect.MessageDescriptor
-	fd_QueryPoCV2StoreCommitResponse_count     protoreflect.FieldDescriptor
-	fd_QueryPoCV2StoreCommitResponse_root_hash protoreflect.FieldDescriptor
-	fd_QueryPoCV2StoreCommitResponse_found     protoreflect.FieldDescriptor
+	md_PoCValidationsWithParticipantsV2                protoreflect.MessageDescriptor
+	fd_PoCValidationsWithParticipantsV2_participant    protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipantsV2_pub_key        protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipantsV2_hex_pub_key    protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipantsV2_poc_validation protoreflect.FieldDescriptor
+	fd_PoCValidationsWithParticipantsV2_model_id       protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPoCV2StoreCommitResponse = File_inference_inference_query_proto.Messages().ByName("QueryPoCV2StoreCommitResponse")
-	fd_QueryPoCV2StoreCommitResponse_count = md_QueryPoCV2StoreCommitResponse.Fields().ByName("count")
-	fd_QueryPoCV2StoreCommitResponse_root_hash = md_QueryPoCV2StoreCommitResponse.Fields().ByName("root_hash")
-	fd_QueryPoCV2StoreCommitResponse_found = md_QueryPoCV2StoreCommitResponse.Fields().ByName("found")
+	md_PoCValidationsWithParticipantsV2 = File_inference_inference_query_proto.Messages().ByName("PoCValidationsWithParticipantsV2")
+	fd_PoCValidationsWithParticipantsV2_participant = md_PoCValidationsWithParticipantsV2.Fields().ByName("participant")
+	fd_PoCValidationsWithParticipantsV2_pub_key = md_PoCValidationsWithParticipantsV2.Fields().ByName("pub_key")
+	fd_PoCValidationsWithParticipantsV2_hex_pub_key = md_PoCValidationsWithParticipantsV2.Fields().ByName("hex_pub_key")
+	fd_PoCValidationsWithParticipantsV2_poc_validation = md_PoCValidationsWithParticipantsV2.Fields().ByName("poc_validation")
+	fd_PoCValidationsWithParticipantsV2_model_id = md_PoCValidationsWithParticipantsV2.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPoCV2StoreCommitResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_PoCValidationsWithParticipantsV2)(nil)
 
-type fastReflection_QueryPoCV2StoreCommitResponse QueryPoCV2StoreCommitResponse
+type fastReflection_PoCValidationsWithParticipantsV2 PoCValidationsWithParticipantsV2
 
-func (x *QueryPoCV2StoreCommitResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPoCV2StoreCommitResponse)(x)
+func (x *PoCValidationsWithParticipantsV2) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_PoCValidationsWithParticipantsV2)(x)
 }
 
-func (x *QueryPoCV2StoreCommitResponse) slowProtoReflect() protoreflect.Message {
+func (x *PoCValidationsWithParticipantsV2) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[36]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -17457,43 +17085,43 @@ func (x *QueryPoCV2StoreCommitResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPoCV2StoreCommitResponse_messageType fastReflection_QueryPoCV2StoreCommitResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPoCV2StoreCommitResponse_messageType{}
+var _fastReflection_PoCValidationsWithParticipantsV2_messageType fastReflection_PoCValidationsWithParticipantsV2_messageType
+var _ protoreflect.MessageType = fastReflection_PoCValidationsWithParticipantsV2_messageType{}
 
-type fastReflection_QueryPoCV2StoreCommitResponse_messageType struct{}
+type fastReflection_PoCValidationsWithParticipantsV2_messageType struct{}
 
-func (x fastReflection_QueryPoCV2StoreCommitResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPoCV2StoreCommitResponse)(nil)
+func (x fastReflection_PoCValidationsWithParticipantsV2_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_PoCValidationsWithParticipantsV2)(nil)
 }
-func (x fastReflection_QueryPoCV2StoreCommitResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCV2StoreCommitResponse)
+func (x fastReflection_PoCValidationsWithParticipantsV2_messageType) New() protoreflect.Message {
+	return new(fastReflection_PoCValidationsWithParticipantsV2)
 }
-func (x fastReflection_QueryPoCV2StoreCommitResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCV2StoreCommitResponse
+func (x fastReflection_PoCValidationsWithParticipantsV2_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCValidationsWithParticipantsV2
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCV2StoreCommitResponse
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCValidationsWithParticipantsV2
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPoCV2StoreCommitResponse_messageType
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Type() protoreflect.MessageType {
+	return _fastReflection_PoCValidationsWithParticipantsV2_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCV2StoreCommitResponse)
+func (x *fastReflection_PoCValidationsWithParticipantsV2) New() protoreflect.Message {
+	return new(fastReflection_PoCValidationsWithParticipantsV2)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPoCV2StoreCommitResponse)(x)
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Interface() protoreflect.ProtoMessage {
+	return (*PoCValidationsWithParticipantsV2)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -17501,22 +17129,34 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Count != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Count)
-		if !f(fd_QueryPoCV2StoreCommitResponse_count, value) {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_PoCValidationsWithParticipantsV2_participant, value) {
 			return
 		}
 	}
-	if len(x.RootHash) != 0 {
-		value := protoreflect.ValueOfBytes(x.RootHash)
-		if !f(fd_QueryPoCV2StoreCommitResponse_root_hash, value) {
+	if x.PubKey != "" {
+		value := protoreflect.ValueOfString(x.PubKey)
+		if !f(fd_PoCValidationsWithParticipantsV2_pub_key, value) {
 			return
 		}
 	}
-	if x.Found != false {
-		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryPoCV2StoreCommitResponse_found, value) {
+	if x.HexPubKey != "" {
+		value := protoreflect.ValueOfString(x.HexPubKey)
+		if !f(fd_PoCValidationsWithParticipantsV2_hex_pub_key, value) {
+			return
+		}
+	}
+	if len(x.PocValidation) != 0 {
+		value := protoreflect.ValueOfList(&_PoCValidationsWithParticipantsV2_4_list{list: &x.PocValidation})
+		if !f(fd_PoCValidationsWithParticipantsV2_poc_validation, value) {
+			return
+		}
+	}
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_PoCValidationsWithParticipantsV2_model_id, value) {
 			return
 		}
 	}
@@ -17533,19 +17173,23 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
-		return x.Count != uint32(0)
-	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
-		return len(x.RootHash) != 0
-	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
-		return x.Found != false
+	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
+		return x.Participant != ""
+	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
+		return x.PubKey != ""
+	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
+		return x.HexPubKey != ""
+	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
+		return len(x.PocValidation) != 0
+	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17555,19 +17199,23 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
-		x.Count = uint32(0)
-	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
-		x.RootHash = nil
-	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
-		x.Found = false
+	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
+		x.Participant = ""
+	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
+		x.PubKey = ""
+	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
+		x.HexPubKey = ""
+	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
+		x.PocValidation = nil
+	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17577,22 +17225,31 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
-		value := x.Count
-		return protoreflect.ValueOfUint32(value)
-	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
-		value := x.RootHash
-		return protoreflect.ValueOfBytes(value)
-	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
-		value := x.Found
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
+		value := x.PubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
+		value := x.HexPubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
+		if len(x.PocValidation) == 0 {
+			return protoreflect.ValueOfList(&_PoCValidationsWithParticipantsV2_4_list{})
+		}
+		listValue := &_PoCValidationsWithParticipantsV2_4_list{list: &x.PocValidation}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -17606,19 +17263,25 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
-		x.Count = uint32(value.Uint())
-	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
-		x.RootHash = value.Bytes()
-	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
-		x.Found = value.Bool()
+	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
+		x.PubKey = value.Interface().(string)
+	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
+		x.HexPubKey = value.Interface().(string)
+	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
+		lv := value.List()
+		clv := lv.(*_PoCValidationsWithParticipantsV2_4_list)
+		x.PocValidation = *clv.list
+	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17632,48 +17295,61 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
-		panic(fmt.Errorf("field count of message inference.inference.QueryPoCV2StoreCommitResponse is not mutable"))
-	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
-		panic(fmt.Errorf("field root_hash of message inference.inference.QueryPoCV2StoreCommitResponse is not mutable"))
-	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryPoCV2StoreCommitResponse is not mutable"))
+	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
+		if x.PocValidation == nil {
+			x.PocValidation = []*PoCValidationV2{}
+		}
+		value := &_PoCValidationsWithParticipantsV2_4_list{list: &x.PocValidation}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
+	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
+		panic(fmt.Errorf("field pub_key of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
+	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
+		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
+	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.PoCValidationsWithParticipantsV2 is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
-		return protoreflect.ValueOfUint32(uint32(0))
-	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
-		return protoreflect.ValueOfBytes(nil)
-	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.PoCValidationsWithParticipantsV2.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCValidationsWithParticipantsV2.pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCValidationsWithParticipantsV2.hex_pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCValidationsWithParticipantsV2.poc_validation":
+		list := []*PoCValidationV2{}
+		return protoreflect.ValueOfList(&_PoCValidationsWithParticipantsV2_4_list{list: &list})
+	case "inference.inference.PoCValidationsWithParticipantsV2.model_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCValidationsWithParticipantsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCValidationsWithParticipantsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCV2StoreCommitResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCValidationsWithParticipantsV2", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -17681,7 +17357,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -17692,7 +17368,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -17704,7 +17380,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) IsValid() bool {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) IsValid() bool {
 	return x != nil
 }
 
@@ -17714,9 +17390,9 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_PoCValidationsWithParticipantsV2) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPoCV2StoreCommitResponse)
+		x := input.Message.Interface().(*PoCValidationsWithParticipantsV2)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17728,15 +17404,27 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if x.Count != 0 {
-			n += 1 + runtime.Sov(uint64(x.Count))
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.RootHash)
+		l = len(x.PubKey)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Found {
-			n += 2
+		l = len(x.HexPubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.PocValidation) > 0 {
+			for _, e := range x.PocValidation {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -17748,7 +17436,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCV2StoreCommitResponse)
+		x := input.Message.Interface().(*PoCValidationsWithParticipantsV2)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17767,27 +17455,49 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Found {
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
 			i--
-			if x.Found {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
+			dAtA[i] = 0x2a
+		}
+		if len(x.PocValidation) > 0 {
+			for iNdEx := len(x.PocValidation) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.PocValidation[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x22
 			}
+		}
+		if len(x.HexPubKey) > 0 {
+			i -= len(x.HexPubKey)
+			copy(dAtA[i:], x.HexPubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
 			i--
-			dAtA[i] = 0x18
+			dAtA[i] = 0x1a
 		}
-		if len(x.RootHash) > 0 {
-			i -= len(x.RootHash)
-			copy(dAtA[i:], x.RootHash)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RootHash)))
+		if len(x.PubKey) > 0 {
+			i -= len(x.PubKey)
+			copy(dAtA[i:], x.PubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
 			i--
 			dAtA[i] = 0x12
 		}
-		if x.Count != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -17800,7 +17510,7 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCV2StoreCommitResponse)
+		x := input.Message.Interface().(*PoCValidationsWithParticipantsV2)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17832,17 +17542,17 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipantsV2: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCValidationsWithParticipantsV2: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 				}
-				x.Count = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -17852,16 +17562,29 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Count |= uint32(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
 				}
-				var byteLen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -17871,31 +17594,29 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					byteLen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if byteLen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + byteLen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.RootHash = append(x.RootHash[:0], dAtA[iNdEx:postIndex]...)
-				if x.RootHash == nil {
-					x.RootHash = []byte{}
-				}
+				x.PubKey = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
 				}
-				var v int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -17905,12 +17626,90 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.Found = bool(v != 0)
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.HexPubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.PocValidation = append(x.PocValidation, &PoCValidationV2{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PocValidation[len(x.PocValidation)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -17947,29 +17746,29 @@ func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryMLNodeWeightDistributionRequest                              protoreflect.MessageDescriptor
-	fd_QueryMLNodeWeightDistributionRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
-	fd_QueryMLNodeWeightDistributionRequest_participant_address          protoreflect.FieldDescriptor
-	fd_QueryMLNodeWeightDistributionRequest_model_id                     protoreflect.FieldDescriptor
+	md_QueryPoCV2StoreCommitRequest                              protoreflect.MessageDescriptor
+	fd_QueryPoCV2StoreCommitRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
+	fd_QueryPoCV2StoreCommitRequest_participant_address          protoreflect.FieldDescriptor
+	fd_QueryPoCV2StoreCommitRequest_model_id                     protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryMLNodeWeightDistributionRequest = File_inference_inference_query_proto.Messages().ByName("QueryMLNodeWeightDistributionRequest")
-	fd_QueryMLNodeWeightDistributionRequest_poc_stage_start_block_height = md_QueryMLNodeWeightDistributionRequest.Fields().ByName("poc_stage_start_block_height")
-	fd_QueryMLNodeWeightDistributionRequest_participant_address = md_QueryMLNodeWeightDistributionRequest.Fields().ByName("participant_address")
-	fd_QueryMLNodeWeightDistributionRequest_model_id = md_QueryMLNodeWeightDistributionRequest.Fields().ByName("model_id")
+	md_QueryPoCV2StoreCommitRequest = File_inference_inference_query_proto.Messages().ByName("QueryPoCV2StoreCommitRequest")
+	fd_QueryPoCV2StoreCommitRequest_poc_stage_start_block_height = md_QueryPoCV2StoreCommitRequest.Fields().ByName("poc_stage_start_block_height")
+	fd_QueryPoCV2StoreCommitRequest_participant_address = md_QueryPoCV2StoreCommitRequest.Fields().ByName("participant_address")
+	fd_QueryPoCV2StoreCommitRequest_model_id = md_QueryPoCV2StoreCommitRequest.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryMLNodeWeightDistributionRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPoCV2StoreCommitRequest)(nil)
 
-type fastReflection_QueryMLNodeWeightDistributionRequest QueryMLNodeWeightDistributionRequest
+type fastReflection_QueryPoCV2StoreCommitRequest QueryPoCV2StoreCommitRequest
 
-func (x *QueryMLNodeWeightDistributionRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryMLNodeWeightDistributionRequest)(x)
+func (x *QueryPoCV2StoreCommitRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPoCV2StoreCommitRequest)(x)
 }
 
-func (x *QueryMLNodeWeightDistributionRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPoCV2StoreCommitRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[37]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -17981,43 +17780,43 @@ func (x *QueryMLNodeWeightDistributionRequest) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryMLNodeWeightDistributionRequest_messageType fastReflection_QueryMLNodeWeightDistributionRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryMLNodeWeightDistributionRequest_messageType{}
+var _fastReflection_QueryPoCV2StoreCommitRequest_messageType fastReflection_QueryPoCV2StoreCommitRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPoCV2StoreCommitRequest_messageType{}
 
-type fastReflection_QueryMLNodeWeightDistributionRequest_messageType struct{}
+type fastReflection_QueryPoCV2StoreCommitRequest_messageType struct{}
 
-func (x fastReflection_QueryMLNodeWeightDistributionRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryMLNodeWeightDistributionRequest)(nil)
+func (x fastReflection_QueryPoCV2StoreCommitRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPoCV2StoreCommitRequest)(nil)
 }
-func (x fastReflection_QueryMLNodeWeightDistributionRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryMLNodeWeightDistributionRequest)
+func (x fastReflection_QueryPoCV2StoreCommitRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCV2StoreCommitRequest)
 }
-func (x fastReflection_QueryMLNodeWeightDistributionRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryMLNodeWeightDistributionRequest
+func (x fastReflection_QueryPoCV2StoreCommitRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCV2StoreCommitRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryMLNodeWeightDistributionRequest
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCV2StoreCommitRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryMLNodeWeightDistributionRequest_messageType
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPoCV2StoreCommitRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryMLNodeWeightDistributionRequest)
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCV2StoreCommitRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryMLNodeWeightDistributionRequest)(x)
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPoCV2StoreCommitRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -18025,22 +17824,22 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.PocStageStartBlockHeight != int64(0) {
 		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_QueryMLNodeWeightDistributionRequest_poc_stage_start_block_height, value) {
+		if !f(fd_QueryPoCV2StoreCommitRequest_poc_stage_start_block_height, value) {
 			return
 		}
 	}
 	if x.ParticipantAddress != "" {
 		value := protoreflect.ValueOfString(x.ParticipantAddress)
-		if !f(fd_QueryMLNodeWeightDistributionRequest_participant_address, value) {
+		if !f(fd_QueryPoCV2StoreCommitRequest_participant_address, value) {
 			return
 		}
 	}
 	if x.ModelId != "" {
 		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_QueryMLNodeWeightDistributionRequest_model_id, value) {
+		if !f(fd_QueryPoCV2StoreCommitRequest_model_id, value) {
 			return
 		}
 	}
@@ -18057,19 +17856,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
 		return x.PocStageStartBlockHeight != int64(0)
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
 		return x.ParticipantAddress != ""
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
 		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18079,19 +17878,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = int64(0)
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
 		x.ParticipantAddress = ""
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
 		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18101,22 +17900,22 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
 		value := x.PocStageStartBlockHeight
 		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
 		value := x.ParticipantAddress
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
 		value := x.ModelId
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -18130,19 +17929,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = value.Int()
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
 		x.ParticipantAddress = value.Interface().(string)
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
 		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18156,48 +17955,48 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryMLNodeWeightDistributionRequest is not mutable"))
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
-		panic(fmt.Errorf("field participant_address of message inference.inference.QueryMLNodeWeightDistributionRequest is not mutable"))
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.QueryMLNodeWeightDistributionRequest is not mutable"))
+	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryPoCV2StoreCommitRequest is not mutable"))
+	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
+		panic(fmt.Errorf("field participant_address of message inference.inference.QueryPoCV2StoreCommitRequest is not mutable"))
+	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.QueryPoCV2StoreCommitRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.poc_stage_start_block_height":
 		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.participant_address":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+	case "inference.inference.QueryPoCV2StoreCommitRequest.model_id":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMLNodeWeightDistributionRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCV2StoreCommitRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -18205,7 +18004,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -18216,7 +18015,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -18228,7 +18027,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) IsValid() bool {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -18238,9 +18037,9 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryMLNodeWeightDistributionRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPoCV2StoreCommitRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryMLNodeWeightDistributionRequest)
+		x := input.Message.Interface().(*QueryPoCV2StoreCommitRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18273,7 +18072,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryMLNodeWeightDistributionRequest)
+		x := input.Message.Interface().(*QueryPoCV2StoreCommitRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18322,7 +18121,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryMLNodeWeightDistributionRequest)
+		x := input.Message.Interface().(*QueryPoCV2StoreCommitRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18354,10 +18153,10 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -18478,79 +18277,30 @@ func (x *fastReflection_QueryMLNodeWeightDistributionRequest) ProtoMethods() *pr
 	}
 }
 
-var _ protoreflect.List = (*_QueryMLNodeWeightDistributionResponse_1_list)(nil)
-
-type _QueryMLNodeWeightDistributionResponse_1_list struct {
-	list *[]*MLNodeWeight
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(MLNodeWeight)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) NewElement() protoreflect.Value {
-	v := new(MLNodeWeight)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryMLNodeWeightDistributionResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryMLNodeWeightDistributionResponse         protoreflect.MessageDescriptor
-	fd_QueryMLNodeWeightDistributionResponse_weights protoreflect.FieldDescriptor
-	fd_QueryMLNodeWeightDistributionResponse_found   protoreflect.FieldDescriptor
+	md_QueryPoCV2StoreCommitResponse           protoreflect.MessageDescriptor
+	fd_QueryPoCV2StoreCommitResponse_count     protoreflect.FieldDescriptor
+	fd_QueryPoCV2StoreCommitResponse_root_hash protoreflect.FieldDescriptor
+	fd_QueryPoCV2StoreCommitResponse_found     protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryMLNodeWeightDistributionResponse = File_inference_inference_query_proto.Messages().ByName("QueryMLNodeWeightDistributionResponse")
-	fd_QueryMLNodeWeightDistributionResponse_weights = md_QueryMLNodeWeightDistributionResponse.Fields().ByName("weights")
-	fd_QueryMLNodeWeightDistributionResponse_found = md_QueryMLNodeWeightDistributionResponse.Fields().ByName("found")
+	md_QueryPoCV2StoreCommitResponse = File_inference_inference_query_proto.Messages().ByName("QueryPoCV2StoreCommitResponse")
+	fd_QueryPoCV2StoreCommitResponse_count = md_QueryPoCV2StoreCommitResponse.Fields().ByName("count")
+	fd_QueryPoCV2StoreCommitResponse_root_hash = md_QueryPoCV2StoreCommitResponse.Fields().ByName("root_hash")
+	fd_QueryPoCV2StoreCommitResponse_found = md_QueryPoCV2StoreCommitResponse.Fields().ByName("found")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryMLNodeWeightDistributionResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPoCV2StoreCommitResponse)(nil)
 
-type fastReflection_QueryMLNodeWeightDistributionResponse QueryMLNodeWeightDistributionResponse
+type fastReflection_QueryPoCV2StoreCommitResponse QueryPoCV2StoreCommitResponse
 
-func (x *QueryMLNodeWeightDistributionResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryMLNodeWeightDistributionResponse)(x)
+func (x *QueryPoCV2StoreCommitResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPoCV2StoreCommitResponse)(x)
 }
 
-func (x *QueryMLNodeWeightDistributionResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryPoCV2StoreCommitResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[38]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -18562,43 +18312,43 @@ func (x *QueryMLNodeWeightDistributionResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryMLNodeWeightDistributionResponse_messageType fastReflection_QueryMLNodeWeightDistributionResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryMLNodeWeightDistributionResponse_messageType{}
+var _fastReflection_QueryPoCV2StoreCommitResponse_messageType fastReflection_QueryPoCV2StoreCommitResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPoCV2StoreCommitResponse_messageType{}
 
-type fastReflection_QueryMLNodeWeightDistributionResponse_messageType struct{}
+type fastReflection_QueryPoCV2StoreCommitResponse_messageType struct{}
 
-func (x fastReflection_QueryMLNodeWeightDistributionResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryMLNodeWeightDistributionResponse)(nil)
+func (x fastReflection_QueryPoCV2StoreCommitResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPoCV2StoreCommitResponse)(nil)
 }
-func (x fastReflection_QueryMLNodeWeightDistributionResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryMLNodeWeightDistributionResponse)
+func (x fastReflection_QueryPoCV2StoreCommitResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCV2StoreCommitResponse)
 }
-func (x fastReflection_QueryMLNodeWeightDistributionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryMLNodeWeightDistributionResponse
+func (x fastReflection_QueryPoCV2StoreCommitResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCV2StoreCommitResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryMLNodeWeightDistributionResponse
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCV2StoreCommitResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryMLNodeWeightDistributionResponse_messageType
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPoCV2StoreCommitResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryMLNodeWeightDistributionResponse)
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCV2StoreCommitResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryMLNodeWeightDistributionResponse)(x)
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPoCV2StoreCommitResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -18606,16 +18356,22 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Weights) != 0 {
-		value := protoreflect.ValueOfList(&_QueryMLNodeWeightDistributionResponse_1_list{list: &x.Weights})
-		if !f(fd_QueryMLNodeWeightDistributionResponse_weights, value) {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Count != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Count)
+		if !f(fd_QueryPoCV2StoreCommitResponse_count, value) {
+			return
+		}
+	}
+	if len(x.RootHash) != 0 {
+		value := protoreflect.ValueOfBytes(x.RootHash)
+		if !f(fd_QueryPoCV2StoreCommitResponse_root_hash, value) {
 			return
 		}
 	}
 	if x.Found != false {
 		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryMLNodeWeightDistributionResponse_found, value) {
+		if !f(fd_QueryPoCV2StoreCommitResponse_found, value) {
 			return
 		}
 	}
@@ -18632,17 +18388,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
-		return len(x.Weights) != 0
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
+		return x.Count != uint32(0)
+	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
+		return len(x.RootHash) != 0
+	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
 		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18652,17 +18410,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
-		x.Weights = nil
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
+		x.Count = uint32(0)
+	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
+		x.RootHash = nil
+	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
 		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18672,22 +18432,22 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
-		if len(x.Weights) == 0 {
-			return protoreflect.ValueOfList(&_QueryMLNodeWeightDistributionResponse_1_list{})
-		}
-		listValue := &_QueryMLNodeWeightDistributionResponse_1_list{list: &x.Weights}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
+		value := x.Count
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
+		value := x.RootHash
+		return protoreflect.ValueOfBytes(value)
+	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
 		value := x.Found
 		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -18701,19 +18461,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
-		lv := value.List()
-		clv := lv.(*_QueryMLNodeWeightDistributionResponse_1_list)
-		x.Weights = *clv.list
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
+		x.Count = uint32(value.Uint())
+	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
+		x.RootHash = value.Bytes()
+	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
 		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18727,49 +18487,48 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
-		if x.Weights == nil {
-			x.Weights = []*MLNodeWeight{}
-		}
-		value := &_QueryMLNodeWeightDistributionResponse_1_list{list: &x.Weights}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryMLNodeWeightDistributionResponse is not mutable"))
+	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
+		panic(fmt.Errorf("field count of message inference.inference.QueryPoCV2StoreCommitResponse is not mutable"))
+	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
+		panic(fmt.Errorf("field root_hash of message inference.inference.QueryPoCV2StoreCommitResponse is not mutable"))
+	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryPoCV2StoreCommitResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
-		list := []*MLNodeWeight{}
-		return protoreflect.ValueOfList(&_QueryMLNodeWeightDistributionResponse_1_list{list: &list})
-	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+	case "inference.inference.QueryPoCV2StoreCommitResponse.count":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.QueryPoCV2StoreCommitResponse.root_hash":
+		return protoreflect.ValueOfBytes(nil)
+	case "inference.inference.QueryPoCV2StoreCommitResponse.found":
 		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMLNodeWeightDistributionResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCV2StoreCommitResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -18777,7 +18536,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -18788,7 +18547,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -18800,7 +18559,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) IsValid() bool {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -18810,9 +18569,9 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPoCV2StoreCommitResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryMLNodeWeightDistributionResponse)
+		x := input.Message.Interface().(*QueryPoCV2StoreCommitResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18824,11 +18583,12 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
-		if len(x.Weights) > 0 {
-			for _, e := range x.Weights {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Count != 0 {
+			n += 1 + runtime.Sov(uint64(x.Count))
+		}
+		l = len(x.RootHash)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.Found {
 			n += 2
@@ -18843,7 +18603,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryMLNodeWeightDistributionResponse)
+		x := input.Message.Interface().(*QueryPoCV2StoreCommitResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18870,23 +18630,19 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 				dAtA[i] = 0
 			}
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x18
 		}
-		if len(x.Weights) > 0 {
-			for iNdEx := len(x.Weights) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Weights[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if len(x.RootHash) > 0 {
+			i -= len(x.RootHash)
+			copy(dAtA[i:], x.RootHash)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RootHash)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Count != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -18899,7 +18655,7 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryMLNodeWeightDistributionResponse)
+		x := input.Message.Interface().(*QueryPoCV2StoreCommitResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18931,17 +18687,36 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+				}
+				x.Count = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Count |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
 				}
-				var msglen int
+				var byteLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -18951,27 +18726,27 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					byteLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				if byteLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + byteLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Weights = append(x.Weights, &MLNodeWeight{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Weights[len(x.Weights)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.RootHash = append(x.RootHash[:0], dAtA[iNdEx:postIndex]...)
+				if x.RootHash == nil {
+					x.RootHash = []byte{}
 				}
 				iNdEx = postIndex
-			case 2:
+			case 3:
 				if wireType != 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 				}
@@ -19027,25 +18802,29 @@ func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *p
 }
 
 var (
-	md_QueryAllPoCV2StoreCommitsForStageRequest                              protoreflect.MessageDescriptor
-	fd_QueryAllPoCV2StoreCommitsForStageRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
+	md_QueryMLNodeWeightDistributionRequest                              protoreflect.MessageDescriptor
+	fd_QueryMLNodeWeightDistributionRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
+	fd_QueryMLNodeWeightDistributionRequest_participant_address          protoreflect.FieldDescriptor
+	fd_QueryMLNodeWeightDistributionRequest_model_id                     protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllPoCV2StoreCommitsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllPoCV2StoreCommitsForStageRequest")
-	fd_QueryAllPoCV2StoreCommitsForStageRequest_poc_stage_start_block_height = md_QueryAllPoCV2StoreCommitsForStageRequest.Fields().ByName("poc_stage_start_block_height")
+	md_QueryMLNodeWeightDistributionRequest = File_inference_inference_query_proto.Messages().ByName("QueryMLNodeWeightDistributionRequest")
+	fd_QueryMLNodeWeightDistributionRequest_poc_stage_start_block_height = md_QueryMLNodeWeightDistributionRequest.Fields().ByName("poc_stage_start_block_height")
+	fd_QueryMLNodeWeightDistributionRequest_participant_address = md_QueryMLNodeWeightDistributionRequest.Fields().ByName("participant_address")
+	fd_QueryMLNodeWeightDistributionRequest_model_id = md_QueryMLNodeWeightDistributionRequest.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryMLNodeWeightDistributionRequest)(nil)
 
-type fastReflection_QueryAllPoCV2StoreCommitsForStageRequest QueryAllPoCV2StoreCommitsForStageRequest
+type fastReflection_QueryMLNodeWeightDistributionRequest QueryMLNodeWeightDistributionRequest
 
-func (x *QueryAllPoCV2StoreCommitsForStageRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)(x)
+func (x *QueryMLNodeWeightDistributionRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMLNodeWeightDistributionRequest)(x)
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryMLNodeWeightDistributionRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[39]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -19057,43 +18836,43 @@ func (x *QueryAllPoCV2StoreCommitsForStageRequest) slowProtoReflect() protorefle
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType{}
+var _fastReflection_QueryMLNodeWeightDistributionRequest_messageType fastReflection_QueryMLNodeWeightDistributionRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMLNodeWeightDistributionRequest_messageType{}
 
-type fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType struct{}
+type fastReflection_QueryMLNodeWeightDistributionRequest_messageType struct{}
 
-func (x fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)(nil)
+func (x fastReflection_QueryMLNodeWeightDistributionRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMLNodeWeightDistributionRequest)(nil)
 }
-func (x fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)
+func (x fastReflection_QueryMLNodeWeightDistributionRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMLNodeWeightDistributionRequest)
 }
-func (x fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPoCV2StoreCommitsForStageRequest
+func (x fastReflection_QueryMLNodeWeightDistributionRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMLNodeWeightDistributionRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPoCV2StoreCommitsForStageRequest
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMLNodeWeightDistributionRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMLNodeWeightDistributionRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMLNodeWeightDistributionRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllPoCV2StoreCommitsForStageRequest)(x)
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMLNodeWeightDistributionRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -19101,10 +18880,22 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Interface() pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.PocStageStartBlockHeight != int64(0) {
 		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_QueryAllPoCV2StoreCommitsForStageRequest_poc_stage_start_block_height, value) {
+		if !f(fd_QueryMLNodeWeightDistributionRequest_poc_stage_start_block_height, value) {
+			return
+		}
+	}
+	if x.ParticipantAddress != "" {
+		value := protoreflect.ValueOfString(x.ParticipantAddress)
+		if !f(fd_QueryMLNodeWeightDistributionRequest_participant_address, value) {
+			return
+		}
+	}
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_QueryMLNodeWeightDistributionRequest_model_id, value) {
 			return
 		}
 	}
@@ -19121,15 +18912,19 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Range(f func(p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
 		return x.PocStageStartBlockHeight != int64(0)
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+		return x.ParticipantAddress != ""
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19139,15 +18934,19 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Has(fd protore
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = int64(0)
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+		x.ParticipantAddress = ""
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19157,16 +18956,22 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Clear(fd proto
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
 		value := x.PocStageStartBlockHeight
 		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+		value := x.ParticipantAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -19180,15 +18985,19 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = value.Int()
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+		x.ParticipantAddress = value.Interface().(string)
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19202,40 +19011,48 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Set(fd protore
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest is not mutable"))
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryMLNodeWeightDistributionRequest is not mutable"))
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+		panic(fmt.Errorf("field participant_address of message inference.inference.QueryMLNodeWeightDistributionRequest is not mutable"))
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.QueryMLNodeWeightDistributionRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.poc_stage_start_block_height":
 		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.participant_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryMLNodeWeightDistributionRequest.model_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPoCV2StoreCommitsForStageRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMLNodeWeightDistributionRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -19243,7 +19060,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) WhichOneof(d p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -19254,7 +19071,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) GetUnknown() p
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -19266,7 +19083,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) SetUnknown(fie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) IsValid() bool {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -19276,9 +19093,9 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryMLNodeWeightDistributionRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageRequest)
+		x := input.Message.Interface().(*QueryMLNodeWeightDistributionRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19293,6 +19110,14 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 		if x.PocStageStartBlockHeight != 0 {
 			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
+		l = len(x.ParticipantAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -19303,7 +19128,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageRequest)
+		x := input.Message.Interface().(*QueryMLNodeWeightDistributionRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19322,6 +19147,20 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ParticipantAddress) > 0 {
+			i -= len(x.ParticipantAddress)
+			copy(dAtA[i:], x.ParticipantAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
 		if x.PocStageStartBlockHeight != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
 			i--
@@ -19338,7 +19177,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageRequest)
+		x := input.Message.Interface().(*QueryMLNodeWeightDistributionRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19370,10 +19209,10 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -19395,6 +19234,70 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 						break
 					}
 				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ParticipantAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -19430,77 +19333,79 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods()
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllPoCV2StoreCommitsForStageResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryMLNodeWeightDistributionResponse_1_list)(nil)
 
-type _QueryAllPoCV2StoreCommitsForStageResponse_1_list struct {
-	list *[]*PoCV2StoreCommitWithAddress
+type _QueryMLNodeWeightDistributionResponse_1_list struct {
+	list *[]*MLNodeWeight
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Len() int {
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCV2StoreCommitWithAddress)
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCV2StoreCommitWithAddress)
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(PoCV2StoreCommitWithAddress)
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(MLNodeWeight)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Truncate(n int) {
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) NewElement() protoreflect.Value {
-	v := new(PoCV2StoreCommitWithAddress)
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) NewElement() protoreflect.Value {
+	v := new(MLNodeWeight)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) IsValid() bool {
+func (x *_QueryMLNodeWeightDistributionResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryAllPoCV2StoreCommitsForStageResponse         protoreflect.MessageDescriptor
-	fd_QueryAllPoCV2StoreCommitsForStageResponse_commits protoreflect.FieldDescriptor
+	md_QueryMLNodeWeightDistributionResponse         protoreflect.MessageDescriptor
+	fd_QueryMLNodeWeightDistributionResponse_weights protoreflect.FieldDescriptor
+	fd_QueryMLNodeWeightDistributionResponse_found   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllPoCV2StoreCommitsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllPoCV2StoreCommitsForStageResponse")
-	fd_QueryAllPoCV2StoreCommitsForStageResponse_commits = md_QueryAllPoCV2StoreCommitsForStageResponse.Fields().ByName("commits")
+	md_QueryMLNodeWeightDistributionResponse = File_inference_inference_query_proto.Messages().ByName("QueryMLNodeWeightDistributionResponse")
+	fd_QueryMLNodeWeightDistributionResponse_weights = md_QueryMLNodeWeightDistributionResponse.Fields().ByName("weights")
+	fd_QueryMLNodeWeightDistributionResponse_found = md_QueryMLNodeWeightDistributionResponse.Fields().ByName("found")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryMLNodeWeightDistributionResponse)(nil)
 
-type fastReflection_QueryAllPoCV2StoreCommitsForStageResponse QueryAllPoCV2StoreCommitsForStageResponse
+type fastReflection_QueryMLNodeWeightDistributionResponse QueryMLNodeWeightDistributionResponse
 
-func (x *QueryAllPoCV2StoreCommitsForStageResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)(x)
+func (x *QueryMLNodeWeightDistributionResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMLNodeWeightDistributionResponse)(x)
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryMLNodeWeightDistributionResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[40]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -19512,43 +19417,43 @@ func (x *QueryAllPoCV2StoreCommitsForStageResponse) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType{}
+var _fastReflection_QueryMLNodeWeightDistributionResponse_messageType fastReflection_QueryMLNodeWeightDistributionResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMLNodeWeightDistributionResponse_messageType{}
 
-type fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType struct{}
+type fastReflection_QueryMLNodeWeightDistributionResponse_messageType struct{}
 
-func (x fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)(nil)
+func (x fastReflection_QueryMLNodeWeightDistributionResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMLNodeWeightDistributionResponse)(nil)
 }
-func (x fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)
+func (x fastReflection_QueryMLNodeWeightDistributionResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMLNodeWeightDistributionResponse)
 }
-func (x fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPoCV2StoreCommitsForStageResponse
+func (x fastReflection_QueryMLNodeWeightDistributionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMLNodeWeightDistributionResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPoCV2StoreCommitsForStageResponse
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMLNodeWeightDistributionResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMLNodeWeightDistributionResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMLNodeWeightDistributionResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllPoCV2StoreCommitsForStageResponse)(x)
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMLNodeWeightDistributionResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -19556,10 +19461,16 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Commits) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &x.Commits})
-		if !f(fd_QueryAllPoCV2StoreCommitsForStageResponse_commits, value) {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Weights) != 0 {
+		value := protoreflect.ValueOfList(&_QueryMLNodeWeightDistributionResponse_1_list{list: &x.Weights})
+		if !f(fd_QueryMLNodeWeightDistributionResponse_weights, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryMLNodeWeightDistributionResponse_found, value) {
 			return
 		}
 	}
@@ -19576,15 +19487,17 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
-		return len(x.Commits) != 0
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
+		return len(x.Weights) != 0
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19594,15 +19507,17 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
-		x.Commits = nil
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
+		x.Weights = nil
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19612,19 +19527,22 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
-		if len(x.Commits) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllPoCV2StoreCommitsForStageResponse_1_list{})
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
+		if len(x.Weights) == 0 {
+			return protoreflect.ValueOfList(&_QueryMLNodeWeightDistributionResponse_1_list{})
 		}
-		listValue := &_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &x.Commits}
+		listValue := &_QueryMLNodeWeightDistributionResponse_1_list{list: &x.Weights}
 		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -19638,17 +19556,19 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
 		lv := value.List()
-		clv := lv.(*_QueryAllPoCV2StoreCommitsForStageResponse_1_list)
-		x.Commits = *clv.list
+		clv := lv.(*_QueryMLNodeWeightDistributionResponse_1_list)
+		x.Weights = *clv.list
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19662,45 +19582,49 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
-		if x.Commits == nil {
-			x.Commits = []*PoCV2StoreCommitWithAddress{}
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
+		if x.Weights == nil {
+			x.Weights = []*MLNodeWeight{}
 		}
-		value := &_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &x.Commits}
+		value := &_QueryMLNodeWeightDistributionResponse_1_list{list: &x.Weights}
 		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryMLNodeWeightDistributionResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
-		list := []*PoCV2StoreCommitWithAddress{}
-		return protoreflect.ValueOfList(&_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &list})
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.weights":
+		list := []*MLNodeWeight{}
+		return protoreflect.ValueOfList(&_QueryMLNodeWeightDistributionResponse_1_list{list: &list})
+	case "inference.inference.QueryMLNodeWeightDistributionResponse.found":
+		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPoCV2StoreCommitsForStageResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMLNodeWeightDistributionResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -19708,7 +19632,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -19719,7 +19643,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -19731,7 +19655,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) IsValid() bool {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -19741,9 +19665,9 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryMLNodeWeightDistributionResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageResponse)
+		x := input.Message.Interface().(*QueryMLNodeWeightDistributionResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19755,12 +19679,15 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		if len(x.Commits) > 0 {
-			for _, e := range x.Commits {
+		if len(x.Weights) > 0 {
+			for _, e := range x.Weights {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
 		}
+		if x.Found {
+			n += 2
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -19771,7 +19698,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageResponse)
+		x := input.Message.Interface().(*QueryMLNodeWeightDistributionResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19790,9 +19717,19 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Commits) > 0 {
-			for iNdEx := len(x.Commits) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Commits[iNdEx])
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Weights) > 0 {
+			for iNdEx := len(x.Weights) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Weights[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19817,7 +19754,7 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageResponse)
+		x := input.Message.Interface().(*QueryMLNodeWeightDistributionResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19849,15 +19786,15 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Commits", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -19884,11 +19821,31 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Commits = append(x.Commits, &PoCV2StoreCommitWithAddress{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Commits[len(x.Commits)-1]); err != nil {
+				x.Weights = append(x.Weights, &MLNodeWeight{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Weights[len(x.Weights)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Found = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -19925,33 +19882,25 @@ func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods(
 }
 
 var (
-	md_PoCV2StoreCommitWithAddress                     protoreflect.MessageDescriptor
-	fd_PoCV2StoreCommitWithAddress_participant_address protoreflect.FieldDescriptor
-	fd_PoCV2StoreCommitWithAddress_count               protoreflect.FieldDescriptor
-	fd_PoCV2StoreCommitWithAddress_root_hash           protoreflect.FieldDescriptor
-	fd_PoCV2StoreCommitWithAddress_hex_pub_key         protoreflect.FieldDescriptor
-	fd_PoCV2StoreCommitWithAddress_model_id            protoreflect.FieldDescriptor
+	md_QueryAllPoCV2StoreCommitsForStageRequest                              protoreflect.MessageDescriptor
+	fd_QueryAllPoCV2StoreCommitsForStageRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_PoCV2StoreCommitWithAddress = File_inference_inference_query_proto.Messages().ByName("PoCV2StoreCommitWithAddress")
-	fd_PoCV2StoreCommitWithAddress_participant_address = md_PoCV2StoreCommitWithAddress.Fields().ByName("participant_address")
-	fd_PoCV2StoreCommitWithAddress_count = md_PoCV2StoreCommitWithAddress.Fields().ByName("count")
-	fd_PoCV2StoreCommitWithAddress_root_hash = md_PoCV2StoreCommitWithAddress.Fields().ByName("root_hash")
-	fd_PoCV2StoreCommitWithAddress_hex_pub_key = md_PoCV2StoreCommitWithAddress.Fields().ByName("hex_pub_key")
-	fd_PoCV2StoreCommitWithAddress_model_id = md_PoCV2StoreCommitWithAddress.Fields().ByName("model_id")
+	md_QueryAllPoCV2StoreCommitsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllPoCV2StoreCommitsForStageRequest")
+	fd_QueryAllPoCV2StoreCommitsForStageRequest_poc_stage_start_block_height = md_QueryAllPoCV2StoreCommitsForStageRequest.Fields().ByName("poc_stage_start_block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_PoCV2StoreCommitWithAddress)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)(nil)
 
-type fastReflection_PoCV2StoreCommitWithAddress PoCV2StoreCommitWithAddress
+type fastReflection_QueryAllPoCV2StoreCommitsForStageRequest QueryAllPoCV2StoreCommitsForStageRequest
 
-func (x *PoCV2StoreCommitWithAddress) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_PoCV2StoreCommitWithAddress)(x)
+func (x *QueryAllPoCV2StoreCommitsForStageRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)(x)
 }
 
-func (x *PoCV2StoreCommitWithAddress) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllPoCV2StoreCommitsForStageRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[41]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -19963,43 +19912,43 @@ func (x *PoCV2StoreCommitWithAddress) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_PoCV2StoreCommitWithAddress_messageType fastReflection_PoCV2StoreCommitWithAddress_messageType
-var _ protoreflect.MessageType = fastReflection_PoCV2StoreCommitWithAddress_messageType{}
+var _fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType{}
 
-type fastReflection_PoCV2StoreCommitWithAddress_messageType struct{}
+type fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType struct{}
 
-func (x fastReflection_PoCV2StoreCommitWithAddress_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_PoCV2StoreCommitWithAddress)(nil)
+func (x fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)(nil)
 }
-func (x fastReflection_PoCV2StoreCommitWithAddress_messageType) New() protoreflect.Message {
-	return new(fastReflection_PoCV2StoreCommitWithAddress)
+func (x fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)
 }
-func (x fastReflection_PoCV2StoreCommitWithAddress_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCV2StoreCommitWithAddress
+func (x fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPoCV2StoreCommitsForStageRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Descriptor() protoreflect.MessageDescriptor {
-	return md_PoCV2StoreCommitWithAddress
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPoCV2StoreCommitsForStageRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Type() protoreflect.MessageType {
-	return _fastReflection_PoCV2StoreCommitWithAddress_messageType
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllPoCV2StoreCommitsForStageRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) New() protoreflect.Message {
-	return new(fastReflection_PoCV2StoreCommitWithAddress)
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Interface() protoreflect.ProtoMessage {
-	return (*PoCV2StoreCommitWithAddress)(x)
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllPoCV2StoreCommitsForStageRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -20007,34 +19956,10 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) Interface() protoreflect.Pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ParticipantAddress != "" {
-		value := protoreflect.ValueOfString(x.ParticipantAddress)
-		if !f(fd_PoCV2StoreCommitWithAddress_participant_address, value) {
-			return
-		}
-	}
-	if x.Count != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Count)
-		if !f(fd_PoCV2StoreCommitWithAddress_count, value) {
-			return
-		}
-	}
-	if len(x.RootHash) != 0 {
-		value := protoreflect.ValueOfBytes(x.RootHash)
-		if !f(fd_PoCV2StoreCommitWithAddress_root_hash, value) {
-			return
-		}
-	}
-	if x.HexPubKey != "" {
-		value := protoreflect.ValueOfString(x.HexPubKey)
-		if !f(fd_PoCV2StoreCommitWithAddress_hex_pub_key, value) {
-			return
-		}
-	}
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_PoCV2StoreCommitWithAddress_model_id, value) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.PocStageStartBlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
+		if !f(fd_QueryAllPoCV2StoreCommitsForStageRequest_poc_stage_start_block_height, value) {
 			return
 		}
 	}
@@ -20051,23 +19976,15 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) Range(f func(protoreflect.F
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
-		return x.ParticipantAddress != ""
-	case "inference.inference.PoCV2StoreCommitWithAddress.count":
-		return x.Count != uint32(0)
-	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
-		return len(x.RootHash) != 0
-	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
-		return x.HexPubKey != ""
-	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
-		return x.ModelId != ""
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+		return x.PocStageStartBlockHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20077,23 +19994,15 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) Has(fd protoreflect.FieldDe
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
-		x.ParticipantAddress = ""
-	case "inference.inference.PoCV2StoreCommitWithAddress.count":
-		x.Count = uint32(0)
-	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
-		x.RootHash = nil
-	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
-		x.HexPubKey = ""
-	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
-		x.ModelId = ""
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+		x.PocStageStartBlockHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20103,28 +20012,16 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) Clear(fd protoreflect.Field
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
-		value := x.ParticipantAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCV2StoreCommitWithAddress.count":
-		value := x.Count
-		return protoreflect.ValueOfUint32(value)
-	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
-		value := x.RootHash
-		return protoreflect.ValueOfBytes(value)
-	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
-		value := x.HexPubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+		value := x.PocStageStartBlockHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -20138,23 +20035,15 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) Get(descriptor protoreflect
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
-		x.ParticipantAddress = value.Interface().(string)
-	case "inference.inference.PoCV2StoreCommitWithAddress.count":
-		x.Count = uint32(value.Uint())
-	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
-		x.RootHash = value.Bytes()
-	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
-		x.HexPubKey = value.Interface().(string)
-	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
-		x.ModelId = value.Interface().(string)
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+		x.PocStageStartBlockHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20168,56 +20057,40 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) Set(fd protoreflect.FieldDe
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
-		panic(fmt.Errorf("field participant_address of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
-	case "inference.inference.PoCV2StoreCommitWithAddress.count":
-		panic(fmt.Errorf("field count of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
-	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
-		panic(fmt.Errorf("field root_hash of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
-	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
-		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
-	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCV2StoreCommitWithAddress.count":
-		return protoreflect.ValueOfUint32(uint32(0))
-	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
-		return protoreflect.ValueOfBytes(nil)
-	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest.poc_stage_start_block_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCV2StoreCommitWithAddress", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPoCV2StoreCommitsForStageRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -20225,7 +20098,7 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) WhichOneof(d protoreflect.O
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -20236,7 +20109,7 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) GetUnknown() protoreflect.R
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -20248,7 +20121,7 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) SetUnknown(fields protorefl
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) IsValid() bool {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -20258,9 +20131,9 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*PoCV2StoreCommitWithAddress)
+		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20272,24 +20145,8 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 		var n int
 		var l int
 		_ = l
-		l = len(x.ParticipantAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.Count != 0 {
-			n += 1 + runtime.Sov(uint64(x.Count))
-		}
-		l = len(x.RootHash)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.HexPubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.PocStageStartBlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -20301,7 +20158,7 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*PoCV2StoreCommitWithAddress)
+		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20320,43 +20177,15 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.HexPubKey) > 0 {
-			i -= len(x.HexPubKey)
-			copy(dAtA[i:], x.HexPubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
-			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.RootHash) > 0 {
-			i -= len(x.RootHash)
-			copy(dAtA[i:], x.RootHash)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RootHash)))
+		if x.PocStageStartBlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
 			i--
-			dAtA[i] = 0x1a
+			dAtA[i] = 0x8
 		}
-		if x.Count != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
-			i--
-			dAtA[i] = 0x10
-		}
-		if len(x.ParticipantAddress) > 0 {
-			i -= len(x.ParticipantAddress)
-			copy(dAtA[i:], x.ParticipantAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantAddress)))
-			i--
-			dAtA[i] = 0xa
-		}
-		if input.Buf != nil {
-			input.Buf = append(input.Buf, dAtA...)
-		} else {
-			input.Buf = dAtA
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
 		}
 		return protoiface.MarshalOutput{
 			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20364,7 +20193,7 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*PoCV2StoreCommitWithAddress)
+		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20396,134 +20225,17 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCV2StoreCommitWithAddress: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCV2StoreCommitWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ParticipantAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
-				}
-				x.Count = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Count |= uint32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
-				}
-				var byteLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					byteLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if byteLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + byteLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RootHash = append(x.RootHash[:0], dAtA[iNdEx:postIndex]...)
-				if x.RootHash == nil {
-					x.RootHash = []byte{}
-				}
-				iNdEx = postIndex
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HexPubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 				}
-				var stringLen uint64
+				x.PocStageStartBlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -20533,24 +20245,11 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.PocStageStartBlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -20586,26 +20285,77 @@ func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.
 	}
 }
 
+var _ protoreflect.List = (*_QueryAllPoCV2StoreCommitsForStageResponse_1_list)(nil)
+
+type _QueryAllPoCV2StoreCommitsForStageResponse_1_list struct {
+	list *[]*PoCV2StoreCommitWithAddress
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCV2StoreCommitWithAddress)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*PoCV2StoreCommitWithAddress)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(PoCV2StoreCommitWithAddress)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) NewElement() protoreflect.Value {
+	v := new(PoCV2StoreCommitWithAddress)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllPoCV2StoreCommitsForStageResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryAllMLNodeWeightDistributionsForStageRequest                              protoreflect.MessageDescriptor
-	fd_QueryAllMLNodeWeightDistributionsForStageRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
+	md_QueryAllPoCV2StoreCommitsForStageResponse         protoreflect.MessageDescriptor
+	fd_QueryAllPoCV2StoreCommitsForStageResponse_commits protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllMLNodeWeightDistributionsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllMLNodeWeightDistributionsForStageRequest")
-	fd_QueryAllMLNodeWeightDistributionsForStageRequest_poc_stage_start_block_height = md_QueryAllMLNodeWeightDistributionsForStageRequest.Fields().ByName("poc_stage_start_block_height")
+	md_QueryAllPoCV2StoreCommitsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllPoCV2StoreCommitsForStageResponse")
+	fd_QueryAllPoCV2StoreCommitsForStageResponse_commits = md_QueryAllPoCV2StoreCommitsForStageResponse.Fields().ByName("commits")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)(nil)
 
-type fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest QueryAllMLNodeWeightDistributionsForStageRequest
+type fastReflection_QueryAllPoCV2StoreCommitsForStageResponse QueryAllPoCV2StoreCommitsForStageResponse
 
-func (x *QueryAllMLNodeWeightDistributionsForStageRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)(x)
+func (x *QueryAllPoCV2StoreCommitsForStageResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)(x)
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllPoCV2StoreCommitsForStageResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[42]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -20617,43 +20367,43 @@ func (x *QueryAllMLNodeWeightDistributionsForStageRequest) slowProtoReflect() pr
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType{}
+var _fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType{}
 
-type fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType struct{}
+type fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType struct{}
 
-func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)(nil)
+func (x fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)(nil)
 }
-func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)
+func (x fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)
 }
-func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllMLNodeWeightDistributionsForStageRequest
+func (x fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPoCV2StoreCommitsForStageResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllMLNodeWeightDistributionsForStageRequest
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPoCV2StoreCommitsForStageResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllPoCV2StoreCommitsForStageResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPoCV2StoreCommitsForStageResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllMLNodeWeightDistributionsForStageRequest)(x)
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllPoCV2StoreCommitsForStageResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -20661,10 +20411,10 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Interf
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.PocStageStartBlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_QueryAllMLNodeWeightDistributionsForStageRequest_poc_stage_start_block_height, value) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Commits) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &x.Commits})
+		if !f(fd_QueryAllPoCV2StoreCommitsForStageResponse_commits, value) {
 			return
 		}
 	}
@@ -20681,15 +20431,15 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Range(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
-		return x.PocStageStartBlockHeight != int64(0)
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+		return len(x.Commits) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20699,15 +20449,15 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Has(fd
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
-		x.PocStageStartBlockHeight = int64(0)
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+		x.Commits = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20717,16 +20467,19 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Clear(
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
-		value := x.PocStageStartBlockHeight
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+		if len(x.Commits) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllPoCV2StoreCommitsForStageResponse_1_list{})
+		}
+		listValue := &_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &x.Commits}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -20740,15 +20493,17 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Get(de
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
-		x.PocStageStartBlockHeight = value.Int()
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+		lv := value.List()
+		clv := lv.(*_QueryAllPoCV2StoreCommitsForStageResponse_1_list)
+		x.Commits = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20762,40 +20517,45 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Set(fd
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest is not mutable"))
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+		if x.Commits == nil {
+			x.Commits = []*PoCV2StoreCommitWithAddress{}
+		}
+		value := &_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &x.Commits}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits":
+		list := []*PoCV2StoreCommitWithAddress{}
+		return protoreflect.ValueOfList(&_QueryAllPoCV2StoreCommitsForStageResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPoCV2StoreCommitsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPoCV2StoreCommitsForStageResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -20803,7 +20563,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) WhichO
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -20814,7 +20574,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) GetUnk
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -20826,7 +20586,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) SetUnk
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) IsValid() bool {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -20836,9 +20596,9 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) IsVali
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllPoCV2StoreCommitsForStageResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageRequest)
+		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20850,8 +20610,11 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 		var n int
 		var l int
 		_ = l
-		if x.PocStageStartBlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
+		if len(x.Commits) > 0 {
+			for _, e := range x.Commits {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -20863,7 +20626,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageRequest)
+		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20882,10 +20645,21 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.PocStageStartBlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
-			i--
-			dAtA[i] = 0x8
+		if len(x.Commits) > 0 {
+			for iNdEx := len(x.Commits) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Commits[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -20898,7 +20672,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageRequest)
+		x := input.Message.Interface().(*QueryAllPoCV2StoreCommitsForStageResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20930,17 +20704,17 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Commits", wireType)
 				}
-				x.PocStageStartBlockHeight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -20950,11 +20724,26 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.PocStageStartBlockHeight |= int64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Commits = append(x.Commits, &PoCV2StoreCommitWithAddress{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Commits[len(x.Commits)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -20990,77 +20779,34 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoM
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllMLNodeWeightDistributionsForStageResponse_1_list)(nil)
-
-type _QueryAllMLNodeWeightDistributionsForStageResponse_1_list struct {
-	list *[]*MLNodeWeightDistributionWithAddress
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeightDistributionWithAddress)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeightDistributionWithAddress)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(MLNodeWeightDistributionWithAddress)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) NewElement() protoreflect.Value {
-	v := new(MLNodeWeightDistributionWithAddress)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryAllMLNodeWeightDistributionsForStageResponse               protoreflect.MessageDescriptor
-	fd_QueryAllMLNodeWeightDistributionsForStageResponse_distributions protoreflect.FieldDescriptor
+	md_PoCV2StoreCommitWithAddress                     protoreflect.MessageDescriptor
+	fd_PoCV2StoreCommitWithAddress_participant_address protoreflect.FieldDescriptor
+	fd_PoCV2StoreCommitWithAddress_count               protoreflect.FieldDescriptor
+	fd_PoCV2StoreCommitWithAddress_root_hash           protoreflect.FieldDescriptor
+	fd_PoCV2StoreCommitWithAddress_hex_pub_key         protoreflect.FieldDescriptor
+	fd_PoCV2StoreCommitWithAddress_model_id            protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllMLNodeWeightDistributionsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllMLNodeWeightDistributionsForStageResponse")
-	fd_QueryAllMLNodeWeightDistributionsForStageResponse_distributions = md_QueryAllMLNodeWeightDistributionsForStageResponse.Fields().ByName("distributions")
+	md_PoCV2StoreCommitWithAddress = File_inference_inference_query_proto.Messages().ByName("PoCV2StoreCommitWithAddress")
+	fd_PoCV2StoreCommitWithAddress_participant_address = md_PoCV2StoreCommitWithAddress.Fields().ByName("participant_address")
+	fd_PoCV2StoreCommitWithAddress_count = md_PoCV2StoreCommitWithAddress.Fields().ByName("count")
+	fd_PoCV2StoreCommitWithAddress_root_hash = md_PoCV2StoreCommitWithAddress.Fields().ByName("root_hash")
+	fd_PoCV2StoreCommitWithAddress_hex_pub_key = md_PoCV2StoreCommitWithAddress.Fields().ByName("hex_pub_key")
+	fd_PoCV2StoreCommitWithAddress_model_id = md_PoCV2StoreCommitWithAddress.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_PoCV2StoreCommitWithAddress)(nil)
 
-type fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse QueryAllMLNodeWeightDistributionsForStageResponse
+type fastReflection_PoCV2StoreCommitWithAddress PoCV2StoreCommitWithAddress
 
-func (x *QueryAllMLNodeWeightDistributionsForStageResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)(x)
+func (x *PoCV2StoreCommitWithAddress) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_PoCV2StoreCommitWithAddress)(x)
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageResponse) slowProtoReflect() protoreflect.Message {
+func (x *PoCV2StoreCommitWithAddress) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[43]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -21072,43 +20818,43 @@ func (x *QueryAllMLNodeWeightDistributionsForStageResponse) slowProtoReflect() p
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType{}
+var _fastReflection_PoCV2StoreCommitWithAddress_messageType fastReflection_PoCV2StoreCommitWithAddress_messageType
+var _ protoreflect.MessageType = fastReflection_PoCV2StoreCommitWithAddress_messageType{}
 
-type fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType struct{}
+type fastReflection_PoCV2StoreCommitWithAddress_messageType struct{}
 
-func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)(nil)
+func (x fastReflection_PoCV2StoreCommitWithAddress_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_PoCV2StoreCommitWithAddress)(nil)
 }
-func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)
+func (x fastReflection_PoCV2StoreCommitWithAddress_messageType) New() protoreflect.Message {
+	return new(fastReflection_PoCV2StoreCommitWithAddress)
 }
-func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllMLNodeWeightDistributionsForStageResponse
+func (x fastReflection_PoCV2StoreCommitWithAddress_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCV2StoreCommitWithAddress
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllMLNodeWeightDistributionsForStageResponse
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Descriptor() protoreflect.MessageDescriptor {
+	return md_PoCV2StoreCommitWithAddress
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Type() protoreflect.MessageType {
+	return _fastReflection_PoCV2StoreCommitWithAddress_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)
+func (x *fastReflection_PoCV2StoreCommitWithAddress) New() protoreflect.Message {
+	return new(fastReflection_PoCV2StoreCommitWithAddress)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllMLNodeWeightDistributionsForStageResponse)(x)
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Interface() protoreflect.ProtoMessage {
+	return (*PoCV2StoreCommitWithAddress)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -21116,10 +20862,34 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Inter
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Distributions) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &x.Distributions})
-		if !f(fd_QueryAllMLNodeWeightDistributionsForStageResponse_distributions, value) {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ParticipantAddress != "" {
+		value := protoreflect.ValueOfString(x.ParticipantAddress)
+		if !f(fd_PoCV2StoreCommitWithAddress_participant_address, value) {
+			return
+		}
+	}
+	if x.Count != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Count)
+		if !f(fd_PoCV2StoreCommitWithAddress_count, value) {
+			return
+		}
+	}
+	if len(x.RootHash) != 0 {
+		value := protoreflect.ValueOfBytes(x.RootHash)
+		if !f(fd_PoCV2StoreCommitWithAddress_root_hash, value) {
+			return
+		}
+	}
+	if x.HexPubKey != "" {
+		value := protoreflect.ValueOfString(x.HexPubKey)
+		if !f(fd_PoCV2StoreCommitWithAddress_hex_pub_key, value) {
+			return
+		}
+	}
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_PoCV2StoreCommitWithAddress_model_id, value) {
 			return
 		}
 	}
@@ -21136,15 +20906,23 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Range
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
-		return len(x.Distributions) != 0
+	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
+		return x.ParticipantAddress != ""
+	case "inference.inference.PoCV2StoreCommitWithAddress.count":
+		return x.Count != uint32(0)
+	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
+		return len(x.RootHash) != 0
+	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
+		return x.HexPubKey != ""
+	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21154,15 +20932,23 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Has(f
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
-		x.Distributions = nil
+	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
+		x.ParticipantAddress = ""
+	case "inference.inference.PoCV2StoreCommitWithAddress.count":
+		x.Count = uint32(0)
+	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
+		x.RootHash = nil
+	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
+		x.HexPubKey = ""
+	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21172,19 +20958,28 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Clear
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
-		if len(x.Distributions) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{})
-		}
-		listValue := &_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &x.Distributions}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
+		value := x.ParticipantAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCV2StoreCommitWithAddress.count":
+		value := x.Count
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
+		value := x.RootHash
+		return protoreflect.ValueOfBytes(value)
+	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
+		value := x.HexPubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -21198,17 +20993,23 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Get(d
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
-		lv := value.List()
-		clv := lv.(*_QueryAllMLNodeWeightDistributionsForStageResponse_1_list)
-		x.Distributions = *clv.list
+	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
+		x.ParticipantAddress = value.Interface().(string)
+	case "inference.inference.PoCV2StoreCommitWithAddress.count":
+		x.Count = uint32(value.Uint())
+	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
+		x.RootHash = value.Bytes()
+	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
+		x.HexPubKey = value.Interface().(string)
+	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21222,45 +21023,56 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Set(f
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
-		if x.Distributions == nil {
-			x.Distributions = []*MLNodeWeightDistributionWithAddress{}
-		}
-		value := &_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &x.Distributions}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
+		panic(fmt.Errorf("field participant_address of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
+	case "inference.inference.PoCV2StoreCommitWithAddress.count":
+		panic(fmt.Errorf("field count of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
+	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
+		panic(fmt.Errorf("field root_hash of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
+	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
+		panic(fmt.Errorf("field hex_pub_key of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
+	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.PoCV2StoreCommitWithAddress is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
-		list := []*MLNodeWeightDistributionWithAddress{}
-		return protoreflect.ValueOfList(&_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &list})
+	case "inference.inference.PoCV2StoreCommitWithAddress.participant_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCV2StoreCommitWithAddress.count":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.PoCV2StoreCommitWithAddress.root_hash":
+		return protoreflect.ValueOfBytes(nil)
+	case "inference.inference.PoCV2StoreCommitWithAddress.hex_pub_key":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.PoCV2StoreCommitWithAddress.model_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.PoCV2StoreCommitWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.PoCV2StoreCommitWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.PoCV2StoreCommitWithAddress", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -21268,7 +21080,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Which
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -21279,7 +21091,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) GetUn
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -21291,7 +21103,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) SetUn
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) IsValid() bool {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) IsValid() bool {
 	return x != nil
 }
 
@@ -21301,9 +21113,9 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) IsVal
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_PoCV2StoreCommitWithAddress) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageResponse)
+		x := input.Message.Interface().(*PoCV2StoreCommitWithAddress)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21315,11 +21127,24 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 		var n int
 		var l int
 		_ = l
-		if len(x.Distributions) > 0 {
-			for _, e := range x.Distributions {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		l = len(x.ParticipantAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Count != 0 {
+			n += 1 + runtime.Sov(uint64(x.Count))
+		}
+		l = len(x.RootHash)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.HexPubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -21331,7 +21156,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageResponse)
+		x := input.Message.Interface().(*PoCV2StoreCommitWithAddress)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21350,21 +21175,38 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Distributions) > 0 {
-			for iNdEx := len(x.Distributions) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Distributions[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.HexPubKey) > 0 {
+			i -= len(x.HexPubKey)
+			copy(dAtA[i:], x.HexPubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HexPubKey)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.RootHash) > 0 {
+			i -= len(x.RootHash)
+			copy(dAtA[i:], x.RootHash)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RootHash)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.Count != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.ParticipantAddress) > 0 {
+			i -= len(x.ParticipantAddress)
+			copy(dAtA[i:], x.ParticipantAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantAddress)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -21377,7 +21219,7 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageResponse)
+		x := input.Message.Interface().(*PoCV2StoreCommitWithAddress)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21409,17 +21251,17 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCV2StoreCommitWithAddress: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: PoCV2StoreCommitWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Distributions", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -21429,25 +21271,140 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Distributions = append(x.Distributions, &MLNodeWeightDistributionWithAddress{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Distributions[len(x.Distributions)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.ParticipantAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+				}
+				x.Count = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Count |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
+				}
+				var byteLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					byteLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if byteLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + byteLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.RootHash = append(x.RootHash[:0], dAtA[iNdEx:postIndex]...)
+				if x.RootHash == nil {
+					x.RootHash = []byte{}
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.HexPubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -21484,81 +21441,26 @@ func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Proto
 	}
 }
 
-var _ protoreflect.List = (*_MLNodeWeightDistributionWithAddress_2_list)(nil)
-
-type _MLNodeWeightDistributionWithAddress_2_list struct {
-	list *[]*MLNodeWeight
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) AppendMutable() protoreflect.Value {
-	v := new(MLNodeWeight)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) NewElement() protoreflect.Value {
-	v := new(MLNodeWeight)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MLNodeWeightDistributionWithAddress_2_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MLNodeWeightDistributionWithAddress                     protoreflect.MessageDescriptor
-	fd_MLNodeWeightDistributionWithAddress_participant_address protoreflect.FieldDescriptor
-	fd_MLNodeWeightDistributionWithAddress_weights             protoreflect.FieldDescriptor
-	fd_MLNodeWeightDistributionWithAddress_model_id            protoreflect.FieldDescriptor
+	md_QueryAllMLNodeWeightDistributionsForStageRequest                              protoreflect.MessageDescriptor
+	fd_QueryAllMLNodeWeightDistributionsForStageRequest_poc_stage_start_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_MLNodeWeightDistributionWithAddress = File_inference_inference_query_proto.Messages().ByName("MLNodeWeightDistributionWithAddress")
-	fd_MLNodeWeightDistributionWithAddress_participant_address = md_MLNodeWeightDistributionWithAddress.Fields().ByName("participant_address")
-	fd_MLNodeWeightDistributionWithAddress_weights = md_MLNodeWeightDistributionWithAddress.Fields().ByName("weights")
-	fd_MLNodeWeightDistributionWithAddress_model_id = md_MLNodeWeightDistributionWithAddress.Fields().ByName("model_id")
+	md_QueryAllMLNodeWeightDistributionsForStageRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllMLNodeWeightDistributionsForStageRequest")
+	fd_QueryAllMLNodeWeightDistributionsForStageRequest_poc_stage_start_block_height = md_QueryAllMLNodeWeightDistributionsForStageRequest.Fields().ByName("poc_stage_start_block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_MLNodeWeightDistributionWithAddress)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)(nil)
 
-type fastReflection_MLNodeWeightDistributionWithAddress MLNodeWeightDistributionWithAddress
+type fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest QueryAllMLNodeWeightDistributionsForStageRequest
 
-func (x *MLNodeWeightDistributionWithAddress) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MLNodeWeightDistributionWithAddress)(x)
+func (x *QueryAllMLNodeWeightDistributionsForStageRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)(x)
 }
 
-func (x *MLNodeWeightDistributionWithAddress) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllMLNodeWeightDistributionsForStageRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[44]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -21570,43 +21472,43 @@ func (x *MLNodeWeightDistributionWithAddress) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MLNodeWeightDistributionWithAddress_messageType fastReflection_MLNodeWeightDistributionWithAddress_messageType
-var _ protoreflect.MessageType = fastReflection_MLNodeWeightDistributionWithAddress_messageType{}
+var _fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType{}
 
-type fastReflection_MLNodeWeightDistributionWithAddress_messageType struct{}
+type fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType struct{}
 
-func (x fastReflection_MLNodeWeightDistributionWithAddress_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MLNodeWeightDistributionWithAddress)(nil)
+func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)(nil)
 }
-func (x fastReflection_MLNodeWeightDistributionWithAddress_messageType) New() protoreflect.Message {
-	return new(fastReflection_MLNodeWeightDistributionWithAddress)
+func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)
 }
-func (x fastReflection_MLNodeWeightDistributionWithAddress_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MLNodeWeightDistributionWithAddress
+func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllMLNodeWeightDistributionsForStageRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Descriptor() protoreflect.MessageDescriptor {
-	return md_MLNodeWeightDistributionWithAddress
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllMLNodeWeightDistributionsForStageRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Type() protoreflect.MessageType {
-	return _fastReflection_MLNodeWeightDistributionWithAddress_messageType
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) New() protoreflect.Message {
-	return new(fastReflection_MLNodeWeightDistributionWithAddress)
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Interface() protoreflect.ProtoMessage {
-	return (*MLNodeWeightDistributionWithAddress)(x)
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllMLNodeWeightDistributionsForStageRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -21614,22 +21516,10 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ParticipantAddress != "" {
-		value := protoreflect.ValueOfString(x.ParticipantAddress)
-		if !f(fd_MLNodeWeightDistributionWithAddress_participant_address, value) {
-			return
-		}
-	}
-	if len(x.Weights) != 0 {
-		value := protoreflect.ValueOfList(&_MLNodeWeightDistributionWithAddress_2_list{list: &x.Weights})
-		if !f(fd_MLNodeWeightDistributionWithAddress_weights, value) {
-			return
-		}
-	}
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_MLNodeWeightDistributionWithAddress_model_id, value) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.PocStageStartBlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
+		if !f(fd_QueryAllMLNodeWeightDistributionsForStageRequest_poc_stage_start_block_height, value) {
 			return
 		}
 	}
@@ -21646,19 +21536,15 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
-		return x.ParticipantAddress != ""
-	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
-		return len(x.Weights) != 0
-	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
-		return x.ModelId != ""
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
+		return x.PocStageStartBlockHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21668,19 +21554,15 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
-		x.ParticipantAddress = ""
-	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
-		x.Weights = nil
-	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
-		x.ModelId = ""
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
+		x.PocStageStartBlockHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21690,25 +21572,16 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
-		value := x.ParticipantAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
-		if len(x.Weights) == 0 {
-			return protoreflect.ValueOfList(&_MLNodeWeightDistributionWithAddress_2_list{})
-		}
-		listValue := &_MLNodeWeightDistributionWithAddress_2_list{list: &x.Weights}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
+		value := x.PocStageStartBlockHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -21722,21 +21595,15 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
-		x.ParticipantAddress = value.Interface().(string)
-	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
-		lv := value.List()
-		clv := lv.(*_MLNodeWeightDistributionWithAddress_2_list)
-		x.Weights = *clv.list
-	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
-		x.ModelId = value.Interface().(string)
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
+		x.PocStageStartBlockHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21750,53 +21617,40 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
-		if x.Weights == nil {
-			x.Weights = []*MLNodeWeight{}
-		}
-		value := &_MLNodeWeightDistributionWithAddress_2_list{list: &x.Weights}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
-		panic(fmt.Errorf("field participant_address of message inference.inference.MLNodeWeightDistributionWithAddress is not mutable"))
-	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.MLNodeWeightDistributionWithAddress is not mutable"))
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
-		list := []*MLNodeWeight{}
-		return protoreflect.ValueOfList(&_MLNodeWeightDistributionWithAddress_2_list{list: &list})
-	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest.poc_stage_start_block_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MLNodeWeightDistributionWithAddress", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -21804,7 +21658,7 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -21815,7 +21669,7 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -21827,7 +21681,7 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) IsValid() bool {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -21837,9 +21691,9 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MLNodeWeightDistributionWithAddress)
+		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21851,19 +21705,8 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 		var n int
 		var l int
 		_ = l
-		l = len(x.ParticipantAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.Weights) > 0 {
-			for _, e := range x.Weights {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.PocStageStartBlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -21875,7 +21718,7 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MLNodeWeightDistributionWithAddress)
+		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21894,35 +21737,10 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.Weights) > 0 {
-			for iNdEx := len(x.Weights) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Weights[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x12
-			}
-		}
-		if len(x.ParticipantAddress) > 0 {
-			i -= len(x.ParticipantAddress)
-			copy(dAtA[i:], x.ParticipantAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantAddress)))
+		if x.PocStageStartBlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -21935,7 +21753,7 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MLNodeWeightDistributionWithAddress)
+		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21967,83 +21785,17 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ParticipantAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Weights = append(x.Weights, &MLNodeWeight{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Weights[len(x.Weights)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 				}
-				var stringLen uint64
+				x.PocStageStartBlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -22053,24 +21805,11 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.PocStageStartBlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -22106,24 +21845,77 @@ func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *pro
 	}
 }
 
+var _ protoreflect.List = (*_QueryAllMLNodeWeightDistributionsForStageResponse_1_list)(nil)
+
+type _QueryAllMLNodeWeightDistributionsForStageResponse_1_list struct {
+	list *[]*MLNodeWeightDistributionWithAddress
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeightDistributionWithAddress)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeightDistributionWithAddress)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(MLNodeWeightDistributionWithAddress)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) NewElement() protoreflect.Value {
+	v := new(MLNodeWeightDistributionWithAddress)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllMLNodeWeightDistributionsForStageResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetCurrentEpochRequest protoreflect.MessageDescriptor
+	md_QueryAllMLNodeWeightDistributionsForStageResponse               protoreflect.MessageDescriptor
+	fd_QueryAllMLNodeWeightDistributionsForStageResponse_distributions protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetCurrentEpochRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetCurrentEpochRequest")
+	md_QueryAllMLNodeWeightDistributionsForStageResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllMLNodeWeightDistributionsForStageResponse")
+	fd_QueryAllMLNodeWeightDistributionsForStageResponse_distributions = md_QueryAllMLNodeWeightDistributionsForStageResponse.Fields().ByName("distributions")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetCurrentEpochRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)(nil)
 
-type fastReflection_QueryGetCurrentEpochRequest QueryGetCurrentEpochRequest
+type fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse QueryAllMLNodeWeightDistributionsForStageResponse
 
-func (x *QueryGetCurrentEpochRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetCurrentEpochRequest)(x)
+func (x *QueryAllMLNodeWeightDistributionsForStageResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)(x)
 }
 
-func (x *QueryGetCurrentEpochRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllMLNodeWeightDistributionsForStageResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[45]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -22135,43 +21927,43 @@ func (x *QueryGetCurrentEpochRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetCurrentEpochRequest_messageType fastReflection_QueryGetCurrentEpochRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetCurrentEpochRequest_messageType{}
+var _fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType{}
 
-type fastReflection_QueryGetCurrentEpochRequest_messageType struct{}
+type fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType struct{}
 
-func (x fastReflection_QueryGetCurrentEpochRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetCurrentEpochRequest)(nil)
+func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)(nil)
 }
-func (x fastReflection_QueryGetCurrentEpochRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetCurrentEpochRequest)
+func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)
 }
-func (x fastReflection_QueryGetCurrentEpochRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetCurrentEpochRequest
+func (x fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllMLNodeWeightDistributionsForStageResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetCurrentEpochRequest
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllMLNodeWeightDistributionsForStageResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetCurrentEpochRequest_messageType
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetCurrentEpochRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetCurrentEpochRequest)
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetCurrentEpochRequest)(x)
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllMLNodeWeightDistributionsForStageResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -22179,7 +21971,13 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) Interface() protoreflect.Pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Distributions) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &x.Distributions})
+		if !f(fd_QueryAllMLNodeWeightDistributionsForStageResponse_distributions, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -22193,13 +21991,15 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) Range(f func(protoreflect.F
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
+		return len(x.Distributions) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22209,13 +22009,15 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) Has(fd protoreflect.FieldDe
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
+		x.Distributions = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22225,13 +22027,19 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) Clear(fd protoreflect.Field
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
+		if len(x.Distributions) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{})
+		}
+		listValue := &_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &x.Distributions}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -22245,13 +22053,17 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) Get(descriptor protoreflect
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
+		lv := value.List()
+		clv := lv.(*_QueryAllMLNodeWeightDistributionsForStageResponse_1_list)
+		x.Distributions = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22265,36 +22077,45 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) Set(fd protoreflect.FieldDe
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
+		if x.Distributions == nil {
+			x.Distributions = []*MLNodeWeightDistributionWithAddress{}
+		}
+		value := &_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &x.Distributions}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetCurrentEpochRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions":
+		list := []*MLNodeWeightDistributionWithAddress{}
+		return protoreflect.ValueOfList(&_QueryAllMLNodeWeightDistributionsForStageResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetCurrentEpochRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetCurrentEpochRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -22302,7 +22123,7 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) WhichOneof(d protoreflect.O
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetCurrentEpochRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -22313,7 +22134,7 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) GetUnknown() protoreflect.R
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -22325,7 +22146,7 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) SetUnknown(fields protorefl
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetCurrentEpochRequest) IsValid() bool {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -22335,9 +22156,9 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllMLNodeWeightDistributionsForStageResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
+		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22349,6 +22170,12 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.
 		var n int
 		var l int
 		_ = l
+		if len(x.Distributions) > 0 {
+			for _, e := range x.Distributions {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -22359,7 +22186,7 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
+		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22378,6 +22205,22 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.Distributions) > 0 {
+			for iNdEx := len(x.Distributions) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Distributions[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -22389,7 +22232,7 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
+		x := input.Message.Interface().(*QueryAllMLNodeWeightDistributionsForStageResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22421,12 +22264,46 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Distributions", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Distributions = append(x.Distributions, &MLNodeWeightDistributionWithAddress{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Distributions[len(x.Distributions)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -22462,26 +22339,81 @@ func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.
 	}
 }
 
-var (
-	md_QueryGetCurrentEpochResponse       protoreflect.MessageDescriptor
-	fd_QueryGetCurrentEpochResponse_epoch protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_MLNodeWeightDistributionWithAddress_2_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryGetCurrentEpochResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetCurrentEpochResponse")
-	fd_QueryGetCurrentEpochResponse_epoch = md_QueryGetCurrentEpochResponse.Fields().ByName("epoch")
+type _MLNodeWeightDistributionWithAddress_2_list struct {
+	list *[]*MLNodeWeight
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetCurrentEpochResponse)(nil)
-
-type fastReflection_QueryGetCurrentEpochResponse QueryGetCurrentEpochResponse
+func (x *_MLNodeWeightDistributionWithAddress_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-func (x *QueryGetCurrentEpochResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetCurrentEpochResponse)(x)
+func (x *_MLNodeWeightDistributionWithAddress_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *QueryGetCurrentEpochResponse) slowProtoReflect() protoreflect.Message {
+func (x *_MLNodeWeightDistributionWithAddress_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MLNodeWeightDistributionWithAddress_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MLNodeWeightDistributionWithAddress_2_list) AppendMutable() protoreflect.Value {
+	v := new(MLNodeWeight)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MLNodeWeightDistributionWithAddress_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MLNodeWeightDistributionWithAddress_2_list) NewElement() protoreflect.Value {
+	v := new(MLNodeWeight)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MLNodeWeightDistributionWithAddress_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_MLNodeWeightDistributionWithAddress                     protoreflect.MessageDescriptor
+	fd_MLNodeWeightDistributionWithAddress_participant_address protoreflect.FieldDescriptor
+	fd_MLNodeWeightDistributionWithAddress_weights             protoreflect.FieldDescriptor
+	fd_MLNodeWeightDistributionWithAddress_model_id            protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_MLNodeWeightDistributionWithAddress = File_inference_inference_query_proto.Messages().ByName("MLNodeWeightDistributionWithAddress")
+	fd_MLNodeWeightDistributionWithAddress_participant_address = md_MLNodeWeightDistributionWithAddress.Fields().ByName("participant_address")
+	fd_MLNodeWeightDistributionWithAddress_weights = md_MLNodeWeightDistributionWithAddress.Fields().ByName("weights")
+	fd_MLNodeWeightDistributionWithAddress_model_id = md_MLNodeWeightDistributionWithAddress.Fields().ByName("model_id")
+}
+
+var _ protoreflect.Message = (*fastReflection_MLNodeWeightDistributionWithAddress)(nil)
+
+type fastReflection_MLNodeWeightDistributionWithAddress MLNodeWeightDistributionWithAddress
+
+func (x *MLNodeWeightDistributionWithAddress) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MLNodeWeightDistributionWithAddress)(x)
+}
+
+func (x *MLNodeWeightDistributionWithAddress) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[46]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -22493,43 +22425,43 @@ func (x *QueryGetCurrentEpochResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetCurrentEpochResponse_messageType fastReflection_QueryGetCurrentEpochResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetCurrentEpochResponse_messageType{}
+var _fastReflection_MLNodeWeightDistributionWithAddress_messageType fastReflection_MLNodeWeightDistributionWithAddress_messageType
+var _ protoreflect.MessageType = fastReflection_MLNodeWeightDistributionWithAddress_messageType{}
 
-type fastReflection_QueryGetCurrentEpochResponse_messageType struct{}
+type fastReflection_MLNodeWeightDistributionWithAddress_messageType struct{}
 
-func (x fastReflection_QueryGetCurrentEpochResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetCurrentEpochResponse)(nil)
+func (x fastReflection_MLNodeWeightDistributionWithAddress_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MLNodeWeightDistributionWithAddress)(nil)
 }
-func (x fastReflection_QueryGetCurrentEpochResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetCurrentEpochResponse)
+func (x fastReflection_MLNodeWeightDistributionWithAddress_messageType) New() protoreflect.Message {
+	return new(fastReflection_MLNodeWeightDistributionWithAddress)
 }
-func (x fastReflection_QueryGetCurrentEpochResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetCurrentEpochResponse
+func (x fastReflection_MLNodeWeightDistributionWithAddress_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MLNodeWeightDistributionWithAddress
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetCurrentEpochResponse
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Descriptor() protoreflect.MessageDescriptor {
+	return md_MLNodeWeightDistributionWithAddress
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetCurrentEpochResponse_messageType
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Type() protoreflect.MessageType {
+	return _fastReflection_MLNodeWeightDistributionWithAddress_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetCurrentEpochResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetCurrentEpochResponse)
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) New() protoreflect.Message {
+	return new(fastReflection_MLNodeWeightDistributionWithAddress)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetCurrentEpochResponse)(x)
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Interface() protoreflect.ProtoMessage {
+	return (*MLNodeWeightDistributionWithAddress)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -22537,10 +22469,22 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Epoch != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Epoch)
-		if !f(fd_QueryGetCurrentEpochResponse_epoch, value) {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ParticipantAddress != "" {
+		value := protoreflect.ValueOfString(x.ParticipantAddress)
+		if !f(fd_MLNodeWeightDistributionWithAddress_participant_address, value) {
+			return
+		}
+	}
+	if len(x.Weights) != 0 {
+		value := protoreflect.ValueOfList(&_MLNodeWeightDistributionWithAddress_2_list{list: &x.Weights})
+		if !f(fd_MLNodeWeightDistributionWithAddress_weights, value) {
+			return
+		}
+	}
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_MLNodeWeightDistributionWithAddress_model_id, value) {
 			return
 		}
 	}
@@ -22557,15 +22501,19 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
-		return x.Epoch != uint64(0)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
+		return x.ParticipantAddress != ""
+	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
+		return len(x.Weights) != 0
+	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22575,15 +22523,19 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
-		x.Epoch = uint64(0)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
+		x.ParticipantAddress = ""
+	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
+		x.Weights = nil
+	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22593,16 +22545,25 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
-		value := x.Epoch
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
+		value := x.ParticipantAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
+		if len(x.Weights) == 0 {
+			return protoreflect.ValueOfList(&_MLNodeWeightDistributionWithAddress_2_list{})
+		}
+		listValue := &_MLNodeWeightDistributionWithAddress_2_list{list: &x.Weights}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -22616,15 +22577,21 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
-		x.Epoch = value.Uint()
+	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
+		x.ParticipantAddress = value.Interface().(string)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
+		lv := value.List()
+		clv := lv.(*_MLNodeWeightDistributionWithAddress_2_list)
+		x.Weights = *clv.list
+	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22638,40 +22605,53 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
-		panic(fmt.Errorf("field epoch of message inference.inference.QueryGetCurrentEpochResponse is not mutable"))
+	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
+		if x.Weights == nil {
+			x.Weights = []*MLNodeWeight{}
+		}
+		value := &_MLNodeWeightDistributionWithAddress_2_list{list: &x.Weights}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
+		panic(fmt.Errorf("field participant_address of message inference.inference.MLNodeWeightDistributionWithAddress is not mutable"))
+	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.MLNodeWeightDistributionWithAddress is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetCurrentEpochResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MLNodeWeightDistributionWithAddress.participant_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MLNodeWeightDistributionWithAddress.weights":
+		list := []*MLNodeWeight{}
+		return protoreflect.ValueOfList(&_MLNodeWeightDistributionWithAddress_2_list{list: &list})
+	case "inference.inference.MLNodeWeightDistributionWithAddress.model_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MLNodeWeightDistributionWithAddress"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MLNodeWeightDistributionWithAddress does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetCurrentEpochResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetCurrentEpochResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MLNodeWeightDistributionWithAddress", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -22679,7 +22659,7 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetCurrentEpochResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -22690,7 +22670,7 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetCurrentEpochResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -22702,7 +22682,7 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetCurrentEpochResponse) IsValid() bool {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) IsValid() bool {
 	return x != nil
 }
 
@@ -22712,9 +22692,9 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MLNodeWeightDistributionWithAddress) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
+		x := input.Message.Interface().(*MLNodeWeightDistributionWithAddress)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22726,8 +22706,19 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 		var n int
 		var l int
 		_ = l
-		if x.Epoch != 0 {
-			n += 1 + runtime.Sov(uint64(x.Epoch))
+		l = len(x.ParticipantAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Weights) > 0 {
+			for _, e := range x.Weights {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -22739,7 +22730,7 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
+		x := input.Message.Interface().(*MLNodeWeightDistributionWithAddress)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22758,10 +22749,35 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Epoch != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Epoch))
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0x1a
+		}
+		if len(x.Weights) > 0 {
+			for iNdEx := len(x.Weights) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Weights[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if len(x.ParticipantAddress) > 0 {
+			i -= len(x.ParticipantAddress)
+			copy(dAtA[i:], x.ParticipantAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantAddress)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -22774,7 +22790,7 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
+		x := input.Message.Interface().(*MLNodeWeightDistributionWithAddress)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22806,17 +22822,17 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
 				}
-				x.Epoch = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -22826,11 +22842,90 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Epoch |= uint64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ParticipantAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Weights = append(x.Weights, &MLNodeWeight{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Weights[len(x.Weights)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -22867,23 +22962,23 @@ func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface
 }
 
 var (
-	md_QueryGetTokenomicsDataRequest protoreflect.MessageDescriptor
+	md_QueryGetCurrentEpochRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetTokenomicsDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetTokenomicsDataRequest")
+	md_QueryGetCurrentEpochRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetCurrentEpochRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetTokenomicsDataRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetCurrentEpochRequest)(nil)
 
-type fastReflection_QueryGetTokenomicsDataRequest QueryGetTokenomicsDataRequest
+type fastReflection_QueryGetCurrentEpochRequest QueryGetCurrentEpochRequest
 
-func (x *QueryGetTokenomicsDataRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetTokenomicsDataRequest)(x)
+func (x *QueryGetCurrentEpochRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetCurrentEpochRequest)(x)
 }
 
-func (x *QueryGetTokenomicsDataRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetCurrentEpochRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[47]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -22895,43 +22990,43 @@ func (x *QueryGetTokenomicsDataRequest) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetTokenomicsDataRequest_messageType fastReflection_QueryGetTokenomicsDataRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetTokenomicsDataRequest_messageType{}
+var _fastReflection_QueryGetCurrentEpochRequest_messageType fastReflection_QueryGetCurrentEpochRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetCurrentEpochRequest_messageType{}
 
-type fastReflection_QueryGetTokenomicsDataRequest_messageType struct{}
+type fastReflection_QueryGetCurrentEpochRequest_messageType struct{}
 
-func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetTokenomicsDataRequest)(nil)
+func (x fastReflection_QueryGetCurrentEpochRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetCurrentEpochRequest)(nil)
 }
-func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetTokenomicsDataRequest)
+func (x fastReflection_QueryGetCurrentEpochRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetCurrentEpochRequest)
 }
-func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetTokenomicsDataRequest
+func (x fastReflection_QueryGetCurrentEpochRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetCurrentEpochRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetTokenomicsDataRequest
+func (x *fastReflection_QueryGetCurrentEpochRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetCurrentEpochRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetTokenomicsDataRequest_messageType
+func (x *fastReflection_QueryGetCurrentEpochRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetCurrentEpochRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetTokenomicsDataRequest)
+func (x *fastReflection_QueryGetCurrentEpochRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetCurrentEpochRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetTokenomicsDataRequest)(x)
+func (x *fastReflection_QueryGetCurrentEpochRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetCurrentEpochRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -22939,7 +23034,7 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetCurrentEpochRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -22953,13 +23048,13 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetCurrentEpochRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22969,13 +23064,13 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetCurrentEpochRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22985,13 +23080,13 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetCurrentEpochRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -23005,13 +23100,13 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetCurrentEpochRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23025,36 +23120,36 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetCurrentEpochRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetCurrentEpochRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetCurrentEpochRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetTokenomicsDataRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetCurrentEpochRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -23062,7 +23157,7 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetCurrentEpochRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -23073,7 +23168,7 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetCurrentEpochRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -23085,7 +23180,7 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) IsValid() bool {
+func (x *fastReflection_QueryGetCurrentEpochRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -23095,9 +23190,9 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetTokenomicsDataRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetCurrentEpochRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
+		x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23119,7 +23214,7 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
+		x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23149,7 +23244,7 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
+		x := input.Message.Interface().(*QueryGetCurrentEpochRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23181,10 +23276,10 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -23223,25 +23318,25 @@ func (x *fastReflection_QueryGetTokenomicsDataRequest) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryGetTokenomicsDataResponse                 protoreflect.MessageDescriptor
-	fd_QueryGetTokenomicsDataResponse_tokenomics_data protoreflect.FieldDescriptor
+	md_QueryGetCurrentEpochResponse       protoreflect.MessageDescriptor
+	fd_QueryGetCurrentEpochResponse_epoch protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetTokenomicsDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetTokenomicsDataResponse")
-	fd_QueryGetTokenomicsDataResponse_tokenomics_data = md_QueryGetTokenomicsDataResponse.Fields().ByName("tokenomics_data")
+	md_QueryGetCurrentEpochResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetCurrentEpochResponse")
+	fd_QueryGetCurrentEpochResponse_epoch = md_QueryGetCurrentEpochResponse.Fields().ByName("epoch")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetTokenomicsDataResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetCurrentEpochResponse)(nil)
 
-type fastReflection_QueryGetTokenomicsDataResponse QueryGetTokenomicsDataResponse
+type fastReflection_QueryGetCurrentEpochResponse QueryGetCurrentEpochResponse
 
-func (x *QueryGetTokenomicsDataResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetTokenomicsDataResponse)(x)
+func (x *QueryGetCurrentEpochResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetCurrentEpochResponse)(x)
 }
 
-func (x *QueryGetTokenomicsDataResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetCurrentEpochResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[48]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -23253,43 +23348,43 @@ func (x *QueryGetTokenomicsDataResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetTokenomicsDataResponse_messageType fastReflection_QueryGetTokenomicsDataResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetTokenomicsDataResponse_messageType{}
+var _fastReflection_QueryGetCurrentEpochResponse_messageType fastReflection_QueryGetCurrentEpochResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetCurrentEpochResponse_messageType{}
 
-type fastReflection_QueryGetTokenomicsDataResponse_messageType struct{}
+type fastReflection_QueryGetCurrentEpochResponse_messageType struct{}
 
-func (x fastReflection_QueryGetTokenomicsDataResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetTokenomicsDataResponse)(nil)
-}
-func (x fastReflection_QueryGetTokenomicsDataResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetTokenomicsDataResponse)
+func (x fastReflection_QueryGetCurrentEpochResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetCurrentEpochResponse)(nil)
 }
-func (x fastReflection_QueryGetTokenomicsDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetTokenomicsDataResponse
+func (x fastReflection_QueryGetCurrentEpochResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetCurrentEpochResponse)
+}
+func (x fastReflection_QueryGetCurrentEpochResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetCurrentEpochResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetTokenomicsDataResponse
+func (x *fastReflection_QueryGetCurrentEpochResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetCurrentEpochResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetTokenomicsDataResponse_messageType
+func (x *fastReflection_QueryGetCurrentEpochResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetCurrentEpochResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetTokenomicsDataResponse)
+func (x *fastReflection_QueryGetCurrentEpochResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetCurrentEpochResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetTokenomicsDataResponse)(x)
+func (x *fastReflection_QueryGetCurrentEpochResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetCurrentEpochResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -23297,10 +23392,10 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) Interface() protoreflect
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.TokenomicsData != nil {
-		value := protoreflect.ValueOfMessage(x.TokenomicsData.ProtoReflect())
-		if !f(fd_QueryGetTokenomicsDataResponse_tokenomics_data, value) {
+func (x *fastReflection_QueryGetCurrentEpochResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Epoch != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Epoch)
+		if !f(fd_QueryGetCurrentEpochResponse_epoch, value) {
 			return
 		}
 	}
@@ -23317,15 +23412,15 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) Range(f func(protoreflec
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetCurrentEpochResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
-		return x.TokenomicsData != nil
+	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
+		return x.Epoch != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23335,15 +23430,15 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) Has(fd protoreflect.Fiel
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetCurrentEpochResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
-		x.TokenomicsData = nil
+	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
+		x.Epoch = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23353,16 +23448,16 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) Clear(fd protoreflect.Fi
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetCurrentEpochResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
-		value := x.TokenomicsData
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
+		value := x.Epoch
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -23376,15 +23471,15 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) Get(descriptor protorefl
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetCurrentEpochResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
-		x.TokenomicsData = value.Message().Interface().(*TokenomicsData)
+	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
+		x.Epoch = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23398,44 +23493,40 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) Set(fd protoreflect.Fiel
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetCurrentEpochResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
-		if x.TokenomicsData == nil {
-			x.TokenomicsData = new(TokenomicsData)
-		}
-		return protoreflect.ValueOfMessage(x.TokenomicsData.ProtoReflect())
+	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
+		panic(fmt.Errorf("field epoch of message inference.inference.QueryGetCurrentEpochResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetCurrentEpochResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
-		m := new(TokenomicsData)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetCurrentEpochResponse.epoch":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetCurrentEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetCurrentEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetCurrentEpochResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetTokenomicsDataResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetCurrentEpochResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -23443,7 +23534,7 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) WhichOneof(d protoreflec
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetCurrentEpochResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -23454,7 +23545,7 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) GetUnknown() protoreflec
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetCurrentEpochResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -23466,7 +23557,7 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) SetUnknown(fields protor
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) IsValid() bool {
+func (x *fastReflection_QueryGetCurrentEpochResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -23476,9 +23567,9 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetCurrentEpochResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
+		x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23490,9 +23581,8 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 		var n int
 		var l int
 		_ = l
-		if x.TokenomicsData != nil {
-			l = options.Size(x.TokenomicsData)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Epoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.Epoch))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -23504,7 +23594,7 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
+		x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23523,19 +23613,10 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.TokenomicsData != nil {
-			encoded, err := options.Marshal(x.TokenomicsData)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.Epoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Epoch))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -23548,7 +23629,7 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
+		x := input.Message.Interface().(*QueryGetCurrentEpochResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23580,17 +23661,17 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCurrentEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TokenomicsData", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
 				}
-				var msglen int
+				x.Epoch = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -23600,28 +23681,11 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Epoch |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.TokenomicsData == nil {
-					x.TokenomicsData = &TokenomicsData{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenomicsData); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -23658,25 +23722,23 @@ func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoifa
 }
 
 var (
-	md_QueryGetUnitOfComputePriceProposalRequest             protoreflect.MessageDescriptor
-	fd_QueryGetUnitOfComputePriceProposalRequest_participant protoreflect.FieldDescriptor
+	md_QueryGetTokenomicsDataRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetUnitOfComputePriceProposalRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetUnitOfComputePriceProposalRequest")
-	fd_QueryGetUnitOfComputePriceProposalRequest_participant = md_QueryGetUnitOfComputePriceProposalRequest.Fields().ByName("participant")
+	md_QueryGetTokenomicsDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetTokenomicsDataRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetTokenomicsDataRequest)(nil)
 
-type fastReflection_QueryGetUnitOfComputePriceProposalRequest QueryGetUnitOfComputePriceProposalRequest
+type fastReflection_QueryGetTokenomicsDataRequest QueryGetTokenomicsDataRequest
 
-func (x *QueryGetUnitOfComputePriceProposalRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(x)
+func (x *QueryGetTokenomicsDataRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetTokenomicsDataRequest)(x)
 }
 
-func (x *QueryGetUnitOfComputePriceProposalRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetTokenomicsDataRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[49]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -23688,43 +23750,43 @@ func (x *QueryGetUnitOfComputePriceProposalRequest) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType{}
+var _fastReflection_QueryGetTokenomicsDataRequest_messageType fastReflection_QueryGetTokenomicsDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetTokenomicsDataRequest_messageType{}
 
-type fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType struct{}
+type fastReflection_QueryGetTokenomicsDataRequest_messageType struct{}
 
-func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(nil)
+func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetTokenomicsDataRequest)(nil)
 }
-func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetUnitOfComputePriceProposalRequest)
+func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetTokenomicsDataRequest)
 }
-func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetUnitOfComputePriceProposalRequest
+func (x fastReflection_QueryGetTokenomicsDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetTokenomicsDataRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetUnitOfComputePriceProposalRequest
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetTokenomicsDataRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetTokenomicsDataRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetUnitOfComputePriceProposalRequest)
+func (x *fastReflection_QueryGetTokenomicsDataRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetTokenomicsDataRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetUnitOfComputePriceProposalRequest)(x)
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetTokenomicsDataRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -23732,13 +23794,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Participant != "" {
-		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_QueryGetUnitOfComputePriceProposalRequest_participant, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -23752,15 +23808,13 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
-		return x.Participant != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23770,15 +23824,13 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
-		x.Participant = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23788,16 +23840,13 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
-		value := x.Participant
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -23811,15 +23860,13 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
-		x.Participant = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23833,40 +23880,36 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.QueryGetUnitOfComputePriceProposalRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetUnitOfComputePriceProposalRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetTokenomicsDataRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -23874,7 +23917,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -23885,7 +23928,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -23897,7 +23940,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) IsValid() bool {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -23907,9 +23950,9 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetTokenomicsDataRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
+		x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23921,10 +23964,6 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		l = len(x.Participant)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -23935,7 +23974,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
+		x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23954,13 +23993,6 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Participant) > 0 {
-			i -= len(x.Participant)
-			copy(dAtA[i:], x.Participant)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -23972,7 +24004,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
+		x := input.Message.Interface().(*QueryGetTokenomicsDataRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24004,44 +24036,12 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Participant = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -24078,27 +24078,25 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods(
 }
 
 var (
-	md_QueryGetUnitOfComputePriceProposalResponse          protoreflect.MessageDescriptor
-	fd_QueryGetUnitOfComputePriceProposalResponse_proposal protoreflect.FieldDescriptor
-	fd_QueryGetUnitOfComputePriceProposalResponse_default  protoreflect.FieldDescriptor
+	md_QueryGetTokenomicsDataResponse                 protoreflect.MessageDescriptor
+	fd_QueryGetTokenomicsDataResponse_tokenomics_data protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetUnitOfComputePriceProposalResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetUnitOfComputePriceProposalResponse")
-	fd_QueryGetUnitOfComputePriceProposalResponse_proposal = md_QueryGetUnitOfComputePriceProposalResponse.Fields().ByName("proposal")
-	fd_QueryGetUnitOfComputePriceProposalResponse_default = md_QueryGetUnitOfComputePriceProposalResponse.Fields().ByName("default")
+	md_QueryGetTokenomicsDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetTokenomicsDataResponse")
+	fd_QueryGetTokenomicsDataResponse_tokenomics_data = md_QueryGetTokenomicsDataResponse.Fields().ByName("tokenomics_data")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetTokenomicsDataResponse)(nil)
 
-type fastReflection_QueryGetUnitOfComputePriceProposalResponse QueryGetUnitOfComputePriceProposalResponse
+type fastReflection_QueryGetTokenomicsDataResponse QueryGetTokenomicsDataResponse
 
-func (x *QueryGetUnitOfComputePriceProposalResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(x)
+func (x *QueryGetTokenomicsDataResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetTokenomicsDataResponse)(x)
 }
 
-func (x *QueryGetUnitOfComputePriceProposalResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetTokenomicsDataResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[50]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -24110,43 +24108,43 @@ func (x *QueryGetUnitOfComputePriceProposalResponse) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType{}
+var _fastReflection_QueryGetTokenomicsDataResponse_messageType fastReflection_QueryGetTokenomicsDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetTokenomicsDataResponse_messageType{}
 
-type fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType struct{}
+type fastReflection_QueryGetTokenomicsDataResponse_messageType struct{}
 
-func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(nil)
+func (x fastReflection_QueryGetTokenomicsDataResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetTokenomicsDataResponse)(nil)
 }
-func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetUnitOfComputePriceProposalResponse)
+func (x fastReflection_QueryGetTokenomicsDataResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetTokenomicsDataResponse)
 }
-func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetUnitOfComputePriceProposalResponse
+func (x fastReflection_QueryGetTokenomicsDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetTokenomicsDataResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetUnitOfComputePriceProposalResponse
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetTokenomicsDataResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetTokenomicsDataResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetUnitOfComputePriceProposalResponse)
+func (x *fastReflection_QueryGetTokenomicsDataResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetTokenomicsDataResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetUnitOfComputePriceProposalResponse)(x)
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetTokenomicsDataResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -24154,16 +24152,10 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Proposal != nil {
-		value := protoreflect.ValueOfMessage(x.Proposal.ProtoReflect())
-		if !f(fd_QueryGetUnitOfComputePriceProposalResponse_proposal, value) {
-			return
-		}
-	}
-	if x.Default != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Default)
-		if !f(fd_QueryGetUnitOfComputePriceProposalResponse_default, value) {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.TokenomicsData != nil {
+		value := protoreflect.ValueOfMessage(x.TokenomicsData.ProtoReflect())
+		if !f(fd_QueryGetTokenomicsDataResponse_tokenomics_data, value) {
 			return
 		}
 	}
@@ -24180,17 +24172,15 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
-		return x.Proposal != nil
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
-		return x.Default != uint64(0)
+	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+		return x.TokenomicsData != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24200,17 +24190,15 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
-		x.Proposal = nil
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
-		x.Default = uint64(0)
+	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+		x.TokenomicsData = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24220,19 +24208,16 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
-		value := x.Proposal
+	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+		value := x.TokenomicsData
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
-		value := x.Default
-		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -24246,17 +24231,15 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
-		x.Proposal = value.Message().Interface().(*UnitOfComputePriceProposal)
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
-		x.Default = value.Uint()
+	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+		x.TokenomicsData = value.Message().Interface().(*TokenomicsData)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24270,48 +24253,44 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
-		if x.Proposal == nil {
-			x.Proposal = new(UnitOfComputePriceProposal)
+	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+		if x.TokenomicsData == nil {
+			x.TokenomicsData = new(TokenomicsData)
 		}
-		return protoreflect.ValueOfMessage(x.Proposal.ProtoReflect())
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
-		panic(fmt.Errorf("field default of message inference.inference.QueryGetUnitOfComputePriceProposalResponse is not mutable"))
+		return protoreflect.ValueOfMessage(x.TokenomicsData.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
-		m := new(UnitOfComputePriceProposal)
+	case "inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data":
+		m := new(TokenomicsData)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetTokenomicsDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetTokenomicsDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetUnitOfComputePriceProposalResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetTokenomicsDataResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -24319,7 +24298,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -24330,7 +24309,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -24342,7 +24321,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) IsValid() bool {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -24352,9 +24331,9 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetTokenomicsDataResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
+		x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24366,13 +24345,10 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 		var n int
 		var l int
 		_ = l
-		if x.Proposal != nil {
-			l = options.Size(x.Proposal)
+		if x.TokenomicsData != nil {
+			l = options.Size(x.TokenomicsData)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Default != 0 {
-			n += 1 + runtime.Sov(uint64(x.Default))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -24383,7 +24359,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
+		x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24402,13 +24378,8 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Default != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Default))
-			i--
-			dAtA[i] = 0x10
-		}
-		if x.Proposal != nil {
-			encoded, err := options.Marshal(x.Proposal)
+		if x.TokenomicsData != nil {
+			encoded, err := options.Marshal(x.TokenomicsData)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24432,7 +24403,7 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
+		x := input.Message.Interface().(*QueryGetTokenomicsDataResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24464,15 +24435,15 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetTokenomicsDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TokenomicsData", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -24499,32 +24470,13 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Proposal == nil {
-					x.Proposal = &UnitOfComputePriceProposal{}
+				if x.TokenomicsData == nil {
+					x.TokenomicsData = &TokenomicsData{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Proposal); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenomicsData); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
-				}
-				x.Default = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Default |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -24561,23 +24513,25 @@ func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods
 }
 
 var (
-	md_QueryCurrentEpochGroupDataRequest protoreflect.MessageDescriptor
+	md_QueryGetUnitOfComputePriceProposalRequest             protoreflect.MessageDescriptor
+	fd_QueryGetUnitOfComputePriceProposalRequest_participant protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCurrentEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryCurrentEpochGroupDataRequest")
+	md_QueryGetUnitOfComputePriceProposalRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetUnitOfComputePriceProposalRequest")
+	fd_QueryGetUnitOfComputePriceProposalRequest_participant = md_QueryGetUnitOfComputePriceProposalRequest.Fields().ByName("participant")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCurrentEpochGroupDataRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(nil)
 
-type fastReflection_QueryCurrentEpochGroupDataRequest QueryCurrentEpochGroupDataRequest
+type fastReflection_QueryGetUnitOfComputePriceProposalRequest QueryGetUnitOfComputePriceProposalRequest
 
-func (x *QueryCurrentEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCurrentEpochGroupDataRequest)(x)
+func (x *QueryGetUnitOfComputePriceProposalRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(x)
 }
 
-func (x *QueryCurrentEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetUnitOfComputePriceProposalRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[51]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -24589,43 +24543,43 @@ func (x *QueryCurrentEpochGroupDataRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCurrentEpochGroupDataRequest_messageType fastReflection_QueryCurrentEpochGroupDataRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCurrentEpochGroupDataRequest_messageType{}
+var _fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType{}
 
-type fastReflection_QueryCurrentEpochGroupDataRequest_messageType struct{}
+type fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType struct{}
 
-func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCurrentEpochGroupDataRequest)(nil)
+func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetUnitOfComputePriceProposalRequest)(nil)
 }
-func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCurrentEpochGroupDataRequest)
+func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetUnitOfComputePriceProposalRequest)
 }
-func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCurrentEpochGroupDataRequest
+func (x fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetUnitOfComputePriceProposalRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCurrentEpochGroupDataRequest
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetUnitOfComputePriceProposalRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCurrentEpochGroupDataRequest_messageType
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetUnitOfComputePriceProposalRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryCurrentEpochGroupDataRequest)
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetUnitOfComputePriceProposalRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryCurrentEpochGroupDataRequest)(x)
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetUnitOfComputePriceProposalRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -24633,7 +24587,13 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryGetUnitOfComputePriceProposalRequest_participant, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -24647,13 +24607,15 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
+		return x.Participant != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24663,13 +24625,15 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
+		x.Participant = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24679,13 +24643,16 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -24699,13 +24666,15 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
+		x.Participant = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24719,36 +24688,40 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryGetUnitOfComputePriceProposalRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetUnitOfComputePriceProposalRequest.participant":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCurrentEpochGroupDataRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetUnitOfComputePriceProposalRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -24756,7 +24729,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -24767,7 +24740,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -24779,7 +24752,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) IsValid() bool {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -24789,9 +24762,9 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
+		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24803,6 +24776,10 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -24813,7 +24790,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
+		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24832,6 +24809,13 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -24843,7 +24827,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
+		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24875,12 +24859,44 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -24917,25 +24933,27 @@ func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *proto
 }
 
 var (
-	md_QueryCurrentEpochGroupDataResponse                  protoreflect.MessageDescriptor
-	fd_QueryCurrentEpochGroupDataResponse_epoch_group_data protoreflect.FieldDescriptor
+	md_QueryGetUnitOfComputePriceProposalResponse          protoreflect.MessageDescriptor
+	fd_QueryGetUnitOfComputePriceProposalResponse_proposal protoreflect.FieldDescriptor
+	fd_QueryGetUnitOfComputePriceProposalResponse_default  protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCurrentEpochGroupDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryCurrentEpochGroupDataResponse")
-	fd_QueryCurrentEpochGroupDataResponse_epoch_group_data = md_QueryCurrentEpochGroupDataResponse.Fields().ByName("epoch_group_data")
+	md_QueryGetUnitOfComputePriceProposalResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetUnitOfComputePriceProposalResponse")
+	fd_QueryGetUnitOfComputePriceProposalResponse_proposal = md_QueryGetUnitOfComputePriceProposalResponse.Fields().ByName("proposal")
+	fd_QueryGetUnitOfComputePriceProposalResponse_default = md_QueryGetUnitOfComputePriceProposalResponse.Fields().ByName("default")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCurrentEpochGroupDataResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(nil)
 
-type fastReflection_QueryCurrentEpochGroupDataResponse QueryCurrentEpochGroupDataResponse
+type fastReflection_QueryGetUnitOfComputePriceProposalResponse QueryGetUnitOfComputePriceProposalResponse
 
-func (x *QueryCurrentEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCurrentEpochGroupDataResponse)(x)
+func (x *QueryGetUnitOfComputePriceProposalResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(x)
 }
 
-func (x *QueryCurrentEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetUnitOfComputePriceProposalResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[52]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -24947,43 +24965,43 @@ func (x *QueryCurrentEpochGroupDataResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCurrentEpochGroupDataResponse_messageType fastReflection_QueryCurrentEpochGroupDataResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCurrentEpochGroupDataResponse_messageType{}
+var _fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType{}
 
-type fastReflection_QueryCurrentEpochGroupDataResponse_messageType struct{}
+type fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType struct{}
 
-func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCurrentEpochGroupDataResponse)(nil)
+func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetUnitOfComputePriceProposalResponse)(nil)
 }
-func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCurrentEpochGroupDataResponse)
+func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetUnitOfComputePriceProposalResponse)
 }
-func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCurrentEpochGroupDataResponse
+func (x fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetUnitOfComputePriceProposalResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCurrentEpochGroupDataResponse
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetUnitOfComputePriceProposalResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCurrentEpochGroupDataResponse_messageType
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetUnitOfComputePriceProposalResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryCurrentEpochGroupDataResponse)
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetUnitOfComputePriceProposalResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryCurrentEpochGroupDataResponse)(x)
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetUnitOfComputePriceProposalResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -24991,10 +25009,16 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochGroupData != nil {
-		value := protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
-		if !f(fd_QueryCurrentEpochGroupDataResponse_epoch_group_data, value) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Proposal != nil {
+		value := protoreflect.ValueOfMessage(x.Proposal.ProtoReflect())
+		if !f(fd_QueryGetUnitOfComputePriceProposalResponse_proposal, value) {
+			return
+		}
+	}
+	if x.Default != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Default)
+		if !f(fd_QueryGetUnitOfComputePriceProposalResponse_default, value) {
 			return
 		}
 	}
@@ -25011,15 +25035,17 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
-		return x.EpochGroupData != nil
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+		return x.Proposal != nil
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
+		return x.Default != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25029,15 +25055,17 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
-		x.EpochGroupData = nil
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+		x.Proposal = nil
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
+		x.Default = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25047,16 +25075,19 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
-		value := x.EpochGroupData
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+		value := x.Proposal
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
+		value := x.Default
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -25070,15 +25101,17 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
-		x.EpochGroupData = value.Message().Interface().(*EpochGroupData)
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+		x.Proposal = value.Message().Interface().(*UnitOfComputePriceProposal)
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
+		x.Default = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25092,44 +25125,48 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
-		if x.EpochGroupData == nil {
-			x.EpochGroupData = new(EpochGroupData)
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+		if x.Proposal == nil {
+			x.Proposal = new(UnitOfComputePriceProposal)
 		}
-		return protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.Proposal.ProtoReflect())
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
+		panic(fmt.Errorf("field default of message inference.inference.QueryGetUnitOfComputePriceProposalResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
-		m := new(EpochGroupData)
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal":
+		m := new(UnitOfComputePriceProposal)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetUnitOfComputePriceProposalResponse.default":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCurrentEpochGroupDataResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetUnitOfComputePriceProposalResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -25137,7 +25174,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -25148,7 +25185,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -25160,7 +25197,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) IsValid() bool {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -25170,9 +25207,9 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetUnitOfComputePriceProposalResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
+		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25184,10 +25221,13 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if x.EpochGroupData != nil {
-			l = options.Size(x.EpochGroupData)
+		if x.Proposal != nil {
+			l = options.Size(x.Proposal)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		if x.Default != 0 {
+			n += 1 + runtime.Sov(uint64(x.Default))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -25198,7 +25238,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
+		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25217,8 +25257,13 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochGroupData != nil {
-			encoded, err := options.Marshal(x.EpochGroupData)
+		if x.Default != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Default))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.Proposal != nil {
+			encoded, err := options.Marshal(x.Proposal)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25242,7 +25287,7 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
+		x := input.Message.Interface().(*QueryGetUnitOfComputePriceProposalResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25274,15 +25319,15 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -25309,13 +25354,32 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.EpochGroupData == nil {
-					x.EpochGroupData = &EpochGroupData{}
+				if x.Proposal == nil {
+					x.Proposal = &UnitOfComputePriceProposal{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupData); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Proposal); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
+				}
+				x.Default = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Default |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -25352,23 +25416,23 @@ func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *prot
 }
 
 var (
-	md_QueryPreviousEpochGroupDataRequest protoreflect.MessageDescriptor
+	md_QueryCurrentEpochGroupDataRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPreviousEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryPreviousEpochGroupDataRequest")
+	md_QueryCurrentEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryCurrentEpochGroupDataRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPreviousEpochGroupDataRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCurrentEpochGroupDataRequest)(nil)
 
-type fastReflection_QueryPreviousEpochGroupDataRequest QueryPreviousEpochGroupDataRequest
+type fastReflection_QueryCurrentEpochGroupDataRequest QueryCurrentEpochGroupDataRequest
 
-func (x *QueryPreviousEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPreviousEpochGroupDataRequest)(x)
+func (x *QueryCurrentEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCurrentEpochGroupDataRequest)(x)
 }
 
-func (x *QueryPreviousEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryCurrentEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[53]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -25380,43 +25444,43 @@ func (x *QueryPreviousEpochGroupDataRequest) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPreviousEpochGroupDataRequest_messageType fastReflection_QueryPreviousEpochGroupDataRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPreviousEpochGroupDataRequest_messageType{}
+var _fastReflection_QueryCurrentEpochGroupDataRequest_messageType fastReflection_QueryCurrentEpochGroupDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCurrentEpochGroupDataRequest_messageType{}
 
-type fastReflection_QueryPreviousEpochGroupDataRequest_messageType struct{}
+type fastReflection_QueryCurrentEpochGroupDataRequest_messageType struct{}
 
-func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPreviousEpochGroupDataRequest)(nil)
+func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCurrentEpochGroupDataRequest)(nil)
 }
-func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPreviousEpochGroupDataRequest)
+func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCurrentEpochGroupDataRequest)
 }
-func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreviousEpochGroupDataRequest
+func (x fastReflection_QueryCurrentEpochGroupDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCurrentEpochGroupDataRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreviousEpochGroupDataRequest
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCurrentEpochGroupDataRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPreviousEpochGroupDataRequest_messageType
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCurrentEpochGroupDataRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPreviousEpochGroupDataRequest)
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryCurrentEpochGroupDataRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPreviousEpochGroupDataRequest)(x)
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryCurrentEpochGroupDataRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -25424,7 +25488,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -25438,13 +25502,13 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25454,13 +25518,13 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25470,13 +25534,13 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -25490,13 +25554,13 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25510,36 +25574,36 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreviousEpochGroupDataRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCurrentEpochGroupDataRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -25547,7 +25611,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -25558,7 +25622,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -25570,7 +25634,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) IsValid() bool {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -25580,9 +25644,9 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPreviousEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCurrentEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
+		x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25604,7 +25668,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
+		x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25634,7 +25698,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
+		x := input.Message.Interface().(*QueryCurrentEpochGroupDataRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25666,10 +25730,10 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -25708,25 +25772,25 @@ func (x *fastReflection_QueryPreviousEpochGroupDataRequest) ProtoMethods() *prot
 }
 
 var (
-	md_QueryPreviousEpochGroupDataResponse                  protoreflect.MessageDescriptor
-	fd_QueryPreviousEpochGroupDataResponse_epoch_group_data protoreflect.FieldDescriptor
+	md_QueryCurrentEpochGroupDataResponse                  protoreflect.MessageDescriptor
+	fd_QueryCurrentEpochGroupDataResponse_epoch_group_data protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPreviousEpochGroupDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryPreviousEpochGroupDataResponse")
-	fd_QueryPreviousEpochGroupDataResponse_epoch_group_data = md_QueryPreviousEpochGroupDataResponse.Fields().ByName("epoch_group_data")
+	md_QueryCurrentEpochGroupDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryCurrentEpochGroupDataResponse")
+	fd_QueryCurrentEpochGroupDataResponse_epoch_group_data = md_QueryCurrentEpochGroupDataResponse.Fields().ByName("epoch_group_data")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPreviousEpochGroupDataResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCurrentEpochGroupDataResponse)(nil)
 
-type fastReflection_QueryPreviousEpochGroupDataResponse QueryPreviousEpochGroupDataResponse
+type fastReflection_QueryCurrentEpochGroupDataResponse QueryCurrentEpochGroupDataResponse
 
-func (x *QueryPreviousEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPreviousEpochGroupDataResponse)(x)
+func (x *QueryCurrentEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCurrentEpochGroupDataResponse)(x)
 }
 
-func (x *QueryPreviousEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryCurrentEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[54]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -25738,43 +25802,43 @@ func (x *QueryPreviousEpochGroupDataResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPreviousEpochGroupDataResponse_messageType fastReflection_QueryPreviousEpochGroupDataResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPreviousEpochGroupDataResponse_messageType{}
+var _fastReflection_QueryCurrentEpochGroupDataResponse_messageType fastReflection_QueryCurrentEpochGroupDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCurrentEpochGroupDataResponse_messageType{}
 
-type fastReflection_QueryPreviousEpochGroupDataResponse_messageType struct{}
+type fastReflection_QueryCurrentEpochGroupDataResponse_messageType struct{}
 
-func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPreviousEpochGroupDataResponse)(nil)
+func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCurrentEpochGroupDataResponse)(nil)
 }
-func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPreviousEpochGroupDataResponse)
+func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCurrentEpochGroupDataResponse)
 }
-func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreviousEpochGroupDataResponse
+func (x fastReflection_QueryCurrentEpochGroupDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCurrentEpochGroupDataResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreviousEpochGroupDataResponse
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCurrentEpochGroupDataResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPreviousEpochGroupDataResponse_messageType
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCurrentEpochGroupDataResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPreviousEpochGroupDataResponse)
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryCurrentEpochGroupDataResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPreviousEpochGroupDataResponse)(x)
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryCurrentEpochGroupDataResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -25782,10 +25846,10 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.EpochGroupData != nil {
 		value := protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
-		if !f(fd_QueryPreviousEpochGroupDataResponse_epoch_group_data, value) {
+		if !f(fd_QueryCurrentEpochGroupDataResponse_epoch_group_data, value) {
 			return
 		}
 	}
@@ -25802,15 +25866,15 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
 		return x.EpochGroupData != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25820,15 +25884,15 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
 		x.EpochGroupData = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25838,16 +25902,16 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
 		value := x.EpochGroupData
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -25861,15 +25925,15 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
 		x.EpochGroupData = value.Message().Interface().(*EpochGroupData)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25883,44 +25947,44 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
 		if x.EpochGroupData == nil {
 			x.EpochGroupData = new(EpochGroupData)
 		}
 		return protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+	case "inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data":
 		m := new(EpochGroupData)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCurrentEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCurrentEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreviousEpochGroupDataResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCurrentEpochGroupDataResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -25928,7 +25992,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -25939,7 +26003,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -25951,7 +26015,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) IsValid() bool {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -25961,9 +26025,9 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPreviousEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCurrentEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
+		x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25989,7 +26053,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
+		x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26033,7 +26097,7 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
+		x := input.Message.Interface().(*QueryCurrentEpochGroupDataResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26065,10 +26129,10 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -26143,25 +26207,23 @@ func (x *fastReflection_QueryPreviousEpochGroupDataResponse) ProtoMethods() *pro
 }
 
 var (
-	md_QueryModelsAllRequest            protoreflect.MessageDescriptor
-	fd_QueryModelsAllRequest_pagination protoreflect.FieldDescriptor
+	md_QueryPreviousEpochGroupDataRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryModelsAllRequest = File_inference_inference_query_proto.Messages().ByName("QueryModelsAllRequest")
-	fd_QueryModelsAllRequest_pagination = md_QueryModelsAllRequest.Fields().ByName("pagination")
+	md_QueryPreviousEpochGroupDataRequest = File_inference_inference_query_proto.Messages().ByName("QueryPreviousEpochGroupDataRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryModelsAllRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPreviousEpochGroupDataRequest)(nil)
 
-type fastReflection_QueryModelsAllRequest QueryModelsAllRequest
+type fastReflection_QueryPreviousEpochGroupDataRequest QueryPreviousEpochGroupDataRequest
 
-func (x *QueryModelsAllRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryModelsAllRequest)(x)
+func (x *QueryPreviousEpochGroupDataRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPreviousEpochGroupDataRequest)(x)
 }
 
-func (x *QueryModelsAllRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPreviousEpochGroupDataRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[55]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -26173,43 +26235,43 @@ func (x *QueryModelsAllRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryModelsAllRequest_messageType fastReflection_QueryModelsAllRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryModelsAllRequest_messageType{}
+var _fastReflection_QueryPreviousEpochGroupDataRequest_messageType fastReflection_QueryPreviousEpochGroupDataRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPreviousEpochGroupDataRequest_messageType{}
 
-type fastReflection_QueryModelsAllRequest_messageType struct{}
+type fastReflection_QueryPreviousEpochGroupDataRequest_messageType struct{}
 
-func (x fastReflection_QueryModelsAllRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryModelsAllRequest)(nil)
+func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPreviousEpochGroupDataRequest)(nil)
 }
-func (x fastReflection_QueryModelsAllRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryModelsAllRequest)
+func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPreviousEpochGroupDataRequest)
 }
-func (x fastReflection_QueryModelsAllRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryModelsAllRequest
+func (x fastReflection_QueryPreviousEpochGroupDataRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreviousEpochGroupDataRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryModelsAllRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryModelsAllRequest
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreviousEpochGroupDataRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryModelsAllRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryModelsAllRequest_messageType
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPreviousEpochGroupDataRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryModelsAllRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryModelsAllRequest)
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPreviousEpochGroupDataRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryModelsAllRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryModelsAllRequest)(x)
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPreviousEpochGroupDataRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -26217,13 +26279,7 @@ func (x *fastReflection_QueryModelsAllRequest) Interface() protoreflect.ProtoMes
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryModelsAllRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryModelsAllRequest_pagination, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -26237,15 +26293,13 @@ func (x *fastReflection_QueryModelsAllRequest) Range(f func(protoreflect.FieldDe
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryModelsAllRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllRequest.pagination":
-		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26255,15 +26309,13 @@ func (x *fastReflection_QueryModelsAllRequest) Has(fd protoreflect.FieldDescript
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllRequest.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26273,16 +26325,13 @@ func (x *fastReflection_QueryModelsAllRequest) Clear(fd protoreflect.FieldDescri
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryModelsAllRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryModelsAllRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -26296,15 +26345,13 @@ func (x *fastReflection_QueryModelsAllRequest) Get(descriptor protoreflect.Field
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26318,44 +26365,36 @@ func (x *fastReflection_QueryModelsAllRequest) Set(fd protoreflect.FieldDescript
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryModelsAllRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryModelsAllRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryModelsAllRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreviousEpochGroupDataRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -26363,7 +26402,7 @@ func (x *fastReflection_QueryModelsAllRequest) WhichOneof(d protoreflect.OneofDe
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryModelsAllRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -26374,7 +26413,7 @@ func (x *fastReflection_QueryModelsAllRequest) GetUnknown() protoreflect.RawFiel
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -26386,7 +26425,7 @@ func (x *fastReflection_QueryModelsAllRequest) SetUnknown(fields protoreflect.Ra
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryModelsAllRequest) IsValid() bool {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -26396,9 +26435,9 @@ func (x *fastReflection_QueryModelsAllRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPreviousEpochGroupDataRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryModelsAllRequest)
+		x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26410,10 +26449,6 @@ func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Method
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -26424,7 +26459,7 @@ func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Method
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryModelsAllRequest)
+		x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26443,20 +26478,6 @@ func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Method
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -26468,7 +26489,7 @@ func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Method
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryModelsAllRequest)
+		x := input.Message.Interface().(*QueryPreviousEpochGroupDataRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26500,48 +26521,12 @@ func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Method
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -26577,79 +26562,26 @@ func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Method
 	}
 }
 
-var _ protoreflect.List = (*_QueryModelsAllResponse_1_list)(nil)
-
-type _QueryModelsAllResponse_1_list struct {
-	list *[]*Model
-}
-
-func (x *_QueryModelsAllResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryModelsAllResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryModelsAllResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*Model)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryModelsAllResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*Model)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryModelsAllResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(Model)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryModelsAllResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryModelsAllResponse_1_list) NewElement() protoreflect.Value {
-	v := new(Model)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryModelsAllResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryModelsAllResponse            protoreflect.MessageDescriptor
-	fd_QueryModelsAllResponse_model      protoreflect.FieldDescriptor
-	fd_QueryModelsAllResponse_pagination protoreflect.FieldDescriptor
+	md_QueryPreviousEpochGroupDataResponse                  protoreflect.MessageDescriptor
+	fd_QueryPreviousEpochGroupDataResponse_epoch_group_data protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryModelsAllResponse = File_inference_inference_query_proto.Messages().ByName("QueryModelsAllResponse")
-	fd_QueryModelsAllResponse_model = md_QueryModelsAllResponse.Fields().ByName("model")
-	fd_QueryModelsAllResponse_pagination = md_QueryModelsAllResponse.Fields().ByName("pagination")
+	md_QueryPreviousEpochGroupDataResponse = File_inference_inference_query_proto.Messages().ByName("QueryPreviousEpochGroupDataResponse")
+	fd_QueryPreviousEpochGroupDataResponse_epoch_group_data = md_QueryPreviousEpochGroupDataResponse.Fields().ByName("epoch_group_data")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryModelsAllResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPreviousEpochGroupDataResponse)(nil)
 
-type fastReflection_QueryModelsAllResponse QueryModelsAllResponse
+type fastReflection_QueryPreviousEpochGroupDataResponse QueryPreviousEpochGroupDataResponse
 
-func (x *QueryModelsAllResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryModelsAllResponse)(x)
+func (x *QueryPreviousEpochGroupDataResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPreviousEpochGroupDataResponse)(x)
 }
 
-func (x *QueryModelsAllResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryPreviousEpochGroupDataResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[56]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -26661,43 +26593,43 @@ func (x *QueryModelsAllResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryModelsAllResponse_messageType fastReflection_QueryModelsAllResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryModelsAllResponse_messageType{}
+var _fastReflection_QueryPreviousEpochGroupDataResponse_messageType fastReflection_QueryPreviousEpochGroupDataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPreviousEpochGroupDataResponse_messageType{}
 
-type fastReflection_QueryModelsAllResponse_messageType struct{}
+type fastReflection_QueryPreviousEpochGroupDataResponse_messageType struct{}
 
-func (x fastReflection_QueryModelsAllResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryModelsAllResponse)(nil)
+func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPreviousEpochGroupDataResponse)(nil)
 }
-func (x fastReflection_QueryModelsAllResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryModelsAllResponse)
+func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPreviousEpochGroupDataResponse)
 }
-func (x fastReflection_QueryModelsAllResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryModelsAllResponse
+func (x fastReflection_QueryPreviousEpochGroupDataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreviousEpochGroupDataResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryModelsAllResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryModelsAllResponse
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreviousEpochGroupDataResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryModelsAllResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryModelsAllResponse_messageType
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPreviousEpochGroupDataResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryModelsAllResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryModelsAllResponse)
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPreviousEpochGroupDataResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryModelsAllResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryModelsAllResponse)(x)
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPreviousEpochGroupDataResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -26705,16 +26637,10 @@ func (x *fastReflection_QueryModelsAllResponse) Interface() protoreflect.ProtoMe
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryModelsAllResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Model) != 0 {
-		value := protoreflect.ValueOfList(&_QueryModelsAllResponse_1_list{list: &x.Model})
-		if !f(fd_QueryModelsAllResponse_model, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryModelsAllResponse_pagination, value) {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochGroupData != nil {
+		value := protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
+		if !f(fd_QueryPreviousEpochGroupDataResponse_epoch_group_data, value) {
 			return
 		}
 	}
@@ -26731,17 +26657,15 @@ func (x *fastReflection_QueryModelsAllResponse) Range(f func(protoreflect.FieldD
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryModelsAllResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllResponse.model":
-		return len(x.Model) != 0
-	case "inference.inference.QueryModelsAllResponse.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+		return x.EpochGroupData != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26751,17 +26675,15 @@ func (x *fastReflection_QueryModelsAllResponse) Has(fd protoreflect.FieldDescrip
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllResponse.model":
-		x.Model = nil
-	case "inference.inference.QueryModelsAllResponse.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+		x.EpochGroupData = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26771,22 +26693,16 @@ func (x *fastReflection_QueryModelsAllResponse) Clear(fd protoreflect.FieldDescr
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryModelsAllResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryModelsAllResponse.model":
-		if len(x.Model) == 0 {
-			return protoreflect.ValueOfList(&_QueryModelsAllResponse_1_list{})
-		}
-		listValue := &_QueryModelsAllResponse_1_list{list: &x.Model}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryModelsAllResponse.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+		value := x.EpochGroupData
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -26800,19 +26716,15 @@ func (x *fastReflection_QueryModelsAllResponse) Get(descriptor protoreflect.Fiel
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllResponse.model":
-		lv := value.List()
-		clv := lv.(*_QueryModelsAllResponse_1_list)
-		x.Model = *clv.list
-	case "inference.inference.QueryModelsAllResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+		x.EpochGroupData = value.Message().Interface().(*EpochGroupData)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26826,53 +26738,44 @@ func (x *fastReflection_QueryModelsAllResponse) Set(fd protoreflect.FieldDescrip
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllResponse.model":
-		if x.Model == nil {
-			x.Model = []*Model{}
-		}
-		value := &_QueryModelsAllResponse_1_list{list: &x.Model}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryModelsAllResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
+	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+		if x.EpochGroupData == nil {
+			x.EpochGroupData = new(EpochGroupData)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.EpochGroupData.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryModelsAllResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryModelsAllResponse.model":
-		list := []*Model{}
-		return protoreflect.ValueOfList(&_QueryModelsAllResponse_1_list{list: &list})
-	case "inference.inference.QueryModelsAllResponse.pagination":
-		m := new(v1beta1.PageResponse)
+	case "inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data":
+		m := new(EpochGroupData)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreviousEpochGroupDataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreviousEpochGroupDataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryModelsAllResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryModelsAllResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreviousEpochGroupDataResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -26880,7 +26783,7 @@ func (x *fastReflection_QueryModelsAllResponse) WhichOneof(d protoreflect.OneofD
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryModelsAllResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -26891,7 +26794,7 @@ func (x *fastReflection_QueryModelsAllResponse) GetUnknown() protoreflect.RawFie
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryModelsAllResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -26903,7 +26806,7 @@ func (x *fastReflection_QueryModelsAllResponse) SetUnknown(fields protoreflect.R
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryModelsAllResponse) IsValid() bool {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -26913,9 +26816,9 @@ func (x *fastReflection_QueryModelsAllResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPreviousEpochGroupDataResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryModelsAllResponse)
+		x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26927,14 +26830,8 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 		var n int
 		var l int
 		_ = l
-		if len(x.Model) > 0 {
-			for _, e := range x.Model {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.EpochGroupData != nil {
+			l = options.Size(x.EpochGroupData)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -26947,7 +26844,7 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryModelsAllResponse)
+		x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26966,8 +26863,8 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.EpochGroupData != nil {
+			encoded, err := options.Marshal(x.EpochGroupData)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26978,23 +26875,7 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Model) > 0 {
-			for iNdEx := len(x.Model) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Model[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -27007,7 +26888,7 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryModelsAllResponse)
+		x := input.Message.Interface().(*QueryPreviousEpochGroupDataResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27039,49 +26920,15 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Model = append(x.Model, &Model{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Model[len(x.Model)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -27108,10 +26955,10 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
+				if x.EpochGroupData == nil {
+					x.EpochGroupData = &EpochGroupData{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochGroupData); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -27151,27 +26998,25 @@ func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Metho
 }
 
 var (
-	md_QueryGetInferenceTimeoutRequest                  protoreflect.MessageDescriptor
-	fd_QueryGetInferenceTimeoutRequest_expirationHeight protoreflect.FieldDescriptor
-	fd_QueryGetInferenceTimeoutRequest_inferenceId      protoreflect.FieldDescriptor
+	md_QueryModelsAllRequest            protoreflect.MessageDescriptor
+	fd_QueryModelsAllRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetInferenceTimeoutRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceTimeoutRequest")
-	fd_QueryGetInferenceTimeoutRequest_expirationHeight = md_QueryGetInferenceTimeoutRequest.Fields().ByName("expirationHeight")
-	fd_QueryGetInferenceTimeoutRequest_inferenceId = md_QueryGetInferenceTimeoutRequest.Fields().ByName("inferenceId")
+	md_QueryModelsAllRequest = File_inference_inference_query_proto.Messages().ByName("QueryModelsAllRequest")
+	fd_QueryModelsAllRequest_pagination = md_QueryModelsAllRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetInferenceTimeoutRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryModelsAllRequest)(nil)
 
-type fastReflection_QueryGetInferenceTimeoutRequest QueryGetInferenceTimeoutRequest
+type fastReflection_QueryModelsAllRequest QueryModelsAllRequest
 
-func (x *QueryGetInferenceTimeoutRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceTimeoutRequest)(x)
+func (x *QueryModelsAllRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryModelsAllRequest)(x)
 }
 
-func (x *QueryGetInferenceTimeoutRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryModelsAllRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[57]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -27183,43 +27028,43 @@ func (x *QueryGetInferenceTimeoutRequest) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetInferenceTimeoutRequest_messageType fastReflection_QueryGetInferenceTimeoutRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetInferenceTimeoutRequest_messageType{}
+var _fastReflection_QueryModelsAllRequest_messageType fastReflection_QueryModelsAllRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryModelsAllRequest_messageType{}
 
-type fastReflection_QueryGetInferenceTimeoutRequest_messageType struct{}
+type fastReflection_QueryModelsAllRequest_messageType struct{}
 
-func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceTimeoutRequest)(nil)
+func (x fastReflection_QueryModelsAllRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryModelsAllRequest)(nil)
 }
-func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceTimeoutRequest)
+func (x fastReflection_QueryModelsAllRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryModelsAllRequest)
 }
-func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceTimeoutRequest
+func (x fastReflection_QueryModelsAllRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryModelsAllRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceTimeoutRequest
+func (x *fastReflection_QueryModelsAllRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryModelsAllRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetInferenceTimeoutRequest_messageType
+func (x *fastReflection_QueryModelsAllRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryModelsAllRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceTimeoutRequest)
+func (x *fastReflection_QueryModelsAllRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryModelsAllRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetInferenceTimeoutRequest)(x)
+func (x *fastReflection_QueryModelsAllRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryModelsAllRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -27227,16 +27072,10 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ExpirationHeight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.ExpirationHeight)
-		if !f(fd_QueryGetInferenceTimeoutRequest_expirationHeight, value) {
-			return
-		}
-	}
-	if x.InferenceId != "" {
-		value := protoreflect.ValueOfString(x.InferenceId)
-		if !f(fd_QueryGetInferenceTimeoutRequest_inferenceId, value) {
+func (x *fastReflection_QueryModelsAllRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryModelsAllRequest_pagination, value) {
 			return
 		}
 	}
@@ -27253,17 +27092,15 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryModelsAllRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
-		return x.ExpirationHeight != uint64(0)
-	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
-		return x.InferenceId != ""
+	case "inference.inference.QueryModelsAllRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27273,17 +27110,15 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryModelsAllRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
-		x.ExpirationHeight = uint64(0)
-	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
-		x.InferenceId = ""
+	case "inference.inference.QueryModelsAllRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27293,19 +27128,16 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryModelsAllRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
-		value := x.ExpirationHeight
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
-		value := x.InferenceId
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryModelsAllRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -27319,17 +27151,15 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryModelsAllRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
-		x.ExpirationHeight = value.Uint()
-	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
-		x.InferenceId = value.Interface().(string)
+	case "inference.inference.QueryModelsAllRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27343,44 +27173,44 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryModelsAllRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
-		panic(fmt.Errorf("field expirationHeight of message inference.inference.QueryGetInferenceTimeoutRequest is not mutable"))
-	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
-		panic(fmt.Errorf("field inferenceId of message inference.inference.QueryGetInferenceTimeoutRequest is not mutable"))
+	case "inference.inference.QueryModelsAllRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryModelsAllRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryModelsAllRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryModelsAllRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceTimeoutRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryModelsAllRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -27388,7 +27218,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryModelsAllRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -27399,7 +27229,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryModelsAllRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -27411,7 +27241,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) IsValid() bool {
+func (x *fastReflection_QueryModelsAllRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -27421,9 +27251,9 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryModelsAllRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
+		x := input.Message.Interface().(*QueryModelsAllRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27435,11 +27265,8 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 		var n int
 		var l int
 		_ = l
-		if x.ExpirationHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.ExpirationHeight))
-		}
-		l = len(x.InferenceId)
-		if l > 0 {
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -27452,7 +27279,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
+		x := input.Message.Interface().(*QueryModelsAllRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27471,17 +27298,19 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.InferenceId) > 0 {
-			i -= len(x.InferenceId)
-			copy(dAtA[i:], x.InferenceId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceId)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if x.ExpirationHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.ExpirationHeight))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -27494,7 +27323,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
+		x := input.Message.Interface().(*QueryModelsAllRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27526,36 +27355,17 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExpirationHeight", wireType)
-				}
-				x.ExpirationHeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.ExpirationHeight |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -27565,23 +27375,27 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.InferenceId = string(dAtA[iNdEx:postIndex])
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -27618,26 +27432,79 @@ func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoif
 	}
 }
 
+var _ protoreflect.List = (*_QueryModelsAllResponse_1_list)(nil)
+
+type _QueryModelsAllResponse_1_list struct {
+	list *[]*Model
+}
+
+func (x *_QueryModelsAllResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryModelsAllResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryModelsAllResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Model)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryModelsAllResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Model)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryModelsAllResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(Model)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryModelsAllResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryModelsAllResponse_1_list) NewElement() protoreflect.Value {
+	v := new(Model)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryModelsAllResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetInferenceTimeoutResponse                   protoreflect.MessageDescriptor
-	fd_QueryGetInferenceTimeoutResponse_inference_timeout protoreflect.FieldDescriptor
+	md_QueryModelsAllResponse            protoreflect.MessageDescriptor
+	fd_QueryModelsAllResponse_model      protoreflect.FieldDescriptor
+	fd_QueryModelsAllResponse_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetInferenceTimeoutResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceTimeoutResponse")
-	fd_QueryGetInferenceTimeoutResponse_inference_timeout = md_QueryGetInferenceTimeoutResponse.Fields().ByName("inference_timeout")
+	md_QueryModelsAllResponse = File_inference_inference_query_proto.Messages().ByName("QueryModelsAllResponse")
+	fd_QueryModelsAllResponse_model = md_QueryModelsAllResponse.Fields().ByName("model")
+	fd_QueryModelsAllResponse_pagination = md_QueryModelsAllResponse.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetInferenceTimeoutResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryModelsAllResponse)(nil)
 
-type fastReflection_QueryGetInferenceTimeoutResponse QueryGetInferenceTimeoutResponse
+type fastReflection_QueryModelsAllResponse QueryModelsAllResponse
 
-func (x *QueryGetInferenceTimeoutResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceTimeoutResponse)(x)
+func (x *QueryModelsAllResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryModelsAllResponse)(x)
 }
 
-func (x *QueryGetInferenceTimeoutResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryModelsAllResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[58]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -27649,43 +27516,43 @@ func (x *QueryGetInferenceTimeoutResponse) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetInferenceTimeoutResponse_messageType fastReflection_QueryGetInferenceTimeoutResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetInferenceTimeoutResponse_messageType{}
+var _fastReflection_QueryModelsAllResponse_messageType fastReflection_QueryModelsAllResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryModelsAllResponse_messageType{}
 
-type fastReflection_QueryGetInferenceTimeoutResponse_messageType struct{}
+type fastReflection_QueryModelsAllResponse_messageType struct{}
 
-func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceTimeoutResponse)(nil)
+func (x fastReflection_QueryModelsAllResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryModelsAllResponse)(nil)
 }
-func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceTimeoutResponse)
+func (x fastReflection_QueryModelsAllResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryModelsAllResponse)
 }
-func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceTimeoutResponse
+func (x fastReflection_QueryModelsAllResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryModelsAllResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceTimeoutResponse
+func (x *fastReflection_QueryModelsAllResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryModelsAllResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetInferenceTimeoutResponse_messageType
+func (x *fastReflection_QueryModelsAllResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryModelsAllResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceTimeoutResponse)
+func (x *fastReflection_QueryModelsAllResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryModelsAllResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetInferenceTimeoutResponse)(x)
+func (x *fastReflection_QueryModelsAllResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryModelsAllResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -27693,10 +27560,16 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.InferenceTimeout != nil {
-		value := protoreflect.ValueOfMessage(x.InferenceTimeout.ProtoReflect())
-		if !f(fd_QueryGetInferenceTimeoutResponse_inference_timeout, value) {
+func (x *fastReflection_QueryModelsAllResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Model) != 0 {
+		value := protoreflect.ValueOfList(&_QueryModelsAllResponse_1_list{list: &x.Model})
+		if !f(fd_QueryModelsAllResponse_model, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryModelsAllResponse_pagination, value) {
 			return
 		}
 	}
@@ -27713,15 +27586,17 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryModelsAllResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
-		return x.InferenceTimeout != nil
+	case "inference.inference.QueryModelsAllResponse.model":
+		return len(x.Model) != 0
+	case "inference.inference.QueryModelsAllResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27731,15 +27606,17 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryModelsAllResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
-		x.InferenceTimeout = nil
+	case "inference.inference.QueryModelsAllResponse.model":
+		x.Model = nil
+	case "inference.inference.QueryModelsAllResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27749,16 +27626,22 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryModelsAllResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
-		value := x.InferenceTimeout
+	case "inference.inference.QueryModelsAllResponse.model":
+		if len(x.Model) == 0 {
+			return protoreflect.ValueOfList(&_QueryModelsAllResponse_1_list{})
+		}
+		listValue := &_QueryModelsAllResponse_1_list{list: &x.Model}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryModelsAllResponse.pagination":
+		value := x.Pagination
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -27772,15 +27655,19 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryModelsAllResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
-		x.InferenceTimeout = value.Message().Interface().(*InferenceTimeout)
+	case "inference.inference.QueryModelsAllResponse.model":
+		lv := value.List()
+		clv := lv.(*_QueryModelsAllResponse_1_list)
+		x.Model = *clv.list
+	case "inference.inference.QueryModelsAllResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27794,44 +27681,53 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryModelsAllResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
-		if x.InferenceTimeout == nil {
-			x.InferenceTimeout = new(InferenceTimeout)
+	case "inference.inference.QueryModelsAllResponse.model":
+		if x.Model == nil {
+			x.Model = []*Model{}
 		}
-		return protoreflect.ValueOfMessage(x.InferenceTimeout.ProtoReflect())
+		value := &_QueryModelsAllResponse_1_list{list: &x.Model}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryModelsAllResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryModelsAllResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
-		m := new(InferenceTimeout)
+	case "inference.inference.QueryModelsAllResponse.model":
+		list := []*Model{}
+		return protoreflect.ValueOfList(&_QueryModelsAllResponse_1_list{list: &list})
+	case "inference.inference.QueryModelsAllResponse.pagination":
+		m := new(v1beta1.PageResponse)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryModelsAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryModelsAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryModelsAllResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceTimeoutResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryModelsAllResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -27839,7 +27735,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryModelsAllResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -27850,7 +27746,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryModelsAllResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -27862,7 +27758,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) IsValid() bool {
+func (x *fastReflection_QueryModelsAllResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -27872,9 +27768,9 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryModelsAllResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
+		x := input.Message.Interface().(*QueryModelsAllResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27886,8 +27782,14 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
-		if x.InferenceTimeout != nil {
-			l = options.Size(x.InferenceTimeout)
+		if len(x.Model) > 0 {
+			for _, e := range x.Model {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -27900,7 +27802,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
+		x := input.Message.Interface().(*QueryModelsAllResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27919,8 +27821,8 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.InferenceTimeout != nil {
-			encoded, err := options.Marshal(x.InferenceTimeout)
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27931,7 +27833,23 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if len(x.Model) > 0 {
+			for iNdEx := len(x.Model) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Model[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -27944,7 +27862,7 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
+		x := input.Message.Interface().(*QueryModelsAllResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27976,15 +27894,15 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryModelsAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceTimeout", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -28011,10 +27929,44 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.InferenceTimeout == nil {
-					x.InferenceTimeout = &InferenceTimeout{}
+				x.Model = append(x.Model, &Model{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Model[len(x.Model)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceTimeout); err != nil {
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -28054,25 +28006,27 @@ func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoi
 }
 
 var (
-	md_QueryAllInferenceTimeoutRequest            protoreflect.MessageDescriptor
-	fd_QueryAllInferenceTimeoutRequest_pagination protoreflect.FieldDescriptor
+	md_QueryGetInferenceTimeoutRequest                  protoreflect.MessageDescriptor
+	fd_QueryGetInferenceTimeoutRequest_expirationHeight protoreflect.FieldDescriptor
+	fd_QueryGetInferenceTimeoutRequest_inferenceId      protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllInferenceTimeoutRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceTimeoutRequest")
-	fd_QueryAllInferenceTimeoutRequest_pagination = md_QueryAllInferenceTimeoutRequest.Fields().ByName("pagination")
+	md_QueryGetInferenceTimeoutRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceTimeoutRequest")
+	fd_QueryGetInferenceTimeoutRequest_expirationHeight = md_QueryGetInferenceTimeoutRequest.Fields().ByName("expirationHeight")
+	fd_QueryGetInferenceTimeoutRequest_inferenceId = md_QueryGetInferenceTimeoutRequest.Fields().ByName("inferenceId")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllInferenceTimeoutRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceTimeoutRequest)(nil)
 
-type fastReflection_QueryAllInferenceTimeoutRequest QueryAllInferenceTimeoutRequest
+type fastReflection_QueryGetInferenceTimeoutRequest QueryGetInferenceTimeoutRequest
 
-func (x *QueryAllInferenceTimeoutRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceTimeoutRequest)(x)
+func (x *QueryGetInferenceTimeoutRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceTimeoutRequest)(x)
 }
 
-func (x *QueryAllInferenceTimeoutRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetInferenceTimeoutRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[59]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -28084,43 +28038,43 @@ func (x *QueryAllInferenceTimeoutRequest) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllInferenceTimeoutRequest_messageType fastReflection_QueryAllInferenceTimeoutRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllInferenceTimeoutRequest_messageType{}
+var _fastReflection_QueryGetInferenceTimeoutRequest_messageType fastReflection_QueryGetInferenceTimeoutRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceTimeoutRequest_messageType{}
 
-type fastReflection_QueryAllInferenceTimeoutRequest_messageType struct{}
+type fastReflection_QueryGetInferenceTimeoutRequest_messageType struct{}
 
-func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceTimeoutRequest)(nil)
+func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceTimeoutRequest)(nil)
 }
-func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceTimeoutRequest)
+func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceTimeoutRequest)
 }
-func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceTimeoutRequest
+func (x fastReflection_QueryGetInferenceTimeoutRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceTimeoutRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceTimeoutRequest
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceTimeoutRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllInferenceTimeoutRequest_messageType
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetInferenceTimeoutRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceTimeoutRequest)
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceTimeoutRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllInferenceTimeoutRequest)(x)
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetInferenceTimeoutRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -28128,10 +28082,16 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllInferenceTimeoutRequest_pagination, value) {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ExpirationHeight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ExpirationHeight)
+		if !f(fd_QueryGetInferenceTimeoutRequest_expirationHeight, value) {
+			return
+		}
+	}
+	if x.InferenceId != "" {
+		value := protoreflect.ValueOfString(x.InferenceId)
+		if !f(fd_QueryGetInferenceTimeoutRequest_inferenceId, value) {
 			return
 		}
 	}
@@ -28148,15 +28108,17 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
+		return x.ExpirationHeight != uint64(0)
+	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
+		return x.InferenceId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28166,15 +28128,17 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
+		x.ExpirationHeight = uint64(0)
+	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
+		x.InferenceId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28184,16 +28148,19 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
+		value := x.ExpirationHeight
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
+		value := x.InferenceId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -28207,15 +28174,17 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
+		x.ExpirationHeight = value.Uint()
+	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
+		x.InferenceId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28229,44 +28198,44 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
+		panic(fmt.Errorf("field expirationHeight of message inference.inference.QueryGetInferenceTimeoutRequest is not mutable"))
+	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
+		panic(fmt.Errorf("field inferenceId of message inference.inference.QueryGetInferenceTimeoutRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetInferenceTimeoutRequest.expirationHeight":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetInferenceTimeoutRequest.inferenceId":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceTimeoutRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceTimeoutRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -28274,7 +28243,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -28285,7 +28254,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -28297,7 +28266,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) IsValid() bool {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -28307,9 +28276,9 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetInferenceTimeoutRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
+		x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28321,8 +28290,11 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.ExpirationHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.ExpirationHeight))
+		}
+		l = len(x.InferenceId)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -28335,7 +28307,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
+		x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28354,19 +28326,17 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if len(x.InferenceId) > 0 {
+			i -= len(x.InferenceId)
+			copy(dAtA[i:], x.InferenceId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceId)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if x.ExpirationHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ExpirationHeight))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -28379,7 +28349,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
+		x := input.Message.Interface().(*QueryGetInferenceTimeoutRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28411,17 +28381,36 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExpirationHeight", wireType)
+				}
+				x.ExpirationHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ExpirationHeight |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -28431,27 +28420,23 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.InferenceId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -28488,79 +28473,26 @@ func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoif
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllInferenceTimeoutResponse_1_list)(nil)
-
-type _QueryAllInferenceTimeoutResponse_1_list struct {
-	list *[]*InferenceTimeout
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*InferenceTimeout)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*InferenceTimeout)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(InferenceTimeout)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) NewElement() protoreflect.Value {
-	v := new(InferenceTimeout)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllInferenceTimeoutResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryAllInferenceTimeoutResponse                   protoreflect.MessageDescriptor
-	fd_QueryAllInferenceTimeoutResponse_inference_timeout protoreflect.FieldDescriptor
-	fd_QueryAllInferenceTimeoutResponse_pagination        protoreflect.FieldDescriptor
+	md_QueryGetInferenceTimeoutResponse                   protoreflect.MessageDescriptor
+	fd_QueryGetInferenceTimeoutResponse_inference_timeout protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllInferenceTimeoutResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceTimeoutResponse")
-	fd_QueryAllInferenceTimeoutResponse_inference_timeout = md_QueryAllInferenceTimeoutResponse.Fields().ByName("inference_timeout")
-	fd_QueryAllInferenceTimeoutResponse_pagination = md_QueryAllInferenceTimeoutResponse.Fields().ByName("pagination")
+	md_QueryGetInferenceTimeoutResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceTimeoutResponse")
+	fd_QueryGetInferenceTimeoutResponse_inference_timeout = md_QueryGetInferenceTimeoutResponse.Fields().ByName("inference_timeout")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllInferenceTimeoutResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceTimeoutResponse)(nil)
 
-type fastReflection_QueryAllInferenceTimeoutResponse QueryAllInferenceTimeoutResponse
+type fastReflection_QueryGetInferenceTimeoutResponse QueryGetInferenceTimeoutResponse
 
-func (x *QueryAllInferenceTimeoutResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceTimeoutResponse)(x)
+func (x *QueryGetInferenceTimeoutResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceTimeoutResponse)(x)
 }
 
-func (x *QueryAllInferenceTimeoutResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetInferenceTimeoutResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[60]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -28572,43 +28504,43 @@ func (x *QueryAllInferenceTimeoutResponse) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllInferenceTimeoutResponse_messageType fastReflection_QueryAllInferenceTimeoutResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllInferenceTimeoutResponse_messageType{}
+var _fastReflection_QueryGetInferenceTimeoutResponse_messageType fastReflection_QueryGetInferenceTimeoutResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceTimeoutResponse_messageType{}
 
-type fastReflection_QueryAllInferenceTimeoutResponse_messageType struct{}
+type fastReflection_QueryGetInferenceTimeoutResponse_messageType struct{}
 
-func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceTimeoutResponse)(nil)
+func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceTimeoutResponse)(nil)
 }
-func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceTimeoutResponse)
+func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceTimeoutResponse)
 }
-func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceTimeoutResponse
+func (x fastReflection_QueryGetInferenceTimeoutResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceTimeoutResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceTimeoutResponse
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceTimeoutResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllInferenceTimeoutResponse_messageType
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetInferenceTimeoutResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceTimeoutResponse)
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceTimeoutResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllInferenceTimeoutResponse)(x)
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetInferenceTimeoutResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -28616,16 +28548,10 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.InferenceTimeout) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllInferenceTimeoutResponse_1_list{list: &x.InferenceTimeout})
-		if !f(fd_QueryAllInferenceTimeoutResponse_inference_timeout, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllInferenceTimeoutResponse_pagination, value) {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.InferenceTimeout != nil {
+		value := protoreflect.ValueOfMessage(x.InferenceTimeout.ProtoReflect())
+		if !f(fd_QueryGetInferenceTimeoutResponse_inference_timeout, value) {
 			return
 		}
 	}
@@ -28642,17 +28568,15 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
-		return len(x.InferenceTimeout) != 0
-	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
+		return x.InferenceTimeout != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28662,17 +28586,15 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
 		x.InferenceTimeout = nil
-	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28682,22 +28604,16 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
-		if len(x.InferenceTimeout) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllInferenceTimeoutResponse_1_list{})
-		}
-		listValue := &_QueryAllInferenceTimeoutResponse_1_list{list: &x.InferenceTimeout}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
+		value := x.InferenceTimeout
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -28711,19 +28627,15 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
-		lv := value.List()
-		clv := lv.(*_QueryAllInferenceTimeoutResponse_1_list)
-		x.InferenceTimeout = *clv.list
-	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
+		x.InferenceTimeout = value.Message().Interface().(*InferenceTimeout)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28737,53 +28649,44 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
 		if x.InferenceTimeout == nil {
-			x.InferenceTimeout = []*InferenceTimeout{}
-		}
-		value := &_QueryAllInferenceTimeoutResponse_1_list{list: &x.InferenceTimeout}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
+			x.InferenceTimeout = new(InferenceTimeout)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.InferenceTimeout.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
-		list := []*InferenceTimeout{}
-		return protoreflect.ValueOfList(&_QueryAllInferenceTimeoutResponse_1_list{list: &list})
-	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
-		m := new(v1beta1.PageResponse)
+	case "inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout":
+		m := new(InferenceTimeout)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceTimeoutResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceTimeoutResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -28791,7 +28694,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -28802,7 +28705,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -28814,7 +28717,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) IsValid() bool {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -28824,9 +28727,9 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetInferenceTimeoutResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
+		x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28838,14 +28741,8 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
-		if len(x.InferenceTimeout) > 0 {
-			for _, e := range x.InferenceTimeout {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.InferenceTimeout != nil {
+			l = options.Size(x.InferenceTimeout)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -28858,7 +28755,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
+		x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28877,8 +28774,8 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.InferenceTimeout != nil {
+			encoded, err := options.Marshal(x.InferenceTimeout)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28889,23 +28786,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.InferenceTimeout) > 0 {
-			for iNdEx := len(x.InferenceTimeout) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.InferenceTimeout[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -28918,7 +28799,7 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
+		x := input.Message.Interface().(*QueryGetInferenceTimeoutResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28950,10 +28831,10 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -28985,44 +28866,10 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.InferenceTimeout = append(x.InferenceTimeout, &InferenceTimeout{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceTimeout[len(x.InferenceTimeout)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
+				if x.InferenceTimeout == nil {
+					x.InferenceTimeout = &InferenceTimeout{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceTimeout); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -29062,27 +28909,25 @@ func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoi
 }
 
 var (
-	md_QueryGetInferenceValidationDetailsRequest             protoreflect.MessageDescriptor
-	fd_QueryGetInferenceValidationDetailsRequest_epochId     protoreflect.FieldDescriptor
-	fd_QueryGetInferenceValidationDetailsRequest_inferenceId protoreflect.FieldDescriptor
+	md_QueryAllInferenceTimeoutRequest            protoreflect.MessageDescriptor
+	fd_QueryAllInferenceTimeoutRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetInferenceValidationDetailsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationDetailsRequest")
-	fd_QueryGetInferenceValidationDetailsRequest_epochId = md_QueryGetInferenceValidationDetailsRequest.Fields().ByName("epochId")
-	fd_QueryGetInferenceValidationDetailsRequest_inferenceId = md_QueryGetInferenceValidationDetailsRequest.Fields().ByName("inferenceId")
+	md_QueryAllInferenceTimeoutRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceTimeoutRequest")
+	fd_QueryAllInferenceTimeoutRequest_pagination = md_QueryAllInferenceTimeoutRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationDetailsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceTimeoutRequest)(nil)
 
-type fastReflection_QueryGetInferenceValidationDetailsRequest QueryGetInferenceValidationDetailsRequest
+type fastReflection_QueryAllInferenceTimeoutRequest QueryAllInferenceTimeoutRequest
 
-func (x *QueryGetInferenceValidationDetailsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationDetailsRequest)(x)
+func (x *QueryAllInferenceTimeoutRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceTimeoutRequest)(x)
 }
 
-func (x *QueryGetInferenceValidationDetailsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllInferenceTimeoutRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[61]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -29094,43 +28939,43 @@ func (x *QueryGetInferenceValidationDetailsRequest) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetInferenceValidationDetailsRequest_messageType fastReflection_QueryGetInferenceValidationDetailsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationDetailsRequest_messageType{}
+var _fastReflection_QueryAllInferenceTimeoutRequest_messageType fastReflection_QueryAllInferenceTimeoutRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceTimeoutRequest_messageType{}
 
-type fastReflection_QueryGetInferenceValidationDetailsRequest_messageType struct{}
+type fastReflection_QueryAllInferenceTimeoutRequest_messageType struct{}
 
-func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationDetailsRequest)(nil)
+func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceTimeoutRequest)(nil)
 }
-func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationDetailsRequest)
+func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceTimeoutRequest)
 }
-func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationDetailsRequest
+func (x fastReflection_QueryAllInferenceTimeoutRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceTimeoutRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationDetailsRequest
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceTimeoutRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetInferenceValidationDetailsRequest_messageType
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllInferenceTimeoutRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationDetailsRequest)
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceTimeoutRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetInferenceValidationDetailsRequest)(x)
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllInferenceTimeoutRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -29138,16 +28983,10 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochId != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochId)
-		if !f(fd_QueryGetInferenceValidationDetailsRequest_epochId, value) {
-			return
-		}
-	}
-	if x.InferenceId != "" {
-		value := protoreflect.ValueOfString(x.InferenceId)
-		if !f(fd_QueryGetInferenceValidationDetailsRequest_inferenceId, value) {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllInferenceTimeoutRequest_pagination, value) {
 			return
 		}
 	}
@@ -29164,17 +29003,15 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
-		return x.EpochId != uint64(0)
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
-		return x.InferenceId != ""
+	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29184,17 +29021,15 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
-		x.EpochId = uint64(0)
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
-		x.InferenceId = ""
+	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29204,19 +29039,16 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
-		value := x.EpochId
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
-		value := x.InferenceId
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -29230,17 +29062,15 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
-		x.EpochId = value.Uint()
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
-		x.InferenceId = value.Interface().(string)
+	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29254,44 +29084,44 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
-		panic(fmt.Errorf("field epochId of message inference.inference.QueryGetInferenceValidationDetailsRequest is not mutable"))
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
-		panic(fmt.Errorf("field inferenceId of message inference.inference.QueryGetInferenceValidationDetailsRequest is not mutable"))
-	default:
+	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllInferenceTimeoutRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationDetailsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceTimeoutRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -29299,7 +29129,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -29310,7 +29140,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -29322,7 +29152,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) IsValid() bool {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -29332,9 +29162,9 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllInferenceTimeoutRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
+		x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29346,11 +29176,8 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		if x.EpochId != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochId))
-		}
-		l = len(x.InferenceId)
-		if l > 0 {
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -29363,7 +29190,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
+		x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29382,17 +29209,19 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.InferenceId) > 0 {
-			i -= len(x.InferenceId)
-			copy(dAtA[i:], x.InferenceId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceId)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if x.EpochId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -29405,7 +29234,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
+		x := input.Message.Interface().(*QueryAllInferenceTimeoutRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29437,36 +29266,17 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
-				}
-				x.EpochId = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EpochId |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -29476,23 +29286,27 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.InferenceId = string(dAtA[iNdEx:postIndex])
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -29529,26 +29343,79 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods(
 	}
 }
 
+var _ protoreflect.List = (*_QueryAllInferenceTimeoutResponse_1_list)(nil)
+
+type _QueryAllInferenceTimeoutResponse_1_list struct {
+	list *[]*InferenceTimeout
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*InferenceTimeout)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*InferenceTimeout)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(InferenceTimeout)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) NewElement() protoreflect.Value {
+	v := new(InferenceTimeout)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllInferenceTimeoutResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetInferenceValidationDetailsResponse                            protoreflect.MessageDescriptor
-	fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails protoreflect.FieldDescriptor
+	md_QueryAllInferenceTimeoutResponse                   protoreflect.MessageDescriptor
+	fd_QueryAllInferenceTimeoutResponse_inference_timeout protoreflect.FieldDescriptor
+	fd_QueryAllInferenceTimeoutResponse_pagination        protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetInferenceValidationDetailsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationDetailsResponse")
-	fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails = md_QueryGetInferenceValidationDetailsResponse.Fields().ByName("inferenceValidationDetails")
+	md_QueryAllInferenceTimeoutResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceTimeoutResponse")
+	fd_QueryAllInferenceTimeoutResponse_inference_timeout = md_QueryAllInferenceTimeoutResponse.Fields().ByName("inference_timeout")
+	fd_QueryAllInferenceTimeoutResponse_pagination = md_QueryAllInferenceTimeoutResponse.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationDetailsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceTimeoutResponse)(nil)
 
-type fastReflection_QueryGetInferenceValidationDetailsResponse QueryGetInferenceValidationDetailsResponse
+type fastReflection_QueryAllInferenceTimeoutResponse QueryAllInferenceTimeoutResponse
 
-func (x *QueryGetInferenceValidationDetailsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationDetailsResponse)(x)
+func (x *QueryAllInferenceTimeoutResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceTimeoutResponse)(x)
 }
 
-func (x *QueryGetInferenceValidationDetailsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllInferenceTimeoutResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[62]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -29560,43 +29427,43 @@ func (x *QueryGetInferenceValidationDetailsResponse) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetInferenceValidationDetailsResponse_messageType fastReflection_QueryGetInferenceValidationDetailsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationDetailsResponse_messageType{}
+var _fastReflection_QueryAllInferenceTimeoutResponse_messageType fastReflection_QueryAllInferenceTimeoutResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceTimeoutResponse_messageType{}
 
-type fastReflection_QueryGetInferenceValidationDetailsResponse_messageType struct{}
+type fastReflection_QueryAllInferenceTimeoutResponse_messageType struct{}
 
-func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationDetailsResponse)(nil)
+func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceTimeoutResponse)(nil)
 }
-func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationDetailsResponse)
+func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceTimeoutResponse)
 }
-func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationDetailsResponse
+func (x fastReflection_QueryAllInferenceTimeoutResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceTimeoutResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationDetailsResponse
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceTimeoutResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetInferenceValidationDetailsResponse_messageType
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllInferenceTimeoutResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationDetailsResponse)
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceTimeoutResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetInferenceValidationDetailsResponse)(x)
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllInferenceTimeoutResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -29604,10 +29471,16 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.InferenceValidationDetails != nil {
-		value := protoreflect.ValueOfMessage(x.InferenceValidationDetails.ProtoReflect())
-		if !f(fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails, value) {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.InferenceTimeout) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllInferenceTimeoutResponse_1_list{list: &x.InferenceTimeout})
+		if !f(fd_QueryAllInferenceTimeoutResponse_inference_timeout, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllInferenceTimeoutResponse_pagination, value) {
 			return
 		}
 	}
@@ -29624,15 +29497,17 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
-		return x.InferenceValidationDetails != nil
+	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+		return len(x.InferenceTimeout) != 0
+	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29642,15 +29517,17 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
-		x.InferenceValidationDetails = nil
+	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+		x.InferenceTimeout = nil
+	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29660,16 +29537,22 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
-		value := x.InferenceValidationDetails
+	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+		if len(x.InferenceTimeout) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllInferenceTimeoutResponse_1_list{})
+		}
+		listValue := &_QueryAllInferenceTimeoutResponse_1_list{list: &x.InferenceTimeout}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
+		value := x.Pagination
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -29683,15 +29566,19 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
-		x.InferenceValidationDetails = value.Message().Interface().(*InferenceValidationDetails)
+	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+		lv := value.List()
+		clv := lv.(*_QueryAllInferenceTimeoutResponse_1_list)
+		x.InferenceTimeout = *clv.list
+	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29705,44 +29592,53 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
-		if x.InferenceValidationDetails == nil {
-			x.InferenceValidationDetails = new(InferenceValidationDetails)
+	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+		if x.InferenceTimeout == nil {
+			x.InferenceTimeout = []*InferenceTimeout{}
 		}
-		return protoreflect.ValueOfMessage(x.InferenceValidationDetails.ProtoReflect())
+		value := &_QueryAllInferenceTimeoutResponse_1_list{list: &x.InferenceTimeout}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
-		m := new(InferenceValidationDetails)
+	case "inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout":
+		list := []*InferenceTimeout{}
+		return protoreflect.ValueOfList(&_QueryAllInferenceTimeoutResponse_1_list{list: &list})
+	case "inference.inference.QueryAllInferenceTimeoutResponse.pagination":
+		m := new(v1beta1.PageResponse)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceTimeoutResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceTimeoutResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationDetailsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceTimeoutResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -29750,7 +29646,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -29761,7 +29657,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -29773,7 +29669,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) IsValid() bool {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -29783,9 +29679,9 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllInferenceTimeoutResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
+		x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29797,8 +29693,14 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 		var n int
 		var l int
 		_ = l
-		if x.InferenceValidationDetails != nil {
-			l = options.Size(x.InferenceValidationDetails)
+		if len(x.InferenceTimeout) > 0 {
+			for _, e := range x.InferenceTimeout {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -29811,7 +29713,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
+		x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29830,8 +29732,8 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.InferenceValidationDetails != nil {
-			encoded, err := options.Marshal(x.InferenceValidationDetails)
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29842,7 +29744,23 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if len(x.InferenceTimeout) > 0 {
+			for iNdEx := len(x.InferenceTimeout) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.InferenceTimeout[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -29855,7 +29773,7 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
+		x := input.Message.Interface().(*QueryAllInferenceTimeoutResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29887,15 +29805,15 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationDetails", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceTimeout", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -29922,10 +29840,44 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.InferenceValidationDetails == nil {
-					x.InferenceValidationDetails = &InferenceValidationDetails{}
+				x.InferenceTimeout = append(x.InferenceTimeout, &InferenceTimeout{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceTimeout[len(x.InferenceTimeout)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceValidationDetails); err != nil {
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -29965,25 +29917,27 @@ func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods
 }
 
 var (
-	md_QueryAllInferenceValidationDetailsRequest            protoreflect.MessageDescriptor
-	fd_QueryAllInferenceValidationDetailsRequest_pagination protoreflect.FieldDescriptor
+	md_QueryGetInferenceValidationDetailsRequest             protoreflect.MessageDescriptor
+	fd_QueryGetInferenceValidationDetailsRequest_epochId     protoreflect.FieldDescriptor
+	fd_QueryGetInferenceValidationDetailsRequest_inferenceId protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllInferenceValidationDetailsRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceValidationDetailsRequest")
-	fd_QueryAllInferenceValidationDetailsRequest_pagination = md_QueryAllInferenceValidationDetailsRequest.Fields().ByName("pagination")
+	md_QueryGetInferenceValidationDetailsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationDetailsRequest")
+	fd_QueryGetInferenceValidationDetailsRequest_epochId = md_QueryGetInferenceValidationDetailsRequest.Fields().ByName("epochId")
+	fd_QueryGetInferenceValidationDetailsRequest_inferenceId = md_QueryGetInferenceValidationDetailsRequest.Fields().ByName("inferenceId")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllInferenceValidationDetailsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationDetailsRequest)(nil)
 
-type fastReflection_QueryAllInferenceValidationDetailsRequest QueryAllInferenceValidationDetailsRequest
+type fastReflection_QueryGetInferenceValidationDetailsRequest QueryGetInferenceValidationDetailsRequest
 
-func (x *QueryAllInferenceValidationDetailsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceValidationDetailsRequest)(x)
+func (x *QueryGetInferenceValidationDetailsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationDetailsRequest)(x)
 }
 
-func (x *QueryAllInferenceValidationDetailsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetInferenceValidationDetailsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[63]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -29995,43 +29949,43 @@ func (x *QueryAllInferenceValidationDetailsRequest) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllInferenceValidationDetailsRequest_messageType fastReflection_QueryAllInferenceValidationDetailsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllInferenceValidationDetailsRequest_messageType{}
+var _fastReflection_QueryGetInferenceValidationDetailsRequest_messageType fastReflection_QueryGetInferenceValidationDetailsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationDetailsRequest_messageType{}
 
-type fastReflection_QueryAllInferenceValidationDetailsRequest_messageType struct{}
+type fastReflection_QueryGetInferenceValidationDetailsRequest_messageType struct{}
 
-func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceValidationDetailsRequest)(nil)
+func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationDetailsRequest)(nil)
 }
-func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceValidationDetailsRequest)
+func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationDetailsRequest)
 }
-func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceValidationDetailsRequest
+func (x fastReflection_QueryGetInferenceValidationDetailsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationDetailsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceValidationDetailsRequest
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationDetailsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllInferenceValidationDetailsRequest_messageType
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetInferenceValidationDetailsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceValidationDetailsRequest)
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationDetailsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllInferenceValidationDetailsRequest)(x)
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetInferenceValidationDetailsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -30039,10 +29993,16 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllInferenceValidationDetailsRequest_pagination, value) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochId)
+		if !f(fd_QueryGetInferenceValidationDetailsRequest_epochId, value) {
+			return
+		}
+	}
+	if x.InferenceId != "" {
+		value := protoreflect.ValueOfString(x.InferenceId)
+		if !f(fd_QueryGetInferenceValidationDetailsRequest_inferenceId, value) {
 			return
 		}
 	}
@@ -30059,15 +30019,17 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
+		return x.EpochId != uint64(0)
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
+		return x.InferenceId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30077,15 +30039,17 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
+		x.EpochId = uint64(0)
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
+		x.InferenceId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30095,16 +30059,19 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	default:
-		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
+		value := x.EpochId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
+		value := x.InferenceId
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -30118,15 +30085,17 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
+		x.EpochId = value.Uint()
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
+		x.InferenceId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30140,44 +30109,44 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
+		panic(fmt.Errorf("field epochId of message inference.inference.QueryGetInferenceValidationDetailsRequest is not mutable"))
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
+		panic(fmt.Errorf("field inferenceId of message inference.inference.QueryGetInferenceValidationDetailsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.epochId":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetInferenceValidationDetailsRequest.inferenceId":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceValidationDetailsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationDetailsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -30185,7 +30154,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -30196,7 +30165,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -30208,7 +30177,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) IsValid() bool {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -30218,9 +30187,9 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetInferenceValidationDetailsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
+		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30232,8 +30201,11 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.EpochId != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochId))
+		}
+		l = len(x.InferenceId)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -30246,7 +30218,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
+		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30265,19 +30237,17 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if len(x.InferenceId) > 0 {
+			i -= len(x.InferenceId)
+			copy(dAtA[i:], x.InferenceId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InferenceId)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if x.EpochId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -30290,7 +30260,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
+		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30322,17 +30292,36 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
+				}
+				x.EpochId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -30342,27 +30331,23 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.InferenceId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -30399,79 +30384,26 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods(
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllInferenceValidationDetailsResponse_1_list)(nil)
-
-type _QueryAllInferenceValidationDetailsResponse_1_list struct {
-	list *[]*InferenceValidationDetails
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*InferenceValidationDetails)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*InferenceValidationDetails)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(InferenceValidationDetails)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(InferenceValidationDetails)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllInferenceValidationDetailsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryAllInferenceValidationDetailsResponse                            protoreflect.MessageDescriptor
-	fd_QueryAllInferenceValidationDetailsResponse_inferenceValidationDetails protoreflect.FieldDescriptor
-	fd_QueryAllInferenceValidationDetailsResponse_pagination                 protoreflect.FieldDescriptor
+	md_QueryGetInferenceValidationDetailsResponse                            protoreflect.MessageDescriptor
+	fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllInferenceValidationDetailsResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceValidationDetailsResponse")
-	fd_QueryAllInferenceValidationDetailsResponse_inferenceValidationDetails = md_QueryAllInferenceValidationDetailsResponse.Fields().ByName("inferenceValidationDetails")
-	fd_QueryAllInferenceValidationDetailsResponse_pagination = md_QueryAllInferenceValidationDetailsResponse.Fields().ByName("pagination")
+	md_QueryGetInferenceValidationDetailsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationDetailsResponse")
+	fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails = md_QueryGetInferenceValidationDetailsResponse.Fields().ByName("inferenceValidationDetails")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllInferenceValidationDetailsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationDetailsResponse)(nil)
 
-type fastReflection_QueryAllInferenceValidationDetailsResponse QueryAllInferenceValidationDetailsResponse
+type fastReflection_QueryGetInferenceValidationDetailsResponse QueryGetInferenceValidationDetailsResponse
 
-func (x *QueryAllInferenceValidationDetailsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceValidationDetailsResponse)(x)
+func (x *QueryGetInferenceValidationDetailsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationDetailsResponse)(x)
 }
 
-func (x *QueryAllInferenceValidationDetailsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetInferenceValidationDetailsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[64]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -30483,43 +30415,43 @@ func (x *QueryAllInferenceValidationDetailsResponse) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllInferenceValidationDetailsResponse_messageType fastReflection_QueryAllInferenceValidationDetailsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllInferenceValidationDetailsResponse_messageType{}
+var _fastReflection_QueryGetInferenceValidationDetailsResponse_messageType fastReflection_QueryGetInferenceValidationDetailsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationDetailsResponse_messageType{}
 
-type fastReflection_QueryAllInferenceValidationDetailsResponse_messageType struct{}
+type fastReflection_QueryGetInferenceValidationDetailsResponse_messageType struct{}
 
-func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllInferenceValidationDetailsResponse)(nil)
+func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationDetailsResponse)(nil)
 }
-func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceValidationDetailsResponse)
+func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationDetailsResponse)
 }
-func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceValidationDetailsResponse
+func (x fastReflection_QueryGetInferenceValidationDetailsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationDetailsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllInferenceValidationDetailsResponse
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationDetailsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllInferenceValidationDetailsResponse_messageType
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetInferenceValidationDetailsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllInferenceValidationDetailsResponse)
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationDetailsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllInferenceValidationDetailsResponse)(x)
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetInferenceValidationDetailsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -30527,16 +30459,10 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.InferenceValidationDetails) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllInferenceValidationDetailsResponse_1_list{list: &x.InferenceValidationDetails})
-		if !f(fd_QueryAllInferenceValidationDetailsResponse_inferenceValidationDetails, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllInferenceValidationDetailsResponse_pagination, value) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.InferenceValidationDetails != nil {
+		value := protoreflect.ValueOfMessage(x.InferenceValidationDetails.ProtoReflect())
+		if !f(fd_QueryGetInferenceValidationDetailsResponse_inferenceValidationDetails, value) {
 			return
 		}
 	}
@@ -30553,17 +30479,15 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
-		return len(x.InferenceValidationDetails) != 0
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
+		return x.InferenceValidationDetails != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30573,17 +30497,15 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
+	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
 		x.InferenceValidationDetails = nil
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30593,22 +30515,16 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
-		if len(x.InferenceValidationDetails) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllInferenceValidationDetailsResponse_1_list{})
-		}
-		listValue := &_QueryAllInferenceValidationDetailsResponse_1_list{list: &x.InferenceValidationDetails}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
+		value := x.InferenceValidationDetails
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -30622,19 +30538,15 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
-		lv := value.List()
-		clv := lv.(*_QueryAllInferenceValidationDetailsResponse_1_list)
-		x.InferenceValidationDetails = *clv.list
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
+		x.InferenceValidationDetails = value.Message().Interface().(*InferenceValidationDetails)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30648,53 +30560,44 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
+	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
 		if x.InferenceValidationDetails == nil {
-			x.InferenceValidationDetails = []*InferenceValidationDetails{}
-		}
-		value := &_QueryAllInferenceValidationDetailsResponse_1_list{list: &x.InferenceValidationDetails}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
+			x.InferenceValidationDetails = new(InferenceValidationDetails)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.InferenceValidationDetails.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
-		list := []*InferenceValidationDetails{}
-		return protoreflect.ValueOfList(&_QueryAllInferenceValidationDetailsResponse_1_list{list: &list})
-	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
-		m := new(v1beta1.PageResponse)
+	case "inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails":
+		m := new(InferenceValidationDetails)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceValidationDetailsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationDetailsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -30702,7 +30605,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -30713,7 +30616,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -30725,7 +30628,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) IsValid() bool {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -30735,9 +30638,9 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetInferenceValidationDetailsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
+		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30749,14 +30652,8 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 		var n int
 		var l int
 		_ = l
-		if len(x.InferenceValidationDetails) > 0 {
-			for _, e := range x.InferenceValidationDetails {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.InferenceValidationDetails != nil {
+			l = options.Size(x.InferenceValidationDetails)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -30769,7 +30666,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
+		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30788,8 +30685,8 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.InferenceValidationDetails != nil {
+			encoded, err := options.Marshal(x.InferenceValidationDetails)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30800,23 +30697,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.InferenceValidationDetails) > 0 {
-			for iNdEx := len(x.InferenceValidationDetails) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.InferenceValidationDetails[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -30829,7 +30710,7 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
+		x := input.Message.Interface().(*QueryGetInferenceValidationDetailsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30861,10 +30742,10 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -30896,44 +30777,10 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.InferenceValidationDetails = append(x.InferenceValidationDetails, &InferenceValidationDetails{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceValidationDetails[len(x.InferenceValidationDetails)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
+				if x.InferenceValidationDetails == nil {
+					x.InferenceValidationDetails = &InferenceValidationDetails{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceValidationDetails); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -30972,74 +30819,26 @@ func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods
 	}
 }
 
-var _ protoreflect.List = (*_QueryGetInferenceValidationParametersRequest_1_list)(nil)
-
-type _QueryGetInferenceValidationParametersRequest_1_list struct {
-	list *[]string
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfString((*x.list)[i])
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message QueryGetInferenceValidationParametersRequest at list field Ids as it is not of Message kind"))
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) Truncate(n int) {
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) NewElement() protoreflect.Value {
-	v := ""
-	return protoreflect.ValueOfString(v)
-}
-
-func (x *_QueryGetInferenceValidationParametersRequest_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryGetInferenceValidationParametersRequest           protoreflect.MessageDescriptor
-	fd_QueryGetInferenceValidationParametersRequest_ids       protoreflect.FieldDescriptor
-	fd_QueryGetInferenceValidationParametersRequest_requester protoreflect.FieldDescriptor
+	md_QueryAllInferenceValidationDetailsRequest            protoreflect.MessageDescriptor
+	fd_QueryAllInferenceValidationDetailsRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetInferenceValidationParametersRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationParametersRequest")
-	fd_QueryGetInferenceValidationParametersRequest_ids = md_QueryGetInferenceValidationParametersRequest.Fields().ByName("ids")
-	fd_QueryGetInferenceValidationParametersRequest_requester = md_QueryGetInferenceValidationParametersRequest.Fields().ByName("requester")
+	md_QueryAllInferenceValidationDetailsRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceValidationDetailsRequest")
+	fd_QueryAllInferenceValidationDetailsRequest_pagination = md_QueryAllInferenceValidationDetailsRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationParametersRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceValidationDetailsRequest)(nil)
 
-type fastReflection_QueryGetInferenceValidationParametersRequest QueryGetInferenceValidationParametersRequest
+type fastReflection_QueryAllInferenceValidationDetailsRequest QueryAllInferenceValidationDetailsRequest
 
-func (x *QueryGetInferenceValidationParametersRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationParametersRequest)(x)
+func (x *QueryAllInferenceValidationDetailsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceValidationDetailsRequest)(x)
 }
 
-func (x *QueryGetInferenceValidationParametersRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllInferenceValidationDetailsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[65]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -31051,43 +30850,43 @@ func (x *QueryGetInferenceValidationParametersRequest) slowProtoReflect() protor
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetInferenceValidationParametersRequest_messageType fastReflection_QueryGetInferenceValidationParametersRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationParametersRequest_messageType{}
+var _fastReflection_QueryAllInferenceValidationDetailsRequest_messageType fastReflection_QueryAllInferenceValidationDetailsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceValidationDetailsRequest_messageType{}
 
-type fastReflection_QueryGetInferenceValidationParametersRequest_messageType struct{}
+type fastReflection_QueryAllInferenceValidationDetailsRequest_messageType struct{}
 
-func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationParametersRequest)(nil)
+func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceValidationDetailsRequest)(nil)
 }
-func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationParametersRequest)
+func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceValidationDetailsRequest)
 }
-func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationParametersRequest
+func (x fastReflection_QueryAllInferenceValidationDetailsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceValidationDetailsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationParametersRequest
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceValidationDetailsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetInferenceValidationParametersRequest_messageType
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllInferenceValidationDetailsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationParametersRequest)
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceValidationDetailsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetInferenceValidationParametersRequest)(x)
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllInferenceValidationDetailsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -31095,16 +30894,10 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Interface(
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Ids) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersRequest_1_list{list: &x.Ids})
-		if !f(fd_QueryGetInferenceValidationParametersRequest_ids, value) {
-			return
-		}
-	}
-	if x.Requester != "" {
-		value := protoreflect.ValueOfString(x.Requester)
-		if !f(fd_QueryGetInferenceValidationParametersRequest_requester, value) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllInferenceValidationDetailsRequest_pagination, value) {
 			return
 		}
 	}
@@ -31121,17 +30914,15 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Range(f fu
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
-		return len(x.Ids) != 0
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
-		return x.Requester != ""
+	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31141,17 +30932,15 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Has(fd pro
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
-		x.Ids = nil
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
-		x.Requester = ""
+	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31161,22 +30950,16 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Clear(fd p
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
-		if len(x.Ids) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersRequest_1_list{})
-		}
-		listValue := &_QueryGetInferenceValidationParametersRequest_1_list{list: &x.Ids}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
-		value := x.Requester
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -31190,19 +30973,15 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Get(descri
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
-		lv := value.List()
-		clv := lv.(*_QueryGetInferenceValidationParametersRequest_1_list)
-		x.Ids = *clv.list
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
-		x.Requester = value.Interface().(string)
+	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31216,49 +30995,44 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Set(fd pro
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
-		if x.Ids == nil {
-			x.Ids = []string{}
+	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
 		}
-		value := &_QueryGetInferenceValidationParametersRequest_1_list{list: &x.Ids}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
-		panic(fmt.Errorf("field requester of message inference.inference.QueryGetInferenceValidationParametersRequest is not mutable"))
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
-		list := []string{}
-		return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersRequest_1_list{list: &list})
-	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllInferenceValidationDetailsRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationParametersRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceValidationDetailsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -31266,7 +31040,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) WhichOneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -31277,7 +31051,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) GetUnknown
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -31289,7 +31063,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) SetUnknown
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) IsValid() bool {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -31299,9 +31073,9 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) IsValid()
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllInferenceValidationDetailsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
+		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31313,14 +31087,8 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 		var n int
 		var l int
 		_ = l
-		if len(x.Ids) > 0 {
-			for _, s := range x.Ids {
-				l = len(s)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		l = len(x.Requester)
-		if l > 0 {
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -31333,7 +31101,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
+		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31352,21 +31120,19 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Requester) > 0 {
-			i -= len(x.Requester)
-			copy(dAtA[i:], x.Requester)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Requester)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Ids) > 0 {
-			for iNdEx := len(x.Ids) - 1; iNdEx >= 0; iNdEx-- {
-				i -= len(x.Ids[iNdEx])
-				copy(dAtA[i:], x.Ids[iNdEx])
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Ids[iNdEx])))
-				i--
-				dAtA[i] = 0xa
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
 			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -31379,7 +31145,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
+		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31411,17 +31177,17 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -31431,55 +31197,27 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Ids = append(x.Ids, string(dAtA[iNdEx:postIndex]))
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
 				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				x.Requester = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -31516,134 +31254,79 @@ func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMetho
 	}
 }
 
-var _ protoreflect.List = (*_QueryGetInferenceValidationParametersResponse_1_list)(nil)
-
-type _QueryGetInferenceValidationParametersResponse_1_list struct {
-	list *[]*ValidatorPower
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ValidatorPower)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ValidatorPower)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ValidatorPower)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ValidatorPower)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGetInferenceValidationParametersResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var _ protoreflect.List = (*_QueryGetInferenceValidationParametersResponse_3_list)(nil)
+var _ protoreflect.List = (*_QueryAllInferenceValidationDetailsResponse_1_list)(nil)
 
-type _QueryGetInferenceValidationParametersResponse_3_list struct {
+type _QueryAllInferenceValidationDetailsResponse_1_list struct {
 	list *[]*InferenceValidationDetails
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) Len() int {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) Get(i int) protoreflect.Value {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
 	concreteValue := valueUnwrapped.Interface().(*InferenceValidationDetails)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) Append(value protoreflect.Value) {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
 	concreteValue := valueUnwrapped.Interface().(*InferenceValidationDetails)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) AppendMutable() protoreflect.Value {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) AppendMutable() protoreflect.Value {
 	v := new(InferenceValidationDetails)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) Truncate(n int) {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) NewElement() protoreflect.Value {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) NewElement() protoreflect.Value {
 	v := new(InferenceValidationDetails)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryGetInferenceValidationParametersResponse_3_list) IsValid() bool {
+func (x *_QueryAllInferenceValidationDetailsResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryGetInferenceValidationParametersResponse                  protoreflect.MessageDescriptor
-	fd_QueryGetInferenceValidationParametersResponse_validator_powers protoreflect.FieldDescriptor
-	fd_QueryGetInferenceValidationParametersResponse_current_height   protoreflect.FieldDescriptor
-	fd_QueryGetInferenceValidationParametersResponse_details          protoreflect.FieldDescriptor
-	fd_QueryGetInferenceValidationParametersResponse_parameters       protoreflect.FieldDescriptor
+	md_QueryAllInferenceValidationDetailsResponse                            protoreflect.MessageDescriptor
+	fd_QueryAllInferenceValidationDetailsResponse_inferenceValidationDetails protoreflect.FieldDescriptor
+	fd_QueryAllInferenceValidationDetailsResponse_pagination                 protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetInferenceValidationParametersResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationParametersResponse")
-	fd_QueryGetInferenceValidationParametersResponse_validator_powers = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("validator_powers")
-	fd_QueryGetInferenceValidationParametersResponse_current_height = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("current_height")
-	fd_QueryGetInferenceValidationParametersResponse_details = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("details")
-	fd_QueryGetInferenceValidationParametersResponse_parameters = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("parameters")
+	md_QueryAllInferenceValidationDetailsResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllInferenceValidationDetailsResponse")
+	fd_QueryAllInferenceValidationDetailsResponse_inferenceValidationDetails = md_QueryAllInferenceValidationDetailsResponse.Fields().ByName("inferenceValidationDetails")
+	fd_QueryAllInferenceValidationDetailsResponse_pagination = md_QueryAllInferenceValidationDetailsResponse.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationParametersResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllInferenceValidationDetailsResponse)(nil)
 
-type fastReflection_QueryGetInferenceValidationParametersResponse QueryGetInferenceValidationParametersResponse
+type fastReflection_QueryAllInferenceValidationDetailsResponse QueryAllInferenceValidationDetailsResponse
 
-func (x *QueryGetInferenceValidationParametersResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationParametersResponse)(x)
+func (x *QueryAllInferenceValidationDetailsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceValidationDetailsResponse)(x)
 }
 
-func (x *QueryGetInferenceValidationParametersResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllInferenceValidationDetailsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[66]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -31655,43 +31338,43 @@ func (x *QueryGetInferenceValidationParametersResponse) slowProtoReflect() proto
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetInferenceValidationParametersResponse_messageType fastReflection_QueryGetInferenceValidationParametersResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationParametersResponse_messageType{}
+var _fastReflection_QueryAllInferenceValidationDetailsResponse_messageType fastReflection_QueryAllInferenceValidationDetailsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllInferenceValidationDetailsResponse_messageType{}
 
-type fastReflection_QueryGetInferenceValidationParametersResponse_messageType struct{}
+type fastReflection_QueryAllInferenceValidationDetailsResponse_messageType struct{}
 
-func (x fastReflection_QueryGetInferenceValidationParametersResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetInferenceValidationParametersResponse)(nil)
+func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllInferenceValidationDetailsResponse)(nil)
 }
-func (x fastReflection_QueryGetInferenceValidationParametersResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationParametersResponse)
+func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceValidationDetailsResponse)
 }
-func (x fastReflection_QueryGetInferenceValidationParametersResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationParametersResponse
+func (x fastReflection_QueryAllInferenceValidationDetailsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceValidationDetailsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetInferenceValidationParametersResponse
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllInferenceValidationDetailsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetInferenceValidationParametersResponse_messageType
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllInferenceValidationDetailsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetInferenceValidationParametersResponse)
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllInferenceValidationDetailsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetInferenceValidationParametersResponse)(x)
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllInferenceValidationDetailsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -31699,28 +31382,16 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Interface
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.ValidatorPowers) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_1_list{list: &x.ValidatorPowers})
-		if !f(fd_QueryGetInferenceValidationParametersResponse_validator_powers, value) {
-			return
-		}
-	}
-	if x.CurrentHeight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.CurrentHeight)
-		if !f(fd_QueryGetInferenceValidationParametersResponse_current_height, value) {
-			return
-		}
-	}
-	if len(x.Details) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_3_list{list: &x.Details})
-		if !f(fd_QueryGetInferenceValidationParametersResponse_details, value) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.InferenceValidationDetails) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllInferenceValidationDetailsResponse_1_list{list: &x.InferenceValidationDetails})
+		if !f(fd_QueryAllInferenceValidationDetailsResponse_inferenceValidationDetails, value) {
 			return
 		}
 	}
-	if x.Parameters != nil {
-		value := protoreflect.ValueOfMessage(x.Parameters.ProtoReflect())
-		if !f(fd_QueryGetInferenceValidationParametersResponse_parameters, value) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllInferenceValidationDetailsResponse_pagination, value) {
 			return
 		}
 	}
@@ -31737,21 +31408,17 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Range(f f
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
-		return len(x.ValidatorPowers) != 0
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
-		return x.CurrentHeight != uint64(0)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
-		return len(x.Details) != 0
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
-		return x.Parameters != nil
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
+		return len(x.InferenceValidationDetails) != 0
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31761,21 +31428,17 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Has(fd pr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
-		x.ValidatorPowers = nil
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
-		x.CurrentHeight = uint64(0)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
-		x.Details = nil
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
-		x.Parameters = nil
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
+		x.InferenceValidationDetails = nil
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31785,31 +31448,22 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Clear(fd
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
-		if len(x.ValidatorPowers) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_1_list{})
-		}
-		listValue := &_QueryGetInferenceValidationParametersResponse_1_list{list: &x.ValidatorPowers}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
-		value := x.CurrentHeight
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
-		if len(x.Details) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_3_list{})
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
+		if len(x.InferenceValidationDetails) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllInferenceValidationDetailsResponse_1_list{})
 		}
-		listValue := &_QueryGetInferenceValidationParametersResponse_3_list{list: &x.Details}
+		listValue := &_QueryAllInferenceValidationDetailsResponse_1_list{list: &x.InferenceValidationDetails}
 		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
-		value := x.Parameters
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
+		value := x.Pagination
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -31823,25 +31477,19 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Get(descr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
-		lv := value.List()
-		clv := lv.(*_QueryGetInferenceValidationParametersResponse_1_list)
-		x.ValidatorPowers = *clv.list
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
-		x.CurrentHeight = value.Uint()
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
 		lv := value.List()
-		clv := lv.(*_QueryGetInferenceValidationParametersResponse_3_list)
-		x.Details = *clv.list
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
-		x.Parameters = value.Message().Interface().(*ValidationParams)
+		clv := lv.(*_QueryAllInferenceValidationDetailsResponse_1_list)
+		x.InferenceValidationDetails = *clv.list
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31855,66 +31503,53 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Set(fd pr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
-		if x.ValidatorPowers == nil {
-			x.ValidatorPowers = []*ValidatorPower{}
-		}
-		value := &_QueryGetInferenceValidationParametersResponse_1_list{list: &x.ValidatorPowers}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
-		if x.Details == nil {
-			x.Details = []*InferenceValidationDetails{}
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
+		if x.InferenceValidationDetails == nil {
+			x.InferenceValidationDetails = []*InferenceValidationDetails{}
 		}
-		value := &_QueryGetInferenceValidationParametersResponse_3_list{list: &x.Details}
+		value := &_QueryAllInferenceValidationDetailsResponse_1_list{list: &x.InferenceValidationDetails}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
-		if x.Parameters == nil {
-			x.Parameters = new(ValidationParams)
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
 		}
-		return protoreflect.ValueOfMessage(x.Parameters.ProtoReflect())
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
-		panic(fmt.Errorf("field current_height of message inference.inference.QueryGetInferenceValidationParametersResponse is not mutable"))
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
-		list := []*ValidatorPower{}
-		return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_1_list{list: &list})
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails":
 		list := []*InferenceValidationDetails{}
-		return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_3_list{list: &list})
-	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
-		m := new(ValidationParams)
+		return protoreflect.ValueOfList(&_QueryAllInferenceValidationDetailsResponse_1_list{list: &list})
+	case "inference.inference.QueryAllInferenceValidationDetailsResponse.pagination":
+		m := new(v1beta1.PageResponse)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllInferenceValidationDetailsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllInferenceValidationDetailsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationParametersResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllInferenceValidationDetailsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -31922,7 +31557,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) WhichOneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -31933,7 +31568,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) GetUnknow
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -31945,7 +31580,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) SetUnknow
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) IsValid() bool {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -31955,9 +31590,9 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) IsValid()
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllInferenceValidationDetailsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
+		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31969,23 +31604,14 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 		var n int
 		var l int
 		_ = l
-		if len(x.ValidatorPowers) > 0 {
-			for _, e := range x.ValidatorPowers {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.CurrentHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.CurrentHeight))
-		}
-		if len(x.Details) > 0 {
-			for _, e := range x.Details {
+		if len(x.InferenceValidationDetails) > 0 {
+			for _, e := range x.InferenceValidationDetails {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
 		}
-		if x.Parameters != nil {
-			l = options.Size(x.Parameters)
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -31998,7 +31624,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
+		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32017,8 +31643,8 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Parameters != nil {
-			encoded, err := options.Marshal(x.Parameters)
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32029,32 +31655,11 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.Details) > 0 {
-			for iNdEx := len(x.Details) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Details[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x1a
-			}
-		}
-		if x.CurrentHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentHeight))
-			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x12
 		}
-		if len(x.ValidatorPowers) > 0 {
-			for iNdEx := len(x.ValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.ValidatorPowers[iNdEx])
+		if len(x.InferenceValidationDetails) > 0 {
+			for iNdEx := len(x.InferenceValidationDetails) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.InferenceValidationDetails[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32079,7 +31684,7 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
+		x := input.Message.Interface().(*QueryAllInferenceValidationDetailsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32111,15 +31716,15 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorPowers", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationDetails", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -32146,67 +31751,14 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ValidatorPowers = append(x.ValidatorPowers, &ValidatorPower{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidatorPowers[len(x.ValidatorPowers)-1]); err != nil {
+				x.InferenceValidationDetails = append(x.InferenceValidationDetails, &InferenceValidationDetails{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.InferenceValidationDetails[len(x.InferenceValidationDetails)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentHeight", wireType)
-				}
-				x.CurrentHeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.CurrentHeight |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Details = append(x.Details, &InferenceValidationDetails{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Details[len(x.Details)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 4:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -32233,10 +31785,10 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Parameters == nil {
-					x.Parameters = &ValidationParams{}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Parameters); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -32275,28 +31827,74 @@ func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMeth
 	}
 }
 
+var _ protoreflect.List = (*_QueryGetInferenceValidationParametersRequest_1_list)(nil)
+
+type _QueryGetInferenceValidationParametersRequest_1_list struct {
+	list *[]string
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message QueryGetInferenceValidationParametersRequest at list field Ids as it is not of Message kind"))
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_QueryGetInferenceValidationParametersRequest_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_ValidatorPower             protoreflect.MessageDescriptor
-	fd_ValidatorPower_power       protoreflect.FieldDescriptor
-	fd_ValidatorPower_epoch_index protoreflect.FieldDescriptor
+	md_QueryGetInferenceValidationParametersRequest           protoreflect.MessageDescriptor
+	fd_QueryGetInferenceValidationParametersRequest_ids       protoreflect.FieldDescriptor
+	fd_QueryGetInferenceValidationParametersRequest_requester protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ValidatorPower = File_inference_inference_query_proto.Messages().ByName("ValidatorPower")
-	fd_ValidatorPower_power = md_ValidatorPower.Fields().ByName("power")
-	fd_ValidatorPower_epoch_index = md_ValidatorPower.Fields().ByName("epoch_index")
+	md_QueryGetInferenceValidationParametersRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationParametersRequest")
+	fd_QueryGetInferenceValidationParametersRequest_ids = md_QueryGetInferenceValidationParametersRequest.Fields().ByName("ids")
+	fd_QueryGetInferenceValidationParametersRequest_requester = md_QueryGetInferenceValidationParametersRequest.Fields().ByName("requester")
 }
 
-var _ protoreflect.Message = (*fastReflection_ValidatorPower)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationParametersRequest)(nil)
 
-type fastReflection_ValidatorPower ValidatorPower
+type fastReflection_QueryGetInferenceValidationParametersRequest QueryGetInferenceValidationParametersRequest
 
-func (x *ValidatorPower) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ValidatorPower)(x)
+func (x *QueryGetInferenceValidationParametersRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationParametersRequest)(x)
 }
 
-func (x *ValidatorPower) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetInferenceValidationParametersRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[67]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -32308,43 +31906,43 @@ func (x *ValidatorPower) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ValidatorPower_messageType fastReflection_ValidatorPower_messageType
-var _ protoreflect.MessageType = fastReflection_ValidatorPower_messageType{}
+var _fastReflection_QueryGetInferenceValidationParametersRequest_messageType fastReflection_QueryGetInferenceValidationParametersRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationParametersRequest_messageType{}
 
-type fastReflection_ValidatorPower_messageType struct{}
+type fastReflection_QueryGetInferenceValidationParametersRequest_messageType struct{}
 
-func (x fastReflection_ValidatorPower_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ValidatorPower)(nil)
+func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationParametersRequest)(nil)
 }
-func (x fastReflection_ValidatorPower_messageType) New() protoreflect.Message {
-	return new(fastReflection_ValidatorPower)
+func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationParametersRequest)
 }
-func (x fastReflection_ValidatorPower_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ValidatorPower
+func (x fastReflection_QueryGetInferenceValidationParametersRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationParametersRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ValidatorPower) Descriptor() protoreflect.MessageDescriptor {
-	return md_ValidatorPower
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationParametersRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ValidatorPower) Type() protoreflect.MessageType {
-	return _fastReflection_ValidatorPower_messageType
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetInferenceValidationParametersRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ValidatorPower) New() protoreflect.Message {
-	return new(fastReflection_ValidatorPower)
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationParametersRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ValidatorPower) Interface() protoreflect.ProtoMessage {
-	return (*ValidatorPower)(x)
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetInferenceValidationParametersRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -32352,16 +31950,16 @@ func (x *fastReflection_ValidatorPower) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ValidatorPower) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Power != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Power)
-		if !f(fd_ValidatorPower_power, value) {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Ids) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersRequest_1_list{list: &x.Ids})
+		if !f(fd_QueryGetInferenceValidationParametersRequest_ids, value) {
 			return
 		}
 	}
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_ValidatorPower_epoch_index, value) {
+	if x.Requester != "" {
+		value := protoreflect.ValueOfString(x.Requester)
+		if !f(fd_QueryGetInferenceValidationParametersRequest_requester, value) {
 			return
 		}
 	}
@@ -32378,17 +31976,17 @@ func (x *fastReflection_ValidatorPower) Range(f func(protoreflect.FieldDescripto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ValidatorPower) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ValidatorPower.power":
-		return x.Power != uint64(0)
-	case "inference.inference.ValidatorPower.epoch_index":
-		return x.EpochIndex != uint64(0)
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
+		return len(x.Ids) != 0
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
+		return x.Requester != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32398,17 +31996,17 @@ func (x *fastReflection_ValidatorPower) Has(fd protoreflect.FieldDescriptor) boo
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ValidatorPower) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ValidatorPower.power":
-		x.Power = uint64(0)
-	case "inference.inference.ValidatorPower.epoch_index":
-		x.EpochIndex = uint64(0)
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
+		x.Ids = nil
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
+		x.Requester = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32418,19 +32016,22 @@ func (x *fastReflection_ValidatorPower) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ValidatorPower) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ValidatorPower.power":
-		value := x.Power
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.ValidatorPower.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
+		if len(x.Ids) == 0 {
+			return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersRequest_1_list{})
+		}
+		listValue := &_QueryGetInferenceValidationParametersRequest_1_list{list: &x.Ids}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
+		value := x.Requester
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -32444,17 +32045,19 @@ func (x *fastReflection_ValidatorPower) Get(descriptor protoreflect.FieldDescrip
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ValidatorPower) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ValidatorPower.power":
-		x.Power = value.Uint()
-	case "inference.inference.ValidatorPower.epoch_index":
-		x.EpochIndex = value.Uint()
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
+		lv := value.List()
+		clv := lv.(*_QueryGetInferenceValidationParametersRequest_1_list)
+		x.Ids = *clv.list
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
+		x.Requester = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32468,44 +32071,49 @@ func (x *fastReflection_ValidatorPower) Set(fd protoreflect.FieldDescriptor, val
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ValidatorPower) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ValidatorPower.power":
-		panic(fmt.Errorf("field power of message inference.inference.ValidatorPower is not mutable"))
-	case "inference.inference.ValidatorPower.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.ValidatorPower is not mutable"))
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
+		if x.Ids == nil {
+			x.Ids = []string{}
+		}
+		value := &_QueryGetInferenceValidationParametersRequest_1_list{list: &x.Ids}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
+		panic(fmt.Errorf("field requester of message inference.inference.QueryGetInferenceValidationParametersRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ValidatorPower) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ValidatorPower.power":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.ValidatorPower.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.ids":
+		list := []string{}
+		return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersRequest_1_list{list: &list})
+	case "inference.inference.QueryGetInferenceValidationParametersRequest.requester":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ValidatorPower) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ValidatorPower", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationParametersRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -32513,7 +32121,7 @@ func (x *fastReflection_ValidatorPower) WhichOneof(d protoreflect.OneofDescripto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ValidatorPower) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -32524,7 +32132,7 @@ func (x *fastReflection_ValidatorPower) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ValidatorPower) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -32536,7 +32144,7 @@ func (x *fastReflection_ValidatorPower) SetUnknown(fields protoreflect.RawFields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ValidatorPower) IsValid() bool {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -32546,9 +32154,9 @@ func (x *fastReflection_ValidatorPower) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetInferenceValidationParametersRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ValidatorPower)
+		x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32560,11 +32168,15 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		if x.Power != 0 {
-			n += 1 + runtime.Sov(uint64(x.Power))
+		if len(x.Ids) > 0 {
+			for _, s := range x.Ids {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		l = len(x.Requester)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -32576,7 +32188,7 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ValidatorPower)
+		x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32595,15 +32207,21 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+		if len(x.Requester) > 0 {
+			i -= len(x.Requester)
+			copy(dAtA[i:], x.Requester)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Requester)))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x12
 		}
-		if x.Power != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Power))
-			i--
-			dAtA[i] = 0x8
+		if len(x.Ids) > 0 {
+			for iNdEx := len(x.Ids) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.Ids[iNdEx])
+				copy(dAtA[i:], x.Ids[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Ids[iNdEx])))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -32616,7 +32234,7 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ValidatorPower)
+		x := input.Message.Interface().(*QueryGetInferenceValidationParametersRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32648,17 +32266,17 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPower: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
 				}
-				x.Power = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -32668,16 +32286,29 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Power |= uint64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Ids = append(x.Ids, string(dAtA[iNdEx:postIndex]))
+				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
 				}
-				x.EpochIndex = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -32687,11 +32318,24 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Requester = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -32727,74 +32371,182 @@ func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 	}
 }
 
-var (
-	md_QueryEpochPerformanceSummaryByEpochRequest             protoreflect.MessageDescriptor
-	fd_QueryEpochPerformanceSummaryByEpochRequest_epoch_index protoreflect.FieldDescriptor
-)
-
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryEpochPerformanceSummaryByEpochRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByEpochRequest")
-	fd_QueryEpochPerformanceSummaryByEpochRequest_epoch_index = md_QueryEpochPerformanceSummaryByEpochRequest.Fields().ByName("epoch_index")
-}
-
-var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByEpochRequest)(nil)
-
-type fastReflection_QueryEpochPerformanceSummaryByEpochRequest QueryEpochPerformanceSummaryByEpochRequest
+var _ protoreflect.List = (*_QueryGetInferenceValidationParametersResponse_1_list)(nil)
 
-func (x *QueryEpochPerformanceSummaryByEpochRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByEpochRequest)(x)
+type _QueryGetInferenceValidationParametersResponse_1_list struct {
+	list *[]*ValidatorPower
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochRequest) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[68]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
 	}
-	return mi.MessageOf(x)
+	return len(*x.list)
 }
 
-var _fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType{}
-
-type fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType struct{}
-
-func (x fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByEpochRequest)(nil)
-}
-func (x fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByEpochRequest)
-}
-func (x fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByEpochRequest
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-// Descriptor returns message descriptor, which contains only the protobuf
-// type information for the message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByEpochRequest
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ValidatorPower)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ValidatorPower)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ValidatorPower)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ValidatorPower)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_QueryGetInferenceValidationParametersResponse_3_list)(nil)
+
+type _QueryGetInferenceValidationParametersResponse_3_list struct {
+	list *[]*InferenceValidationDetails
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*InferenceValidationDetails)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*InferenceValidationDetails)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) AppendMutable() protoreflect.Value {
+	v := new(InferenceValidationDetails)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) NewElement() protoreflect.Value {
+	v := new(InferenceValidationDetails)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetInferenceValidationParametersResponse_3_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryGetInferenceValidationParametersResponse                  protoreflect.MessageDescriptor
+	fd_QueryGetInferenceValidationParametersResponse_validator_powers protoreflect.FieldDescriptor
+	fd_QueryGetInferenceValidationParametersResponse_current_height   protoreflect.FieldDescriptor
+	fd_QueryGetInferenceValidationParametersResponse_details          protoreflect.FieldDescriptor
+	fd_QueryGetInferenceValidationParametersResponse_parameters       protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetInferenceValidationParametersResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetInferenceValidationParametersResponse")
+	fd_QueryGetInferenceValidationParametersResponse_validator_powers = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("validator_powers")
+	fd_QueryGetInferenceValidationParametersResponse_current_height = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("current_height")
+	fd_QueryGetInferenceValidationParametersResponse_details = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("details")
+	fd_QueryGetInferenceValidationParametersResponse_parameters = md_QueryGetInferenceValidationParametersResponse.Fields().ByName("parameters")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetInferenceValidationParametersResponse)(nil)
+
+type fastReflection_QueryGetInferenceValidationParametersResponse QueryGetInferenceValidationParametersResponse
+
+func (x *QueryGetInferenceValidationParametersResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationParametersResponse)(x)
+}
+
+func (x *QueryGetInferenceValidationParametersResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[68]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetInferenceValidationParametersResponse_messageType fastReflection_QueryGetInferenceValidationParametersResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetInferenceValidationParametersResponse_messageType{}
+
+type fastReflection_QueryGetInferenceValidationParametersResponse_messageType struct{}
+
+func (x fastReflection_QueryGetInferenceValidationParametersResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetInferenceValidationParametersResponse)(nil)
+}
+func (x fastReflection_QueryGetInferenceValidationParametersResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationParametersResponse)
+}
+func (x fastReflection_QueryGetInferenceValidationParametersResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationParametersResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetInferenceValidationParametersResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetInferenceValidationParametersResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByEpochRequest)
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetInferenceValidationParametersResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryEpochPerformanceSummaryByEpochRequest)(x)
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetInferenceValidationParametersResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -32802,10 +32554,28 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryEpochPerformanceSummaryByEpochRequest_epoch_index, value) {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.ValidatorPowers) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_1_list{list: &x.ValidatorPowers})
+		if !f(fd_QueryGetInferenceValidationParametersResponse_validator_powers, value) {
+			return
+		}
+	}
+	if x.CurrentHeight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.CurrentHeight)
+		if !f(fd_QueryGetInferenceValidationParametersResponse_current_height, value) {
+			return
+		}
+	}
+	if len(x.Details) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_3_list{list: &x.Details})
+		if !f(fd_QueryGetInferenceValidationParametersResponse_details, value) {
+			return
+		}
+	}
+	if x.Parameters != nil {
+		value := protoreflect.ValueOfMessage(x.Parameters.ProtoReflect())
+		if !f(fd_QueryGetInferenceValidationParametersResponse_parameters, value) {
 			return
 		}
 	}
@@ -32822,15 +32592,21 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
-		return x.EpochIndex != uint64(0)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
+		return len(x.ValidatorPowers) != 0
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
+		return x.CurrentHeight != uint64(0)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+		return len(x.Details) != 0
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
+		return x.Parameters != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32840,15 +32616,21 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
-		x.EpochIndex = uint64(0)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
+		x.ValidatorPowers = nil
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
+		x.CurrentHeight = uint64(0)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+		x.Details = nil
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
+		x.Parameters = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32858,16 +32640,31 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
-		value := x.EpochIndex
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
+		if len(x.ValidatorPowers) == 0 {
+			return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_1_list{})
+		}
+		listValue := &_QueryGetInferenceValidationParametersResponse_1_list{list: &x.ValidatorPowers}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
+		value := x.CurrentHeight
 		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+		if len(x.Details) == 0 {
+			return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_3_list{})
+		}
+		listValue := &_QueryGetInferenceValidationParametersResponse_3_list{list: &x.Details}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
+		value := x.Parameters
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -32881,15 +32678,25 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
-		x.EpochIndex = value.Uint()
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
+		lv := value.List()
+		clv := lv.(*_QueryGetInferenceValidationParametersResponse_1_list)
+		x.ValidatorPowers = *clv.list
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
+		x.CurrentHeight = value.Uint()
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+		lv := value.List()
+		clv := lv.(*_QueryGetInferenceValidationParametersResponse_3_list)
+		x.Details = *clv.list
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
+		x.Parameters = value.Message().Interface().(*ValidationParams)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32903,40 +32710,66 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryEpochPerformanceSummaryByEpochRequest is not mutable"))
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
+		if x.ValidatorPowers == nil {
+			x.ValidatorPowers = []*ValidatorPower{}
+		}
+		value := &_QueryGetInferenceValidationParametersResponse_1_list{list: &x.ValidatorPowers}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+		if x.Details == nil {
+			x.Details = []*InferenceValidationDetails{}
+		}
+		value := &_QueryGetInferenceValidationParametersResponse_3_list{list: &x.Details}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
+		if x.Parameters == nil {
+			x.Parameters = new(ValidationParams)
+		}
+		return protoreflect.ValueOfMessage(x.Parameters.ProtoReflect())
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
+		panic(fmt.Errorf("field current_height of message inference.inference.QueryGetInferenceValidationParametersResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers":
+		list := []*ValidatorPower{}
+		return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_1_list{list: &list})
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.current_height":
 		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.details":
+		list := []*InferenceValidationDetails{}
+		return protoreflect.ValueOfList(&_QueryGetInferenceValidationParametersResponse_3_list{list: &list})
+	case "inference.inference.QueryGetInferenceValidationParametersResponse.parameters":
+		m := new(ValidationParams)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetInferenceValidationParametersResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetInferenceValidationParametersResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByEpochRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetInferenceValidationParametersResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -32944,7 +32777,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -32955,7 +32788,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -32967,7 +32800,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) IsValid() bool {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -32977,9 +32810,9 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetInferenceValidationParametersResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochRequest)
+		x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32991,8 +32824,24 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 		var n int
 		var l int
 		_ = l
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		if len(x.ValidatorPowers) > 0 {
+			for _, e := range x.ValidatorPowers {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.CurrentHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.CurrentHeight))
+		}
+		if len(x.Details) > 0 {
+			for _, e := range x.Details {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Parameters != nil {
+			l = options.Size(x.Parameters)
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -33004,7 +32853,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochRequest)
+		x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33023,10 +32872,56 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+		if x.Parameters != nil {
+			encoded, err := options.Marshal(x.Parameters)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0x22
+		}
+		if len(x.Details) > 0 {
+			for iNdEx := len(x.Details) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Details[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x1a
+			}
+		}
+		if x.CurrentHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CurrentHeight))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.ValidatorPowers) > 0 {
+			for iNdEx := len(x.ValidatorPowers) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.ValidatorPowers[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -33039,7 +32934,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochRequest)
+		x := input.Message.Interface().(*QueryGetInferenceValidationParametersResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33071,17 +32966,51 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorPowers", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ValidatorPowers = append(x.ValidatorPowers, &ValidatorPower{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidatorPowers[len(x.ValidatorPowers)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CurrentHeight", wireType)
 				}
-				x.EpochIndex = 0
+				x.CurrentHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -33091,11 +33020,81 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
+					x.CurrentHeight |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Details = append(x.Details, &InferenceValidationDetails{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Details[len(x.Details)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Parameters == nil {
+					x.Parameters = &ValidationParams{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Parameters); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -33131,77 +33130,28 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods
 	}
 }
 
-var _ protoreflect.List = (*_QueryEpochPerformanceSummaryByEpochResponse_1_list)(nil)
-
-type _QueryEpochPerformanceSummaryByEpochResponse_1_list struct {
-	list *[]*EpochPerformanceSummary
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(EpochPerformanceSummary)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) NewElement() protoreflect.Value {
-	v := new(EpochPerformanceSummary)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var (
-	md_QueryEpochPerformanceSummaryByEpochResponse                         protoreflect.MessageDescriptor
-	fd_QueryEpochPerformanceSummaryByEpochResponse_epochPerformanceSummary protoreflect.FieldDescriptor
-)
+var (
+	md_ValidatorPower             protoreflect.MessageDescriptor
+	fd_ValidatorPower_power       protoreflect.FieldDescriptor
+	fd_ValidatorPower_epoch_index protoreflect.FieldDescriptor
+)
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryEpochPerformanceSummaryByEpochResponse = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByEpochResponse")
-	fd_QueryEpochPerformanceSummaryByEpochResponse_epochPerformanceSummary = md_QueryEpochPerformanceSummaryByEpochResponse.Fields().ByName("epochPerformanceSummary")
+	md_ValidatorPower = File_inference_inference_query_proto.Messages().ByName("ValidatorPower")
+	fd_ValidatorPower_power = md_ValidatorPower.Fields().ByName("power")
+	fd_ValidatorPower_epoch_index = md_ValidatorPower.Fields().ByName("epoch_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByEpochResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_ValidatorPower)(nil)
 
-type fastReflection_QueryEpochPerformanceSummaryByEpochResponse QueryEpochPerformanceSummaryByEpochResponse
+type fastReflection_ValidatorPower ValidatorPower
 
-func (x *QueryEpochPerformanceSummaryByEpochResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByEpochResponse)(x)
+func (x *ValidatorPower) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ValidatorPower)(x)
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochResponse) slowProtoReflect() protoreflect.Message {
+func (x *ValidatorPower) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[69]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -33213,43 +33163,43 @@ func (x *QueryEpochPerformanceSummaryByEpochResponse) slowProtoReflect() protore
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType{}
+var _fastReflection_ValidatorPower_messageType fastReflection_ValidatorPower_messageType
+var _ protoreflect.MessageType = fastReflection_ValidatorPower_messageType{}
 
-type fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType struct{}
+type fastReflection_ValidatorPower_messageType struct{}
 
-func (x fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByEpochResponse)(nil)
+func (x fastReflection_ValidatorPower_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ValidatorPower)(nil)
 }
-func (x fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByEpochResponse)
+func (x fastReflection_ValidatorPower_messageType) New() protoreflect.Message {
+	return new(fastReflection_ValidatorPower)
 }
-func (x fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByEpochResponse
+func (x fastReflection_ValidatorPower_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ValidatorPower
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByEpochResponse
+func (x *fastReflection_ValidatorPower) Descriptor() protoreflect.MessageDescriptor {
+	return md_ValidatorPower
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType
+func (x *fastReflection_ValidatorPower) Type() protoreflect.MessageType {
+	return _fastReflection_ValidatorPower_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByEpochResponse)
+func (x *fastReflection_ValidatorPower) New() protoreflect.Message {
+	return new(fastReflection_ValidatorPower)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryEpochPerformanceSummaryByEpochResponse)(x)
+func (x *fastReflection_ValidatorPower) Interface() protoreflect.ProtoMessage {
+	return (*ValidatorPower)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -33257,10 +33207,16 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.EpochPerformanceSummary) != 0 {
-		value := protoreflect.ValueOfList(&_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &x.EpochPerformanceSummary})
-		if !f(fd_QueryEpochPerformanceSummaryByEpochResponse_epochPerformanceSummary, value) {
+func (x *fastReflection_ValidatorPower) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Power != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Power)
+		if !f(fd_ValidatorPower_power, value) {
+			return
+		}
+	}
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_ValidatorPower_epoch_index, value) {
 			return
 		}
 	}
@@ -33277,15 +33233,17 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Range(f fun
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ValidatorPower) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
-		return len(x.EpochPerformanceSummary) != 0
+	case "inference.inference.ValidatorPower.power":
+		return x.Power != uint64(0)
+	case "inference.inference.ValidatorPower.epoch_index":
+		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33295,15 +33253,17 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Has(fd prot
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ValidatorPower) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
-		x.EpochPerformanceSummary = nil
+	case "inference.inference.ValidatorPower.power":
+		x.Power = uint64(0)
+	case "inference.inference.ValidatorPower.epoch_index":
+		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33313,19 +33273,19 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Clear(fd pr
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ValidatorPower) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
-		if len(x.EpochPerformanceSummary) == 0 {
-			return protoreflect.ValueOfList(&_QueryEpochPerformanceSummaryByEpochResponse_1_list{})
-		}
-		listValue := &_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &x.EpochPerformanceSummary}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.ValidatorPower.power":
+		value := x.Power
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ValidatorPower.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -33339,17 +33299,17 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Get(descrip
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ValidatorPower) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
-		lv := value.List()
-		clv := lv.(*_QueryEpochPerformanceSummaryByEpochResponse_1_list)
-		x.EpochPerformanceSummary = *clv.list
+	case "inference.inference.ValidatorPower.power":
+		x.Power = value.Uint()
+	case "inference.inference.ValidatorPower.epoch_index":
+		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33363,45 +33323,44 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Set(fd prot
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ValidatorPower) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
-		if x.EpochPerformanceSummary == nil {
-			x.EpochPerformanceSummary = []*EpochPerformanceSummary{}
-		}
-		value := &_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &x.EpochPerformanceSummary}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.ValidatorPower.power":
+		panic(fmt.Errorf("field power of message inference.inference.ValidatorPower is not mutable"))
+	case "inference.inference.ValidatorPower.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.ValidatorPower is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ValidatorPower) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
-		list := []*EpochPerformanceSummary{}
-		return protoreflect.ValueOfList(&_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &list})
+	case "inference.inference.ValidatorPower.power":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ValidatorPower.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ValidatorPower"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ValidatorPower does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ValidatorPower) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByEpochResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ValidatorPower", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -33409,7 +33368,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) WhichOneof(
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ValidatorPower) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -33420,7 +33379,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) GetUnknown(
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ValidatorPower) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -33432,7 +33391,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) SetUnknown(
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) IsValid() bool {
+func (x *fastReflection_ValidatorPower) IsValid() bool {
 	return x != nil
 }
 
@@ -33442,9 +33401,9 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) IsValid() b
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ValidatorPower) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochResponse)
+		x := input.Message.Interface().(*ValidatorPower)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33456,11 +33415,11 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 		var n int
 		var l int
 		_ = l
-		if len(x.EpochPerformanceSummary) > 0 {
-			for _, e := range x.EpochPerformanceSummary {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Power != 0 {
+			n += 1 + runtime.Sov(uint64(x.Power))
+		}
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -33472,7 +33431,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochResponse)
+		x := input.Message.Interface().(*ValidatorPower)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33491,21 +33450,15 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.EpochPerformanceSummary) > 0 {
-			for iNdEx := len(x.EpochPerformanceSummary) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.EpochPerformanceSummary[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.Power != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Power))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -33518,7 +33471,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochResponse)
+		x := input.Message.Interface().(*ValidatorPower)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33550,17 +33503,17 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPower: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
 				}
-				var msglen int
+				x.Power = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -33570,26 +33523,30 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Power |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 				}
-				x.EpochPerformanceSummary = append(x.EpochPerformanceSummary, &EpochPerformanceSummary{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary[len(x.EpochPerformanceSummary)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -33626,27 +33583,25 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethod
 }
 
 var (
-	md_QueryEpochPerformanceSummaryByParticipantRequest               protoreflect.MessageDescriptor
-	fd_QueryEpochPerformanceSummaryByParticipantRequest_epoch_index   protoreflect.FieldDescriptor
-	fd_QueryEpochPerformanceSummaryByParticipantRequest_participantId protoreflect.FieldDescriptor
+	md_QueryEpochPerformanceSummaryByEpochRequest             protoreflect.MessageDescriptor
+	fd_QueryEpochPerformanceSummaryByEpochRequest_epoch_index protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryEpochPerformanceSummaryByParticipantRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByParticipantRequest")
-	fd_QueryEpochPerformanceSummaryByParticipantRequest_epoch_index = md_QueryEpochPerformanceSummaryByParticipantRequest.Fields().ByName("epoch_index")
-	fd_QueryEpochPerformanceSummaryByParticipantRequest_participantId = md_QueryEpochPerformanceSummaryByParticipantRequest.Fields().ByName("participantId")
+	md_QueryEpochPerformanceSummaryByEpochRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByEpochRequest")
+	fd_QueryEpochPerformanceSummaryByEpochRequest_epoch_index = md_QueryEpochPerformanceSummaryByEpochRequest.Fields().ByName("epoch_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByEpochRequest)(nil)
 
-type fastReflection_QueryEpochPerformanceSummaryByParticipantRequest QueryEpochPerformanceSummaryByParticipantRequest
+type fastReflection_QueryEpochPerformanceSummaryByEpochRequest QueryEpochPerformanceSummaryByEpochRequest
 
-func (x *QueryEpochPerformanceSummaryByParticipantRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)(x)
+func (x *QueryEpochPerformanceSummaryByEpochRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByEpochRequest)(x)
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryEpochPerformanceSummaryByEpochRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[70]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -33658,43 +33613,43 @@ func (x *QueryEpochPerformanceSummaryByParticipantRequest) slowProtoReflect() pr
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType{}
+var _fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType{}
 
-type fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType struct{}
+type fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType struct{}
 
-func (x fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)(nil)
+func (x fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByEpochRequest)(nil)
 }
-func (x fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)
+func (x fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByEpochRequest)
 }
-func (x fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByParticipantRequest
+func (x fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByEpochRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByParticipantRequest
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByEpochRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEpochPerformanceSummaryByEpochRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByEpochRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryEpochPerformanceSummaryByParticipantRequest)(x)
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryEpochPerformanceSummaryByEpochRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -33702,16 +33657,10 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Interf
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.EpochIndex != uint64(0) {
 		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryEpochPerformanceSummaryByParticipantRequest_epoch_index, value) {
-			return
-		}
-	}
-	if x.ParticipantId != "" {
-		value := protoreflect.ValueOfString(x.ParticipantId)
-		if !f(fd_QueryEpochPerformanceSummaryByParticipantRequest_participantId, value) {
+		if !f(fd_QueryEpochPerformanceSummaryByEpochRequest_epoch_index, value) {
 			return
 		}
 	}
@@ -33728,17 +33677,15 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Range(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
 		return x.EpochIndex != uint64(0)
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
-		return x.ParticipantId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33748,17 +33695,15 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Has(fd
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
 		x.EpochIndex = uint64(0)
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
-		x.ParticipantId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33768,19 +33713,16 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Clear(
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
 		value := x.EpochIndex
 		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
-		value := x.ParticipantId
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -33794,17 +33736,15 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Get(de
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
 		x.EpochIndex = value.Uint()
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
-		x.ParticipantId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33818,44 +33758,40 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Set(fd
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest is not mutable"))
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
-		panic(fmt.Errorf("field participantId of message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest is not mutable"))
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryEpochPerformanceSummaryByEpochRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochRequest.epoch_index":
 		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByParticipantRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByEpochRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -33863,7 +33799,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) WhichO
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -33874,7 +33810,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) GetUnk
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -33886,7 +33822,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) SetUnk
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) IsValid() bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -33896,9 +33832,9 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) IsVali
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantRequest)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33913,10 +33849,6 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 		if x.EpochIndex != 0 {
 			n += 1 + runtime.Sov(uint64(x.EpochIndex))
 		}
-		l = len(x.ParticipantId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -33927,7 +33859,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantRequest)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33946,13 +33878,6 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ParticipantId) > 0 {
-			i -= len(x.ParticipantId)
-			copy(dAtA[i:], x.ParticipantId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantId)))
-			i--
-			dAtA[i] = 0x12
-		}
 		if x.EpochIndex != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
 			i--
@@ -33969,7 +33894,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantRequest)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34001,10 +33926,10 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -34026,38 +33951,6 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 						break
 					}
 				}
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ParticipantId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -34093,27 +33986,78 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoM
 	}
 }
 
-var (
-	md_QueryEpochPerformanceSummaryByParticipantResponse                         protoreflect.MessageDescriptor
-	fd_QueryEpochPerformanceSummaryByParticipantResponse_epochPerformanceSummary protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_QueryEpochPerformanceSummaryByEpochResponse_1_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryEpochPerformanceSummaryByParticipantResponse = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByParticipantResponse")
-	fd_QueryEpochPerformanceSummaryByParticipantResponse_epochPerformanceSummary = md_QueryEpochPerformanceSummaryByParticipantResponse.Fields().ByName("epochPerformanceSummary")
+type _QueryEpochPerformanceSummaryByEpochResponse_1_list struct {
+	list *[]*EpochPerformanceSummary
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)(nil)
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-type fastReflection_QueryEpochPerformanceSummaryByParticipantResponse QueryEpochPerformanceSummaryByParticipantResponse
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
 
-func (x *QueryEpochPerformanceSummaryByParticipantResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)(x)
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
+	(*x.list)[i] = concreteValue
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[71]
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(EpochPerformanceSummary)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) NewElement() protoreflect.Value {
+	v := new(EpochPerformanceSummary)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryEpochPerformanceSummaryByEpochResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryEpochPerformanceSummaryByEpochResponse                         protoreflect.MessageDescriptor
+	fd_QueryEpochPerformanceSummaryByEpochResponse_epochPerformanceSummary protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryEpochPerformanceSummaryByEpochResponse = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByEpochResponse")
+	fd_QueryEpochPerformanceSummaryByEpochResponse_epochPerformanceSummary = md_QueryEpochPerformanceSummaryByEpochResponse.Fields().ByName("epochPerformanceSummary")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByEpochResponse)(nil)
+
+type fastReflection_QueryEpochPerformanceSummaryByEpochResponse QueryEpochPerformanceSummaryByEpochResponse
+
+func (x *QueryEpochPerformanceSummaryByEpochResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByEpochResponse)(x)
+}
+
+func (x *QueryEpochPerformanceSummaryByEpochResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[71]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -34124,43 +34068,43 @@ func (x *QueryEpochPerformanceSummaryByParticipantResponse) slowProtoReflect() p
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType{}
+var _fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType{}
 
-type fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType struct{}
+type fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType struct{}
 
-func (x fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)(nil)
+func (x fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByEpochResponse)(nil)
 }
-func (x fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)
+func (x fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByEpochResponse)
 }
-func (x fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByParticipantResponse
+func (x fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByEpochResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochPerformanceSummaryByParticipantResponse
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByEpochResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEpochPerformanceSummaryByEpochResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByEpochResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryEpochPerformanceSummaryByParticipantResponse)(x)
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryEpochPerformanceSummaryByEpochResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -34168,10 +34112,10 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Inter
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochPerformanceSummary != nil {
-		value := protoreflect.ValueOfMessage(x.EpochPerformanceSummary.ProtoReflect())
-		if !f(fd_QueryEpochPerformanceSummaryByParticipantResponse_epochPerformanceSummary, value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.EpochPerformanceSummary) != 0 {
+		value := protoreflect.ValueOfList(&_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &x.EpochPerformanceSummary})
+		if !f(fd_QueryEpochPerformanceSummaryByEpochResponse_epochPerformanceSummary, value) {
 			return
 		}
 	}
@@ -34188,15 +34132,15 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Range
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
-		return x.EpochPerformanceSummary != nil
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
+		return len(x.EpochPerformanceSummary) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34206,15 +34150,15 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Has(f
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
 		x.EpochPerformanceSummary = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34224,16 +34168,19 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Clear
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
-		value := x.EpochPerformanceSummary
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
+		if len(x.EpochPerformanceSummary) == 0 {
+			return protoreflect.ValueOfList(&_QueryEpochPerformanceSummaryByEpochResponse_1_list{})
+		}
+		listValue := &_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &x.EpochPerformanceSummary}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -34247,15 +34194,17 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Get(d
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
-		x.EpochPerformanceSummary = value.Message().Interface().(*EpochPerformanceSummary)
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
+		lv := value.List()
+		clv := lv.(*_QueryEpochPerformanceSummaryByEpochResponse_1_list)
+		x.EpochPerformanceSummary = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34269,44 +34218,45 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Set(f
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
 		if x.EpochPerformanceSummary == nil {
-			x.EpochPerformanceSummary = new(EpochPerformanceSummary)
+			x.EpochPerformanceSummary = []*EpochPerformanceSummary{}
 		}
-		return protoreflect.ValueOfMessage(x.EpochPerformanceSummary.ProtoReflect())
+		value := &_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &x.EpochPerformanceSummary}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
-		m := new(EpochPerformanceSummary)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary":
+		list := []*EpochPerformanceSummary{}
+		return protoreflect.ValueOfList(&_QueryEpochPerformanceSummaryByEpochResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByEpochResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByEpochResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByParticipantResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByEpochResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -34314,7 +34264,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Which
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -34325,7 +34275,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) GetUn
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -34337,7 +34287,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) SetUn
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) IsValid() bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -34347,9 +34297,9 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) IsVal
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEpochPerformanceSummaryByEpochResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantResponse)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34361,9 +34311,11 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 		var n int
 		var l int
 		_ = l
-		if x.EpochPerformanceSummary != nil {
-			l = options.Size(x.EpochPerformanceSummary)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.EpochPerformanceSummary) > 0 {
+			for _, e := range x.EpochPerformanceSummary {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -34375,7 +34327,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantResponse)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34394,19 +34346,21 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochPerformanceSummary != nil {
-			encoded, err := options.Marshal(x.EpochPerformanceSummary)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
+		if len(x.EpochPerformanceSummary) > 0 {
+			for iNdEx := len(x.EpochPerformanceSummary) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.EpochPerformanceSummary[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
 			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -34419,7 +34373,7 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantResponse)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByEpochResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34451,10 +34405,10 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -34486,10 +34440,8 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.EpochPerformanceSummary == nil {
-					x.EpochPerformanceSummary = &EpochPerformanceSummary{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary); err != nil {
+				x.EpochPerformanceSummary = append(x.EpochPerformanceSummary, &EpochPerformanceSummary{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary[len(x.EpochPerformanceSummary)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -34529,25 +34481,27 @@ func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Proto
 }
 
 var (
-	md_QueryAllEpochPerformanceSummaryRequest            protoreflect.MessageDescriptor
-	fd_QueryAllEpochPerformanceSummaryRequest_pagination protoreflect.FieldDescriptor
+	md_QueryEpochPerformanceSummaryByParticipantRequest               protoreflect.MessageDescriptor
+	fd_QueryEpochPerformanceSummaryByParticipantRequest_epoch_index   protoreflect.FieldDescriptor
+	fd_QueryEpochPerformanceSummaryByParticipantRequest_participantId protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllEpochPerformanceSummaryRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochPerformanceSummaryRequest")
-	fd_QueryAllEpochPerformanceSummaryRequest_pagination = md_QueryAllEpochPerformanceSummaryRequest.Fields().ByName("pagination")
+	md_QueryEpochPerformanceSummaryByParticipantRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByParticipantRequest")
+	fd_QueryEpochPerformanceSummaryByParticipantRequest_epoch_index = md_QueryEpochPerformanceSummaryByParticipantRequest.Fields().ByName("epoch_index")
+	fd_QueryEpochPerformanceSummaryByParticipantRequest_participantId = md_QueryEpochPerformanceSummaryByParticipantRequest.Fields().ByName("participantId")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)(nil)
 
-type fastReflection_QueryAllEpochPerformanceSummaryRequest QueryAllEpochPerformanceSummaryRequest
+type fastReflection_QueryEpochPerformanceSummaryByParticipantRequest QueryEpochPerformanceSummaryByParticipantRequest
 
-func (x *QueryAllEpochPerformanceSummaryRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(x)
+func (x *QueryEpochPerformanceSummaryByParticipantRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)(x)
 }
 
-func (x *QueryAllEpochPerformanceSummaryRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryEpochPerformanceSummaryByParticipantRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[72]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -34559,43 +34513,43 @@ func (x *QueryAllEpochPerformanceSummaryRequest) slowProtoReflect() protoreflect
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType{}
+var _fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType{}
 
-type fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType struct{}
+type fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType struct{}
 
-func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(nil)
+func (x fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)(nil)
 }
-func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochPerformanceSummaryRequest)
+func (x fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)
 }
-func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochPerformanceSummaryRequest
+func (x fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByParticipantRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochPerformanceSummaryRequest
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByParticipantRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEpochPerformanceSummaryByParticipantRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochPerformanceSummaryRequest)
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllEpochPerformanceSummaryRequest)(x)
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryEpochPerformanceSummaryByParticipantRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -34603,10 +34557,16 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Interface() prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllEpochPerformanceSummaryRequest_pagination, value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_QueryEpochPerformanceSummaryByParticipantRequest_epoch_index, value) {
+			return
+		}
+	}
+	if x.ParticipantId != "" {
+		value := protoreflect.ValueOfString(x.ParticipantId)
+		if !f(fd_QueryEpochPerformanceSummaryByParticipantRequest_participantId, value) {
 			return
 		}
 	}
@@ -34623,15 +34583,17 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Range(f func(pro
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+		return x.EpochIndex != uint64(0)
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
+		return x.ParticipantId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34641,15 +34603,17 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Has(fd protorefl
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+		x.EpochIndex = uint64(0)
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
+		x.ParticipantId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34659,16 +34623,19 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Clear(fd protore
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
+		value := x.ParticipantId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -34682,15 +34649,17 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Get(descriptor p
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+		x.EpochIndex = value.Uint()
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
+		x.ParticipantId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34704,44 +34673,44 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Set(fd protorefl
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest is not mutable"))
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
+		panic(fmt.Errorf("field participantId of message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest.participantId":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochPerformanceSummaryRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByParticipantRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -34749,7 +34718,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) WhichOneof(d pro
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -34760,7 +34729,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) GetUnknown() pro
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -34772,7 +34741,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) SetUnknown(field
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) IsValid() bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -34782,9 +34751,9 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34796,8 +34765,11 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
+		l = len(x.ParticipantId)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -34810,7 +34782,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34829,19 +34801,17 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if len(x.ParticipantId) > 0 {
+			i -= len(x.ParticipantId)
+			copy(dAtA[i:], x.ParticipantId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantId)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -34854,7 +34824,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34886,17 +34856,36 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				}
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -34906,27 +34895,23 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.ParticipantId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -34963,127 +34948,74 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllEpochPerformanceSummaryResponse_1_list)(nil)
-
-type _QueryAllEpochPerformanceSummaryResponse_1_list struct {
-	list *[]*EpochPerformanceSummary
-}
-
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
+var (
+	md_QueryEpochPerformanceSummaryByParticipantResponse                         protoreflect.MessageDescriptor
+	fd_QueryEpochPerformanceSummaryByParticipantResponse_epochPerformanceSummary protoreflect.FieldDescriptor
+)
 
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryEpochPerformanceSummaryByParticipantResponse = File_inference_inference_query_proto.Messages().ByName("QueryEpochPerformanceSummaryByParticipantResponse")
+	fd_QueryEpochPerformanceSummaryByParticipantResponse_epochPerformanceSummary = md_QueryEpochPerformanceSummaryByParticipantResponse.Fields().ByName("epochPerformanceSummary")
 }
 
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
-	(*x.list)[i] = concreteValue
-}
+var _ protoreflect.Message = (*fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)(nil)
 
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
-	*x.list = append(*x.list, concreteValue)
-}
+type fastReflection_QueryEpochPerformanceSummaryByParticipantResponse QueryEpochPerformanceSummaryByParticipantResponse
 
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(EpochPerformanceSummary)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
+func (x *QueryEpochPerformanceSummaryByParticipantResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)(x)
 }
 
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
+func (x *QueryEpochPerformanceSummaryByParticipantResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[73]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	*x.list = (*x.list)[:n]
+	return mi.MessageOf(x)
 }
 
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) NewElement() protoreflect.Value {
-	v := new(EpochPerformanceSummary)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var (
-	md_QueryAllEpochPerformanceSummaryResponse                         protoreflect.MessageDescriptor
-	fd_QueryAllEpochPerformanceSummaryResponse_epochPerformanceSummary protoreflect.FieldDescriptor
-	fd_QueryAllEpochPerformanceSummaryResponse_pagination              protoreflect.FieldDescriptor
-)
-
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryAllEpochPerformanceSummaryResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochPerformanceSummaryResponse")
-	fd_QueryAllEpochPerformanceSummaryResponse_epochPerformanceSummary = md_QueryAllEpochPerformanceSummaryResponse.Fields().ByName("epochPerformanceSummary")
-	fd_QueryAllEpochPerformanceSummaryResponse_pagination = md_QueryAllEpochPerformanceSummaryResponse.Fields().ByName("pagination")
-}
-
-var _ protoreflect.Message = (*fastReflection_QueryAllEpochPerformanceSummaryResponse)(nil)
-
-type fastReflection_QueryAllEpochPerformanceSummaryResponse QueryAllEpochPerformanceSummaryResponse
-
-func (x *QueryAllEpochPerformanceSummaryResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochPerformanceSummaryResponse)(x)
-}
-
-func (x *QueryAllEpochPerformanceSummaryResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[73]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-var _fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType{}
+var _fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType{}
 
-type fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType struct{}
+type fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType struct{}
 
-func (x fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllEpochPerformanceSummaryResponse)(nil)
+func (x fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)(nil)
 }
-func (x fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochPerformanceSummaryResponse)
+func (x fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)
 }
-func (x fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochPerformanceSummaryResponse
+func (x fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByParticipantResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllEpochPerformanceSummaryResponse
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochPerformanceSummaryByParticipantResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEpochPerformanceSummaryByParticipantResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllEpochPerformanceSummaryResponse)
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochPerformanceSummaryByParticipantResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllEpochPerformanceSummaryResponse)(x)
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryEpochPerformanceSummaryByParticipantResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -35091,16 +35023,10 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.EpochPerformanceSummary) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllEpochPerformanceSummaryResponse_1_list{list: &x.EpochPerformanceSummary})
-		if !f(fd_QueryAllEpochPerformanceSummaryResponse_epochPerformanceSummary, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllEpochPerformanceSummaryResponse_pagination, value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochPerformanceSummary != nil {
+		value := protoreflect.ValueOfMessage(x.EpochPerformanceSummary.ProtoReflect())
+		if !f(fd_QueryEpochPerformanceSummaryByParticipantResponse_epochPerformanceSummary, value) {
 			return
 		}
 	}
@@ -35117,17 +35043,15 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
-		return len(x.EpochPerformanceSummary) != 0
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
+		return x.EpochPerformanceSummary != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35137,17 +35061,15 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
 		x.EpochPerformanceSummary = nil
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35157,22 +35079,16 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
-		if len(x.EpochPerformanceSummary) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllEpochPerformanceSummaryResponse_1_list{})
-		}
-		listValue := &_QueryAllEpochPerformanceSummaryResponse_1_list{list: &x.EpochPerformanceSummary}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
+		value := x.EpochPerformanceSummary
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -35186,19 +35102,15 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
-		lv := value.List()
-		clv := lv.(*_QueryAllEpochPerformanceSummaryResponse_1_list)
-		x.EpochPerformanceSummary = *clv.list
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
+		x.EpochPerformanceSummary = value.Message().Interface().(*EpochPerformanceSummary)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35212,53 +35124,44 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
 		if x.EpochPerformanceSummary == nil {
-			x.EpochPerformanceSummary = []*EpochPerformanceSummary{}
-		}
-		value := &_QueryAllEpochPerformanceSummaryResponse_1_list{list: &x.EpochPerformanceSummary}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
+			x.EpochPerformanceSummary = new(EpochPerformanceSummary)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.EpochPerformanceSummary.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
-		list := []*EpochPerformanceSummary{}
-		return protoreflect.ValueOfList(&_QueryAllEpochPerformanceSummaryResponse_1_list{list: &list})
-	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
-		m := new(v1beta1.PageResponse)
+	case "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary":
+		m := new(EpochPerformanceSummary)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochPerformanceSummaryByParticipantResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochPerformanceSummaryResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochPerformanceSummaryByParticipantResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -35266,7 +35169,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -35277,7 +35180,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -35289,7 +35192,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) IsValid() bool {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -35299,9 +35202,9 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEpochPerformanceSummaryByParticipantResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35313,14 +35216,8 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 		var n int
 		var l int
 		_ = l
-		if len(x.EpochPerformanceSummary) > 0 {
-			for _, e := range x.EpochPerformanceSummary {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.EpochPerformanceSummary != nil {
+			l = options.Size(x.EpochPerformanceSummary)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -35333,7 +35230,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35352,8 +35249,8 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.EpochPerformanceSummary != nil {
+			encoded, err := options.Marshal(x.EpochPerformanceSummary)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35364,23 +35261,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.EpochPerformanceSummary) > 0 {
-			for iNdEx := len(x.EpochPerformanceSummary) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.EpochPerformanceSummary[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -35393,7 +35274,7 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
+		x := input.Message.Interface().(*QueryEpochPerformanceSummaryByParticipantResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35425,10 +35306,10 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -35460,44 +35341,10 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.EpochPerformanceSummary = append(x.EpochPerformanceSummary, &EpochPerformanceSummary{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary[len(x.EpochPerformanceSummary)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
+				if x.EpochPerformanceSummary == nil {
+					x.EpochPerformanceSummary = &EpochPerformanceSummary{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -35537,25 +35384,25 @@ func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods()
 }
 
 var (
-	md_QueryHardwareNodesRequest             protoreflect.MessageDescriptor
-	fd_QueryHardwareNodesRequest_participant protoreflect.FieldDescriptor
+	md_QueryAllEpochPerformanceSummaryRequest            protoreflect.MessageDescriptor
+	fd_QueryAllEpochPerformanceSummaryRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryHardwareNodesRequest = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesRequest")
-	fd_QueryHardwareNodesRequest_participant = md_QueryHardwareNodesRequest.Fields().ByName("participant")
+	md_QueryAllEpochPerformanceSummaryRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochPerformanceSummaryRequest")
+	fd_QueryAllEpochPerformanceSummaryRequest_pagination = md_QueryAllEpochPerformanceSummaryRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(nil)
 
-type fastReflection_QueryHardwareNodesRequest QueryHardwareNodesRequest
+type fastReflection_QueryAllEpochPerformanceSummaryRequest QueryAllEpochPerformanceSummaryRequest
 
-func (x *QueryHardwareNodesRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesRequest)(x)
+func (x *QueryAllEpochPerformanceSummaryRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(x)
 }
 
-func (x *QueryHardwareNodesRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllEpochPerformanceSummaryRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[74]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -35567,43 +35414,43 @@ func (x *QueryHardwareNodesRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryHardwareNodesRequest_messageType fastReflection_QueryHardwareNodesRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesRequest_messageType{}
+var _fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType{}
 
-type fastReflection_QueryHardwareNodesRequest_messageType struct{}
+type fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType struct{}
 
-func (x fastReflection_QueryHardwareNodesRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesRequest)(nil)
+func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochPerformanceSummaryRequest)(nil)
 }
-func (x fastReflection_QueryHardwareNodesRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesRequest)
+func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochPerformanceSummaryRequest)
 }
-func (x fastReflection_QueryHardwareNodesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesRequest
+func (x fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochPerformanceSummaryRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryHardwareNodesRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesRequest
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochPerformanceSummaryRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryHardwareNodesRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryHardwareNodesRequest_messageType
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllEpochPerformanceSummaryRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryHardwareNodesRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesRequest)
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochPerformanceSummaryRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryHardwareNodesRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryHardwareNodesRequest)(x)
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllEpochPerformanceSummaryRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -35611,10 +35458,10 @@ func (x *fastReflection_QueryHardwareNodesRequest) Interface() protoreflect.Prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryHardwareNodesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Participant != "" {
-		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_QueryHardwareNodesRequest_participant, value) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllEpochPerformanceSummaryRequest_pagination, value) {
 			return
 		}
 	}
@@ -35631,15 +35478,15 @@ func (x *fastReflection_QueryHardwareNodesRequest) Range(f func(protoreflect.Fie
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryHardwareNodesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesRequest.participant":
-		return x.Participant != ""
+	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35649,15 +35496,15 @@ func (x *fastReflection_QueryHardwareNodesRequest) Has(fd protoreflect.FieldDesc
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesRequest.participant":
-		x.Participant = ""
+	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35667,16 +35514,16 @@ func (x *fastReflection_QueryHardwareNodesRequest) Clear(fd protoreflect.FieldDe
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryHardwareNodesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryHardwareNodesRequest.participant":
-		value := x.Participant
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -35690,15 +35537,15 @@ func (x *fastReflection_QueryHardwareNodesRequest) Get(descriptor protoreflect.F
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesRequest.participant":
-		x.Participant = value.Interface().(string)
+	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35712,40 +35559,44 @@ func (x *fastReflection_QueryHardwareNodesRequest) Set(fd protoreflect.FieldDesc
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesRequest.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.QueryHardwareNodesRequest is not mutable"))
+	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryHardwareNodesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesRequest.participant":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryHardwareNodesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochPerformanceSummaryRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -35753,7 +35604,7 @@ func (x *fastReflection_QueryHardwareNodesRequest) WhichOneof(d protoreflect.One
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryHardwareNodesRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -35764,7 +35615,7 @@ func (x *fastReflection_QueryHardwareNodesRequest) GetUnknown() protoreflect.Raw
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -35776,7 +35627,7 @@ func (x *fastReflection_QueryHardwareNodesRequest) SetUnknown(fields protoreflec
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryHardwareNodesRequest) IsValid() bool {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -35786,9 +35637,9 @@ func (x *fastReflection_QueryHardwareNodesRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryHardwareNodesRequest)
+		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35800,8 +35651,8 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 		var n int
 		var l int
 		_ = l
-		l = len(x.Participant)
-		if l > 0 {
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -35814,7 +35665,7 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesRequest)
+		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35833,10 +35684,17 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Participant) > 0 {
-			i -= len(x.Participant)
-			copy(dAtA[i:], x.Participant)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -35851,7 +35709,7 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesRequest)
+		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35883,17 +35741,17 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -35903,23 +35761,27 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Participant = string(dAtA[iNdEx:postIndex])
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -35956,74 +35818,127 @@ func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Me
 	}
 }
 
-var (
-	md_QueryHardwareNodesResponse       protoreflect.MessageDescriptor
-	fd_QueryHardwareNodesResponse_nodes protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_QueryAllEpochPerformanceSummaryResponse_1_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryHardwareNodesResponse = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesResponse")
-	fd_QueryHardwareNodesResponse_nodes = md_QueryHardwareNodesResponse.Fields().ByName("nodes")
+type _QueryAllEpochPerformanceSummaryResponse_1_list struct {
+	list *[]*EpochPerformanceSummary
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesResponse)(nil)
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-type fastReflection_QueryHardwareNodesResponse QueryHardwareNodesResponse
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
 
-func (x *QueryHardwareNodesResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesResponse)(x)
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
+	(*x.list)[i] = concreteValue
 }
 
-func (x *QueryHardwareNodesResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[75]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*EpochPerformanceSummary)
+	*x.list = append(*x.list, concreteValue)
 }
 
-var _fastReflection_QueryHardwareNodesResponse_messageType fastReflection_QueryHardwareNodesResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesResponse_messageType{}
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(EpochPerformanceSummary)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
 
-type fastReflection_QueryHardwareNodesResponse_messageType struct{}
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
 
-func (x fastReflection_QueryHardwareNodesResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesResponse)(nil)
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) NewElement() protoreflect.Value {
+	v := new(EpochPerformanceSummary)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
-func (x fastReflection_QueryHardwareNodesResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesResponse)
+
+func (x *_QueryAllEpochPerformanceSummaryResponse_1_list) IsValid() bool {
+	return x.list != nil
 }
-func (x fastReflection_QueryHardwareNodesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesResponse
+
+var (
+	md_QueryAllEpochPerformanceSummaryResponse                         protoreflect.MessageDescriptor
+	fd_QueryAllEpochPerformanceSummaryResponse_epochPerformanceSummary protoreflect.FieldDescriptor
+	fd_QueryAllEpochPerformanceSummaryResponse_pagination              protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryAllEpochPerformanceSummaryResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllEpochPerformanceSummaryResponse")
+	fd_QueryAllEpochPerformanceSummaryResponse_epochPerformanceSummary = md_QueryAllEpochPerformanceSummaryResponse.Fields().ByName("epochPerformanceSummary")
+	fd_QueryAllEpochPerformanceSummaryResponse_pagination = md_QueryAllEpochPerformanceSummaryResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllEpochPerformanceSummaryResponse)(nil)
+
+type fastReflection_QueryAllEpochPerformanceSummaryResponse QueryAllEpochPerformanceSummaryResponse
+
+func (x *QueryAllEpochPerformanceSummaryResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochPerformanceSummaryResponse)(x)
+}
+
+func (x *QueryAllEpochPerformanceSummaryResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[75]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType{}
+
+type fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType struct{}
+
+func (x fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllEpochPerformanceSummaryResponse)(nil)
+}
+func (x fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochPerformanceSummaryResponse)
+}
+func (x fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochPerformanceSummaryResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryHardwareNodesResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesResponse
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllEpochPerformanceSummaryResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryHardwareNodesResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryHardwareNodesResponse_messageType
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllEpochPerformanceSummaryResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryHardwareNodesResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesResponse)
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllEpochPerformanceSummaryResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryHardwareNodesResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryHardwareNodesResponse)(x)
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllEpochPerformanceSummaryResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -36031,10 +35946,16 @@ func (x *fastReflection_QueryHardwareNodesResponse) Interface() protoreflect.Pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryHardwareNodesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Nodes != nil {
-		value := protoreflect.ValueOfMessage(x.Nodes.ProtoReflect())
-		if !f(fd_QueryHardwareNodesResponse_nodes, value) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.EpochPerformanceSummary) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllEpochPerformanceSummaryResponse_1_list{list: &x.EpochPerformanceSummary})
+		if !f(fd_QueryAllEpochPerformanceSummaryResponse_epochPerformanceSummary, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllEpochPerformanceSummaryResponse_pagination, value) {
 			return
 		}
 	}
@@ -36051,15 +35972,17 @@ func (x *fastReflection_QueryHardwareNodesResponse) Range(f func(protoreflect.Fi
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryHardwareNodesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesResponse.nodes":
-		return x.Nodes != nil
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+		return len(x.EpochPerformanceSummary) != 0
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36069,15 +35992,17 @@ func (x *fastReflection_QueryHardwareNodesResponse) Has(fd protoreflect.FieldDes
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesResponse.nodes":
-		x.Nodes = nil
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+		x.EpochPerformanceSummary = nil
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36087,16 +36012,22 @@ func (x *fastReflection_QueryHardwareNodesResponse) Clear(fd protoreflect.FieldD
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryHardwareNodesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryHardwareNodesResponse.nodes":
-		value := x.Nodes
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+		if len(x.EpochPerformanceSummary) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllEpochPerformanceSummaryResponse_1_list{})
+		}
+		listValue := &_QueryAllEpochPerformanceSummaryResponse_1_list{list: &x.EpochPerformanceSummary}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
+		value := x.Pagination
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -36110,15 +36041,19 @@ func (x *fastReflection_QueryHardwareNodesResponse) Get(descriptor protoreflect.
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesResponse.nodes":
-		x.Nodes = value.Message().Interface().(*HardwareNodes)
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+		lv := value.List()
+		clv := lv.(*_QueryAllEpochPerformanceSummaryResponse_1_list)
+		x.EpochPerformanceSummary = *clv.list
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36132,44 +36067,53 @@ func (x *fastReflection_QueryHardwareNodesResponse) Set(fd protoreflect.FieldDes
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesResponse.nodes":
-		if x.Nodes == nil {
-			x.Nodes = new(HardwareNodes)
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+		if x.EpochPerformanceSummary == nil {
+			x.EpochPerformanceSummary = []*EpochPerformanceSummary{}
 		}
-		return protoreflect.ValueOfMessage(x.Nodes.ProtoReflect())
+		value := &_QueryAllEpochPerformanceSummaryResponse_1_list{list: &x.EpochPerformanceSummary}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryHardwareNodesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesResponse.nodes":
-		m := new(HardwareNodes)
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary":
+		list := []*EpochPerformanceSummary{}
+		return protoreflect.ValueOfList(&_QueryAllEpochPerformanceSummaryResponse_1_list{list: &list})
+	case "inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination":
+		m := new(v1beta1.PageResponse)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllEpochPerformanceSummaryResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllEpochPerformanceSummaryResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryHardwareNodesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllEpochPerformanceSummaryResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -36177,7 +36121,7 @@ func (x *fastReflection_QueryHardwareNodesResponse) WhichOneof(d protoreflect.On
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryHardwareNodesResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -36188,7 +36132,7 @@ func (x *fastReflection_QueryHardwareNodesResponse) GetUnknown() protoreflect.Ra
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -36200,7 +36144,7 @@ func (x *fastReflection_QueryHardwareNodesResponse) SetUnknown(fields protorefle
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryHardwareNodesResponse) IsValid() bool {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -36210,9 +36154,9 @@ func (x *fastReflection_QueryHardwareNodesResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllEpochPerformanceSummaryResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryHardwareNodesResponse)
+		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36224,8 +36168,14 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 		var n int
 		var l int
 		_ = l
-		if x.Nodes != nil {
-			l = options.Size(x.Nodes)
+		if len(x.EpochPerformanceSummary) > 0 {
+			for _, e := range x.EpochPerformanceSummary {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -36238,7 +36188,7 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesResponse)
+		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36257,8 +36207,8 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Nodes != nil {
-			encoded, err := options.Marshal(x.Nodes)
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36269,7 +36219,23 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if len(x.EpochPerformanceSummary) > 0 {
+			for iNdEx := len(x.EpochPerformanceSummary) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.EpochPerformanceSummary[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -36282,7 +36248,7 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesResponse)
+		x := input.Message.Interface().(*QueryAllEpochPerformanceSummaryResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36314,15 +36280,15 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -36349,10 +36315,44 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Nodes == nil {
-					x.Nodes = &HardwareNodes{}
+				x.EpochPerformanceSummary = append(x.EpochPerformanceSummary, &EpochPerformanceSummary{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EpochPerformanceSummary[len(x.EpochPerformanceSummary)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nodes); err != nil {
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -36392,23 +36392,25 @@ func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.M
 }
 
 var (
-	md_QueryHardwareNodesAllRequest protoreflect.MessageDescriptor
+	md_QueryHardwareNodesRequest             protoreflect.MessageDescriptor
+	fd_QueryHardwareNodesRequest_participant protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryHardwareNodesAllRequest = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesAllRequest")
+	md_QueryHardwareNodesRequest = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesRequest")
+	fd_QueryHardwareNodesRequest_participant = md_QueryHardwareNodesRequest.Fields().ByName("participant")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesAllRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesRequest)(nil)
 
-type fastReflection_QueryHardwareNodesAllRequest QueryHardwareNodesAllRequest
+type fastReflection_QueryHardwareNodesRequest QueryHardwareNodesRequest
 
-func (x *QueryHardwareNodesAllRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesAllRequest)(x)
+func (x *QueryHardwareNodesRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesRequest)(x)
 }
 
-func (x *QueryHardwareNodesAllRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryHardwareNodesRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[76]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -36420,43 +36422,43 @@ func (x *QueryHardwareNodesAllRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryHardwareNodesAllRequest_messageType fastReflection_QueryHardwareNodesAllRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesAllRequest_messageType{}
+var _fastReflection_QueryHardwareNodesRequest_messageType fastReflection_QueryHardwareNodesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesRequest_messageType{}
 
-type fastReflection_QueryHardwareNodesAllRequest_messageType struct{}
+type fastReflection_QueryHardwareNodesRequest_messageType struct{}
 
-func (x fastReflection_QueryHardwareNodesAllRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesAllRequest)(nil)
+func (x fastReflection_QueryHardwareNodesRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesRequest)(nil)
 }
-func (x fastReflection_QueryHardwareNodesAllRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesAllRequest)
+func (x fastReflection_QueryHardwareNodesRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesRequest)
 }
-func (x fastReflection_QueryHardwareNodesAllRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesAllRequest
+func (x fastReflection_QueryHardwareNodesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesAllRequest
+func (x *fastReflection_QueryHardwareNodesRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryHardwareNodesAllRequest_messageType
+func (x *fastReflection_QueryHardwareNodesRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryHardwareNodesRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryHardwareNodesAllRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesAllRequest)
+func (x *fastReflection_QueryHardwareNodesRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryHardwareNodesAllRequest)(x)
+func (x *fastReflection_QueryHardwareNodesRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryHardwareNodesRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -36464,7 +36466,13 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryHardwareNodesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryHardwareNodesRequest_participant, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -36478,13 +36486,15 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryHardwareNodesRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryHardwareNodesRequest.participant":
+		return x.Participant != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36494,13 +36504,15 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryHardwareNodesRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryHardwareNodesRequest.participant":
+		x.Participant = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36510,13 +36522,16 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryHardwareNodesRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -36530,13 +36545,15 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryHardwareNodesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryHardwareNodesRequest.participant":
+		x.Participant = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36550,36 +36567,40 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryHardwareNodesRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryHardwareNodesRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryHardwareNodesAllRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryHardwareNodesRequest.participant":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryHardwareNodesAllRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryHardwareNodesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesAllRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -36587,7 +36608,7 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryHardwareNodesAllRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryHardwareNodesRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -36598,7 +36619,7 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryHardwareNodesRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -36610,7 +36631,7 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryHardwareNodesAllRequest) IsValid() bool {
+func (x *fastReflection_QueryHardwareNodesRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -36620,9 +36641,9 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryHardwareNodesRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
+		x := input.Message.Interface().(*QueryHardwareNodesRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36634,6 +36655,10 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface
 		var n int
 		var l int
 		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -36644,7 +36669,7 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
+		x := input.Message.Interface().(*QueryHardwareNodesRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36663,6 +36688,13 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -36674,7 +36706,7 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
+		x := input.Message.Interface().(*QueryHardwareNodesRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36706,12 +36738,44 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -36747,77 +36811,26 @@ func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface
 	}
 }
 
-var _ protoreflect.List = (*_QueryHardwareNodesAllResponse_1_list)(nil)
-
-type _QueryHardwareNodesAllResponse_1_list struct {
-	list *[]*HardwareNodes
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*HardwareNodes)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*HardwareNodes)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(HardwareNodes)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) NewElement() protoreflect.Value {
-	v := new(HardwareNodes)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryHardwareNodesAllResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryHardwareNodesAllResponse       protoreflect.MessageDescriptor
-	fd_QueryHardwareNodesAllResponse_nodes protoreflect.FieldDescriptor
+	md_QueryHardwareNodesResponse       protoreflect.MessageDescriptor
+	fd_QueryHardwareNodesResponse_nodes protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryHardwareNodesAllResponse = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesAllResponse")
-	fd_QueryHardwareNodesAllResponse_nodes = md_QueryHardwareNodesAllResponse.Fields().ByName("nodes")
+	md_QueryHardwareNodesResponse = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesResponse")
+	fd_QueryHardwareNodesResponse_nodes = md_QueryHardwareNodesResponse.Fields().ByName("nodes")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesAllResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesResponse)(nil)
 
-type fastReflection_QueryHardwareNodesAllResponse QueryHardwareNodesAllResponse
+type fastReflection_QueryHardwareNodesResponse QueryHardwareNodesResponse
 
-func (x *QueryHardwareNodesAllResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesAllResponse)(x)
+func (x *QueryHardwareNodesResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesResponse)(x)
 }
 
-func (x *QueryHardwareNodesAllResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryHardwareNodesResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[77]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -36829,43 +36842,43 @@ func (x *QueryHardwareNodesAllResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryHardwareNodesAllResponse_messageType fastReflection_QueryHardwareNodesAllResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesAllResponse_messageType{}
+var _fastReflection_QueryHardwareNodesResponse_messageType fastReflection_QueryHardwareNodesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesResponse_messageType{}
 
-type fastReflection_QueryHardwareNodesAllResponse_messageType struct{}
+type fastReflection_QueryHardwareNodesResponse_messageType struct{}
 
-func (x fastReflection_QueryHardwareNodesAllResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryHardwareNodesAllResponse)(nil)
+func (x fastReflection_QueryHardwareNodesResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesResponse)(nil)
 }
-func (x fastReflection_QueryHardwareNodesAllResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesAllResponse)
+func (x fastReflection_QueryHardwareNodesResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesResponse)
 }
-func (x fastReflection_QueryHardwareNodesAllResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesAllResponse
+func (x fastReflection_QueryHardwareNodesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryHardwareNodesAllResponse
+func (x *fastReflection_QueryHardwareNodesResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryHardwareNodesAllResponse_messageType
+func (x *fastReflection_QueryHardwareNodesResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryHardwareNodesResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryHardwareNodesAllResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryHardwareNodesAllResponse)
+func (x *fastReflection_QueryHardwareNodesResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryHardwareNodesAllResponse)(x)
+func (x *fastReflection_QueryHardwareNodesResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryHardwareNodesResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -36873,10 +36886,10 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Nodes) != 0 {
-		value := protoreflect.ValueOfList(&_QueryHardwareNodesAllResponse_1_list{list: &x.Nodes})
-		if !f(fd_QueryHardwareNodesAllResponse_nodes, value) {
+func (x *fastReflection_QueryHardwareNodesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Nodes != nil {
+		value := protoreflect.ValueOfMessage(x.Nodes.ProtoReflect())
+		if !f(fd_QueryHardwareNodesResponse_nodes, value) {
 			return
 		}
 	}
@@ -36893,15 +36906,15 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryHardwareNodesResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
-		return len(x.Nodes) != 0
+	case "inference.inference.QueryHardwareNodesResponse.nodes":
+		return x.Nodes != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36911,15 +36924,15 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryHardwareNodesResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+	case "inference.inference.QueryHardwareNodesResponse.nodes":
 		x.Nodes = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36929,19 +36942,16 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
-		if len(x.Nodes) == 0 {
-			return protoreflect.ValueOfList(&_QueryHardwareNodesAllResponse_1_list{})
-		}
-		listValue := &_QueryHardwareNodesAllResponse_1_list{list: &x.Nodes}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryHardwareNodesResponse.nodes":
+		value := x.Nodes
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -36955,17 +36965,15 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryHardwareNodesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
-		lv := value.List()
-		clv := lv.(*_QueryHardwareNodesAllResponse_1_list)
-		x.Nodes = *clv.list
+	case "inference.inference.QueryHardwareNodesResponse.nodes":
+		x.Nodes = value.Message().Interface().(*HardwareNodes)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36979,45 +36987,44 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+	case "inference.inference.QueryHardwareNodesResponse.nodes":
 		if x.Nodes == nil {
-			x.Nodes = []*HardwareNodes{}
+			x.Nodes = new(HardwareNodes)
 		}
-		value := &_QueryHardwareNodesAllResponse_1_list{list: &x.Nodes}
-		return protoreflect.ValueOfList(value)
+		return protoreflect.ValueOfMessage(x.Nodes.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryHardwareNodesAllResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
-		list := []*HardwareNodes{}
-		return protoreflect.ValueOfList(&_QueryHardwareNodesAllResponse_1_list{list: &list})
+	case "inference.inference.QueryHardwareNodesResponse.nodes":
+		m := new(HardwareNodes)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryHardwareNodesAllResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryHardwareNodesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesAllResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -37025,7 +37032,7 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryHardwareNodesAllResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryHardwareNodesResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -37036,7 +37043,7 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryHardwareNodesAllResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryHardwareNodesResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -37048,7 +37055,7 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryHardwareNodesAllResponse) IsValid() bool {
+func (x *fastReflection_QueryHardwareNodesResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -37058,9 +37065,9 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryHardwareNodesResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
+		x := input.Message.Interface().(*QueryHardwareNodesResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37072,11 +37079,9 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if len(x.Nodes) > 0 {
-			for _, e := range x.Nodes {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Nodes != nil {
+			l = options.Size(x.Nodes)
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -37088,7 +37093,7 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
+		x := input.Message.Interface().(*QueryHardwareNodesResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37107,21 +37112,19 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Nodes) > 0 {
-			for iNdEx := len(x.Nodes) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Nodes[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
+		if x.Nodes != nil {
+			encoded, err := options.Marshal(x.Nodes)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
 			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -37134,7 +37137,7 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
+		x := input.Message.Interface().(*QueryHardwareNodesResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37166,10 +37169,10 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -37201,8 +37204,10 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Nodes = append(x.Nodes, &HardwareNodes{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nodes[len(x.Nodes)-1]); err != nil {
+				if x.Nodes == nil {
+					x.Nodes = &HardwareNodes{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nodes); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -37242,25 +37247,23 @@ func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryGetParticipantCurrentStatsRequest               protoreflect.MessageDescriptor
-	fd_QueryGetParticipantCurrentStatsRequest_participantId protoreflect.FieldDescriptor
+	md_QueryHardwareNodesAllRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetParticipantCurrentStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetParticipantCurrentStatsRequest")
-	fd_QueryGetParticipantCurrentStatsRequest_participantId = md_QueryGetParticipantCurrentStatsRequest.Fields().ByName("participantId")
+	md_QueryHardwareNodesAllRequest = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesAllRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetParticipantCurrentStatsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesAllRequest)(nil)
 
-type fastReflection_QueryGetParticipantCurrentStatsRequest QueryGetParticipantCurrentStatsRequest
+type fastReflection_QueryHardwareNodesAllRequest QueryHardwareNodesAllRequest
 
-func (x *QueryGetParticipantCurrentStatsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetParticipantCurrentStatsRequest)(x)
+func (x *QueryHardwareNodesAllRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesAllRequest)(x)
 }
 
-func (x *QueryGetParticipantCurrentStatsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryHardwareNodesAllRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[78]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -37272,43 +37275,43 @@ func (x *QueryGetParticipantCurrentStatsRequest) slowProtoReflect() protoreflect
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetParticipantCurrentStatsRequest_messageType fastReflection_QueryGetParticipantCurrentStatsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetParticipantCurrentStatsRequest_messageType{}
+var _fastReflection_QueryHardwareNodesAllRequest_messageType fastReflection_QueryHardwareNodesAllRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesAllRequest_messageType{}
 
-type fastReflection_QueryGetParticipantCurrentStatsRequest_messageType struct{}
+type fastReflection_QueryHardwareNodesAllRequest_messageType struct{}
 
-func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetParticipantCurrentStatsRequest)(nil)
+func (x fastReflection_QueryHardwareNodesAllRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesAllRequest)(nil)
 }
-func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetParticipantCurrentStatsRequest)
+func (x fastReflection_QueryHardwareNodesAllRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesAllRequest)
 }
-func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetParticipantCurrentStatsRequest
+func (x fastReflection_QueryHardwareNodesAllRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesAllRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetParticipantCurrentStatsRequest
+func (x *fastReflection_QueryHardwareNodesAllRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesAllRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetParticipantCurrentStatsRequest_messageType
+func (x *fastReflection_QueryHardwareNodesAllRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryHardwareNodesAllRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetParticipantCurrentStatsRequest)
+func (x *fastReflection_QueryHardwareNodesAllRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesAllRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetParticipantCurrentStatsRequest)(x)
+func (x *fastReflection_QueryHardwareNodesAllRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryHardwareNodesAllRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -37316,13 +37319,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Interface() prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ParticipantId != "" {
-		value := protoreflect.ValueOfString(x.ParticipantId)
-		if !f(fd_QueryGetParticipantCurrentStatsRequest_participantId, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryHardwareNodesAllRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -37336,15 +37333,13 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Range(f func(pro
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryHardwareNodesAllRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
-		return x.ParticipantId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37354,15 +37349,13 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Has(fd protorefl
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryHardwareNodesAllRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
-		x.ParticipantId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37372,16 +37365,13 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Clear(fd protore
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesAllRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
-		value := x.ParticipantId
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -37395,15 +37385,13 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Get(descriptor p
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryHardwareNodesAllRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
-		x.ParticipantId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37417,40 +37405,36 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Set(fd protorefl
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesAllRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
-		panic(fmt.Errorf("field participantId of message inference.inference.QueryGetParticipantCurrentStatsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesAllRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryHardwareNodesAllRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetParticipantCurrentStatsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesAllRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -37458,7 +37442,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) WhichOneof(d pro
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryHardwareNodesAllRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -37469,7 +37453,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) GetUnknown() pro
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryHardwareNodesAllRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -37481,7 +37465,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) SetUnknown(field
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) IsValid() bool {
+func (x *fastReflection_QueryHardwareNodesAllRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -37491,9 +37475,9 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryHardwareNodesAllRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
+		x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37505,10 +37489,6 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *
 		var n int
 		var l int
 		_ = l
-		l = len(x.ParticipantId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -37519,7 +37499,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
+		x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37538,13 +37518,6 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ParticipantId) > 0 {
-			i -= len(x.ParticipantId)
-			copy(dAtA[i:], x.ParticipantId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantId)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -37556,7 +37529,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
+		x := input.Message.Interface().(*QueryHardwareNodesAllRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37588,44 +37561,12 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ParticipantId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -37661,28 +37602,77 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *
 	}
 }
 
+var _ protoreflect.List = (*_QueryHardwareNodesAllResponse_1_list)(nil)
+
+type _QueryHardwareNodesAllResponse_1_list struct {
+	list *[]*HardwareNodes
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*HardwareNodes)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*HardwareNodes)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(HardwareNodes)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) NewElement() protoreflect.Value {
+	v := new(HardwareNodes)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryHardwareNodesAllResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetParticipantCurrentStatsResponse            protoreflect.MessageDescriptor
-	fd_QueryGetParticipantCurrentStatsResponse_weight     protoreflect.FieldDescriptor
-	fd_QueryGetParticipantCurrentStatsResponse_reputation protoreflect.FieldDescriptor
+	md_QueryHardwareNodesAllResponse       protoreflect.MessageDescriptor
+	fd_QueryHardwareNodesAllResponse_nodes protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetParticipantCurrentStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetParticipantCurrentStatsResponse")
-	fd_QueryGetParticipantCurrentStatsResponse_weight = md_QueryGetParticipantCurrentStatsResponse.Fields().ByName("weight")
-	fd_QueryGetParticipantCurrentStatsResponse_reputation = md_QueryGetParticipantCurrentStatsResponse.Fields().ByName("reputation")
+	md_QueryHardwareNodesAllResponse = File_inference_inference_query_proto.Messages().ByName("QueryHardwareNodesAllResponse")
+	fd_QueryHardwareNodesAllResponse_nodes = md_QueryHardwareNodesAllResponse.Fields().ByName("nodes")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetParticipantCurrentStatsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryHardwareNodesAllResponse)(nil)
 
-type fastReflection_QueryGetParticipantCurrentStatsResponse QueryGetParticipantCurrentStatsResponse
+type fastReflection_QueryHardwareNodesAllResponse QueryHardwareNodesAllResponse
 
-func (x *QueryGetParticipantCurrentStatsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetParticipantCurrentStatsResponse)(x)
+func (x *QueryHardwareNodesAllResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesAllResponse)(x)
 }
 
-func (x *QueryGetParticipantCurrentStatsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryHardwareNodesAllResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[79]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -37694,43 +37684,43 @@ func (x *QueryGetParticipantCurrentStatsResponse) slowProtoReflect() protoreflec
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetParticipantCurrentStatsResponse_messageType fastReflection_QueryGetParticipantCurrentStatsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetParticipantCurrentStatsResponse_messageType{}
+var _fastReflection_QueryHardwareNodesAllResponse_messageType fastReflection_QueryHardwareNodesAllResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryHardwareNodesAllResponse_messageType{}
 
-type fastReflection_QueryGetParticipantCurrentStatsResponse_messageType struct{}
+type fastReflection_QueryHardwareNodesAllResponse_messageType struct{}
 
-func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetParticipantCurrentStatsResponse)(nil)
+func (x fastReflection_QueryHardwareNodesAllResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryHardwareNodesAllResponse)(nil)
 }
-func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetParticipantCurrentStatsResponse)
+func (x fastReflection_QueryHardwareNodesAllResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesAllResponse)
 }
-func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetParticipantCurrentStatsResponse
+func (x fastReflection_QueryHardwareNodesAllResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesAllResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetParticipantCurrentStatsResponse
+func (x *fastReflection_QueryHardwareNodesAllResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryHardwareNodesAllResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetParticipantCurrentStatsResponse_messageType
+func (x *fastReflection_QueryHardwareNodesAllResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryHardwareNodesAllResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetParticipantCurrentStatsResponse)
+func (x *fastReflection_QueryHardwareNodesAllResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryHardwareNodesAllResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetParticipantCurrentStatsResponse)(x)
+func (x *fastReflection_QueryHardwareNodesAllResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryHardwareNodesAllResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -37738,16 +37728,10 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Weight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Weight)
-		if !f(fd_QueryGetParticipantCurrentStatsResponse_weight, value) {
-			return
-		}
-	}
-	if x.Reputation != int32(0) {
-		value := protoreflect.ValueOfInt32(x.Reputation)
-		if !f(fd_QueryGetParticipantCurrentStatsResponse_reputation, value) {
+func (x *fastReflection_QueryHardwareNodesAllResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Nodes) != 0 {
+		value := protoreflect.ValueOfList(&_QueryHardwareNodesAllResponse_1_list{list: &x.Nodes})
+		if !f(fd_QueryHardwareNodesAllResponse_nodes, value) {
 			return
 		}
 	}
@@ -37764,17 +37748,15 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryHardwareNodesAllResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
-		return x.Weight != uint64(0)
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
-		return x.Reputation != int32(0)
+	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+		return len(x.Nodes) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37784,17 +37766,15 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryHardwareNodesAllResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
-		x.Weight = uint64(0)
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
-		x.Reputation = int32(0)
+	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+		x.Nodes = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37804,19 +37784,19 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesAllResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
-		value := x.Weight
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
-		value := x.Reputation
-		return protoreflect.ValueOfInt32(value)
+	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+		if len(x.Nodes) == 0 {
+			return protoreflect.ValueOfList(&_QueryHardwareNodesAllResponse_1_list{})
+		}
+		listValue := &_QueryHardwareNodesAllResponse_1_list{list: &x.Nodes}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -37830,17 +37810,17 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryHardwareNodesAllResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
-		x.Weight = value.Uint()
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
-		x.Reputation = int32(value.Int())
+	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+		lv := value.List()
+		clv := lv.(*_QueryHardwareNodesAllResponse_1_list)
+		x.Nodes = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37854,44 +37834,45 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesAllResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
-		panic(fmt.Errorf("field weight of message inference.inference.QueryGetParticipantCurrentStatsResponse is not mutable"))
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
-		panic(fmt.Errorf("field reputation of message inference.inference.QueryGetParticipantCurrentStatsResponse is not mutable"))
+	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+		if x.Nodes == nil {
+			x.Nodes = []*HardwareNodes{}
+		}
+		value := &_QueryHardwareNodesAllResponse_1_list{list: &x.Nodes}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryHardwareNodesAllResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
-		return protoreflect.ValueOfInt32(int32(0))
+	case "inference.inference.QueryHardwareNodesAllResponse.nodes":
+		list := []*HardwareNodes{}
+		return protoreflect.ValueOfList(&_QueryHardwareNodesAllResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryHardwareNodesAllResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryHardwareNodesAllResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryHardwareNodesAllResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetParticipantCurrentStatsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryHardwareNodesAllResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -37899,7 +37880,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryHardwareNodesAllResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -37910,7 +37891,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryHardwareNodesAllResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -37922,7 +37903,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) IsValid() bool {
+func (x *fastReflection_QueryHardwareNodesAllResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -37932,9 +37913,9 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryHardwareNodesAllResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
+		x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37946,11 +37927,11 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 		var n int
 		var l int
 		_ = l
-		if x.Weight != 0 {
-			n += 1 + runtime.Sov(uint64(x.Weight))
-		}
-		if x.Reputation != 0 {
-			n += 1 + runtime.Sov(uint64(x.Reputation))
+		if len(x.Nodes) > 0 {
+			for _, e := range x.Nodes {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -37962,7 +37943,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
+		x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37981,15 +37962,21 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Reputation != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reputation))
-			i--
-			dAtA[i] = 0x10
-		}
-		if x.Weight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Weight))
-			i--
-			dAtA[i] = 0x8
+		if len(x.Nodes) > 0 {
+			for iNdEx := len(x.Nodes) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Nodes[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -38002,7 +37989,7 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
+		x := input.Message.Interface().(*QueryHardwareNodesAllResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38034,17 +38021,17 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryHardwareNodesAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
 				}
-				x.Weight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -38054,30 +38041,26 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Weight |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				x.Reputation = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Reputation |= int32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Nodes = append(x.Nodes, &HardwareNodes{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nodes[len(x.Nodes)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -38114,23 +38097,25 @@ func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods()
 }
 
 var (
-	md_QueryGetAllParticipantCurrentStatsRequest protoreflect.MessageDescriptor
+	md_QueryGetParticipantCurrentStatsRequest               protoreflect.MessageDescriptor
+	fd_QueryGetParticipantCurrentStatsRequest_participantId protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetAllParticipantCurrentStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllParticipantCurrentStatsRequest")
+	md_QueryGetParticipantCurrentStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetParticipantCurrentStatsRequest")
+	fd_QueryGetParticipantCurrentStatsRequest_participantId = md_QueryGetParticipantCurrentStatsRequest.Fields().ByName("participantId")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetParticipantCurrentStatsRequest)(nil)
 
-type fastReflection_QueryGetAllParticipantCurrentStatsRequest QueryGetAllParticipantCurrentStatsRequest
+type fastReflection_QueryGetParticipantCurrentStatsRequest QueryGetParticipantCurrentStatsRequest
 
-func (x *QueryGetAllParticipantCurrentStatsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(x)
+func (x *QueryGetParticipantCurrentStatsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetParticipantCurrentStatsRequest)(x)
 }
 
-func (x *QueryGetAllParticipantCurrentStatsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetParticipantCurrentStatsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[80]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -38142,43 +38127,43 @@ func (x *QueryGetAllParticipantCurrentStatsRequest) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType{}
+var _fastReflection_QueryGetParticipantCurrentStatsRequest_messageType fastReflection_QueryGetParticipantCurrentStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetParticipantCurrentStatsRequest_messageType{}
 
-type fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType struct{}
+type fastReflection_QueryGetParticipantCurrentStatsRequest_messageType struct{}
 
-func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(nil)
+func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetParticipantCurrentStatsRequest)(nil)
 }
-func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllParticipantCurrentStatsRequest)
+func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetParticipantCurrentStatsRequest)
 }
-func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllParticipantCurrentStatsRequest
+func (x fastReflection_QueryGetParticipantCurrentStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetParticipantCurrentStatsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllParticipantCurrentStatsRequest
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetParticipantCurrentStatsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetParticipantCurrentStatsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllParticipantCurrentStatsRequest)
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetParticipantCurrentStatsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetAllParticipantCurrentStatsRequest)(x)
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetParticipantCurrentStatsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -38186,7 +38171,13 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ParticipantId != "" {
+		value := protoreflect.ValueOfString(x.ParticipantId)
+		if !f(fd_QueryGetParticipantCurrentStatsRequest_participantId, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -38200,13 +38191,15 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
+		return x.ParticipantId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38216,13 +38209,15 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
+		x.ParticipantId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38232,13 +38227,16 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
+		value := x.ParticipantId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -38252,13 +38250,15 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
+		x.ParticipantId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38272,36 +38272,40 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
+		panic(fmt.Errorf("field participantId of message inference.inference.QueryGetParticipantCurrentStatsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetParticipantCurrentStatsRequest.participantId":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllParticipantCurrentStatsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetParticipantCurrentStatsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -38309,7 +38313,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -38320,7 +38324,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -38332,7 +38336,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) IsValid() bool {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -38342,9 +38346,9 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetParticipantCurrentStatsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
+		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38356,6 +38360,10 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods(
 		var n int
 		var l int
 		_ = l
+		l = len(x.ParticipantId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -38366,7 +38374,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
+		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38385,6 +38393,13 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.ParticipantId) > 0 {
+			i -= len(x.ParticipantId)
+			copy(dAtA[i:], x.ParticipantId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantId)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -38396,7 +38411,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
+		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38428,12 +38443,44 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ParticipantId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -38469,81 +38516,28 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods(
 	}
 }
 
-var _ protoreflect.List = (*_QueryGetAllParticipantCurrentStatsResponse_1_list)(nil)
-
-type _QueryGetAllParticipantCurrentStatsResponse_1_list struct {
-	list *[]*ParticipantCurrentStats
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ParticipantCurrentStats)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ParticipantCurrentStats)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ParticipantCurrentStats)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ParticipantCurrentStats)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var (
-	md_QueryGetAllParticipantCurrentStatsResponse                           protoreflect.MessageDescriptor
-	fd_QueryGetAllParticipantCurrentStatsResponse_participant_current_stats protoreflect.FieldDescriptor
-	fd_QueryGetAllParticipantCurrentStatsResponse_block_height              protoreflect.FieldDescriptor
-	fd_QueryGetAllParticipantCurrentStatsResponse_epoch_id                  protoreflect.FieldDescriptor
-)
+var (
+	md_QueryGetParticipantCurrentStatsResponse            protoreflect.MessageDescriptor
+	fd_QueryGetParticipantCurrentStatsResponse_weight     protoreflect.FieldDescriptor
+	fd_QueryGetParticipantCurrentStatsResponse_reputation protoreflect.FieldDescriptor
+)
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetAllParticipantCurrentStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetAllParticipantCurrentStatsResponse")
-	fd_QueryGetAllParticipantCurrentStatsResponse_participant_current_stats = md_QueryGetAllParticipantCurrentStatsResponse.Fields().ByName("participant_current_stats")
-	fd_QueryGetAllParticipantCurrentStatsResponse_block_height = md_QueryGetAllParticipantCurrentStatsResponse.Fields().ByName("block_height")
-	fd_QueryGetAllParticipantCurrentStatsResponse_epoch_id = md_QueryGetAllParticipantCurrentStatsResponse.Fields().ByName("epoch_id")
+	md_QueryGetParticipantCurrentStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetParticipantCurrentStatsResponse")
+	fd_QueryGetParticipantCurrentStatsResponse_weight = md_QueryGetParticipantCurrentStatsResponse.Fields().ByName("weight")
+	fd_QueryGetParticipantCurrentStatsResponse_reputation = md_QueryGetParticipantCurrentStatsResponse.Fields().ByName("reputation")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetParticipantCurrentStatsResponse)(nil)
 
-type fastReflection_QueryGetAllParticipantCurrentStatsResponse QueryGetAllParticipantCurrentStatsResponse
+type fastReflection_QueryGetParticipantCurrentStatsResponse QueryGetParticipantCurrentStatsResponse
 
-func (x *QueryGetAllParticipantCurrentStatsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(x)
+func (x *QueryGetParticipantCurrentStatsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetParticipantCurrentStatsResponse)(x)
 }
 
-func (x *QueryGetAllParticipantCurrentStatsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetParticipantCurrentStatsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[81]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -38555,43 +38549,43 @@ func (x *QueryGetAllParticipantCurrentStatsResponse) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType{}
+var _fastReflection_QueryGetParticipantCurrentStatsResponse_messageType fastReflection_QueryGetParticipantCurrentStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetParticipantCurrentStatsResponse_messageType{}
 
-type fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType struct{}
+type fastReflection_QueryGetParticipantCurrentStatsResponse_messageType struct{}
 
-func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(nil)
+func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetParticipantCurrentStatsResponse)(nil)
 }
-func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllParticipantCurrentStatsResponse)
+func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetParticipantCurrentStatsResponse)
 }
-func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllParticipantCurrentStatsResponse
+func (x fastReflection_QueryGetParticipantCurrentStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetParticipantCurrentStatsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllParticipantCurrentStatsResponse
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetParticipantCurrentStatsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetParticipantCurrentStatsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllParticipantCurrentStatsResponse)
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetParticipantCurrentStatsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetAllParticipantCurrentStatsResponse)(x)
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetParticipantCurrentStatsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -38599,22 +38593,16 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.ParticipantCurrentStats) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &x.ParticipantCurrentStats})
-		if !f(fd_QueryGetAllParticipantCurrentStatsResponse_participant_current_stats, value) {
-			return
-		}
-	}
-	if x.BlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.BlockHeight)
-		if !f(fd_QueryGetAllParticipantCurrentStatsResponse_block_height, value) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Weight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Weight)
+		if !f(fd_QueryGetParticipantCurrentStatsResponse_weight, value) {
 			return
 		}
 	}
-	if x.EpochId != int64(0) {
-		value := protoreflect.ValueOfInt64(x.EpochId)
-		if !f(fd_QueryGetAllParticipantCurrentStatsResponse_epoch_id, value) {
+	if x.Reputation != int32(0) {
+		value := protoreflect.ValueOfInt32(x.Reputation)
+		if !f(fd_QueryGetParticipantCurrentStatsResponse_reputation, value) {
 			return
 		}
 	}
@@ -38631,19 +38619,17 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
-		return len(x.ParticipantCurrentStats) != 0
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
-		return x.BlockHeight != int64(0)
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
-		return x.EpochId != int64(0)
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
+		return x.Weight != uint64(0)
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
+		return x.Reputation != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38653,19 +38639,17 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
-		x.ParticipantCurrentStats = nil
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
-		x.BlockHeight = int64(0)
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
-		x.EpochId = int64(0)
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
+		x.Weight = uint64(0)
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
+		x.Reputation = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38675,25 +38659,19 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
-		if len(x.ParticipantCurrentStats) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetAllParticipantCurrentStatsResponse_1_list{})
-		}
-		listValue := &_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &x.ParticipantCurrentStats}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
-		value := x.EpochId
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
+		value := x.Weight
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
+		value := x.Reputation
+		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -38707,21 +38685,17 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
-		lv := value.List()
-		clv := lv.(*_QueryGetAllParticipantCurrentStatsResponse_1_list)
-		x.ParticipantCurrentStats = *clv.list
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
-		x.BlockHeight = value.Int()
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
-		x.EpochId = value.Int()
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
+		x.Weight = value.Uint()
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
+		x.Reputation = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38735,53 +38709,44 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
-		if x.ParticipantCurrentStats == nil {
-			x.ParticipantCurrentStats = []*ParticipantCurrentStats{}
-		}
-		value := &_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &x.ParticipantCurrentStats}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryGetAllParticipantCurrentStatsResponse is not mutable"))
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
-		panic(fmt.Errorf("field epoch_id of message inference.inference.QueryGetAllParticipantCurrentStatsResponse is not mutable"))
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
+		panic(fmt.Errorf("field weight of message inference.inference.QueryGetParticipantCurrentStatsResponse is not mutable"))
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
+		panic(fmt.Errorf("field reputation of message inference.inference.QueryGetParticipantCurrentStatsResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
-		list := []*ParticipantCurrentStats{}
-		return protoreflect.ValueOfList(&_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &list})
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.weight":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetParticipantCurrentStatsResponse.reputation":
+		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllParticipantCurrentStatsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetParticipantCurrentStatsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -38789,7 +38754,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -38800,7 +38765,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -38812,7 +38777,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) IsValid() bool {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -38822,9 +38787,9 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetParticipantCurrentStatsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
+		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38836,17 +38801,11 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 		var n int
 		var l int
 		_ = l
-		if len(x.ParticipantCurrentStats) > 0 {
-			for _, e := range x.ParticipantCurrentStats {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if x.Weight != 0 {
+			n += 1 + runtime.Sov(uint64(x.Weight))
 		}
-		if x.EpochId != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochId))
+		if x.Reputation != 0 {
+			n += 1 + runtime.Sov(uint64(x.Reputation))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -38858,7 +38817,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
+		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38877,31 +38836,15 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
-			i--
-			dAtA[i] = 0x18
-		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
+		if x.Reputation != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reputation))
 			i--
 			dAtA[i] = 0x10
 		}
-		if len(x.ParticipantCurrentStats) > 0 {
-			for iNdEx := len(x.ParticipantCurrentStats) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.ParticipantCurrentStats[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if x.Weight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Weight))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -38914,7 +38857,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
+		x := input.Message.Interface().(*QueryGetParticipantCurrentStatsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38946,51 +38889,17 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantCurrentStats", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ParticipantCurrentStats = append(x.ParticipantCurrentStats, &ParticipantCurrentStats{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantCurrentStats[len(x.ParticipantCurrentStats)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
 				}
-				x.BlockHeight = 0
+				x.Weight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -39000,16 +38909,16 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= int64(b&0x7F) << shift
+					x.Weight |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 3:
+			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
 				}
-				x.EpochId = 0
+				x.Reputation = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -39019,7 +38928,7 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochId |= int64(b&0x7F) << shift
+					x.Reputation |= int32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -39060,33 +38969,23 @@ func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods
 }
 
 var (
-	md_ParticipantCurrentStats                  protoreflect.MessageDescriptor
-	fd_ParticipantCurrentStats_participant_id   protoreflect.FieldDescriptor
-	fd_ParticipantCurrentStats_weight           protoreflect.FieldDescriptor
-	fd_ParticipantCurrentStats_effective_weight protoreflect.FieldDescriptor
-	fd_ParticipantCurrentStats_capped_weight    protoreflect.FieldDescriptor
-	fd_ParticipantCurrentStats_reputation       protoreflect.FieldDescriptor
+	md_QueryGetAllParticipantCurrentStatsRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ParticipantCurrentStats = File_inference_inference_query_proto.Messages().ByName("ParticipantCurrentStats")
-	fd_ParticipantCurrentStats_participant_id = md_ParticipantCurrentStats.Fields().ByName("participant_id")
-	fd_ParticipantCurrentStats_weight = md_ParticipantCurrentStats.Fields().ByName("weight")
-	fd_ParticipantCurrentStats_effective_weight = md_ParticipantCurrentStats.Fields().ByName("effective_weight")
-	fd_ParticipantCurrentStats_capped_weight = md_ParticipantCurrentStats.Fields().ByName("capped_weight")
-	fd_ParticipantCurrentStats_reputation = md_ParticipantCurrentStats.Fields().ByName("reputation")
+	md_QueryGetAllParticipantCurrentStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllParticipantCurrentStatsRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_ParticipantCurrentStats)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(nil)
 
-type fastReflection_ParticipantCurrentStats ParticipantCurrentStats
+type fastReflection_QueryGetAllParticipantCurrentStatsRequest QueryGetAllParticipantCurrentStatsRequest
 
-func (x *ParticipantCurrentStats) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ParticipantCurrentStats)(x)
+func (x *QueryGetAllParticipantCurrentStatsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(x)
 }
 
-func (x *ParticipantCurrentStats) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetAllParticipantCurrentStatsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[82]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -39098,43 +38997,43 @@ func (x *ParticipantCurrentStats) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ParticipantCurrentStats_messageType fastReflection_ParticipantCurrentStats_messageType
-var _ protoreflect.MessageType = fastReflection_ParticipantCurrentStats_messageType{}
+var _fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType{}
 
-type fastReflection_ParticipantCurrentStats_messageType struct{}
+type fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType struct{}
 
-func (x fastReflection_ParticipantCurrentStats_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ParticipantCurrentStats)(nil)
+func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetAllParticipantCurrentStatsRequest)(nil)
 }
-func (x fastReflection_ParticipantCurrentStats_messageType) New() protoreflect.Message {
-	return new(fastReflection_ParticipantCurrentStats)
+func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllParticipantCurrentStatsRequest)
 }
-func (x fastReflection_ParticipantCurrentStats_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ParticipantCurrentStats
+func (x fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllParticipantCurrentStatsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ParticipantCurrentStats) Descriptor() protoreflect.MessageDescriptor {
-	return md_ParticipantCurrentStats
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllParticipantCurrentStatsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ParticipantCurrentStats) Type() protoreflect.MessageType {
-	return _fastReflection_ParticipantCurrentStats_messageType
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetAllParticipantCurrentStatsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ParticipantCurrentStats) New() protoreflect.Message {
-	return new(fastReflection_ParticipantCurrentStats)
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllParticipantCurrentStatsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ParticipantCurrentStats) Interface() protoreflect.ProtoMessage {
-	return (*ParticipantCurrentStats)(x)
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetAllParticipantCurrentStatsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -39142,37 +39041,7 @@ func (x *fastReflection_ParticipantCurrentStats) Interface() protoreflect.ProtoM
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ParticipantCurrentStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ParticipantId != "" {
-		value := protoreflect.ValueOfString(x.ParticipantId)
-		if !f(fd_ParticipantCurrentStats_participant_id, value) {
-			return
-		}
-	}
-	if x.Weight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Weight)
-		if !f(fd_ParticipantCurrentStats_weight, value) {
-			return
-		}
-	}
-	if x.EffectiveWeight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EffectiveWeight)
-		if !f(fd_ParticipantCurrentStats_effective_weight, value) {
-			return
-		}
-	}
-	if x.CappedWeight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.CappedWeight)
-		if !f(fd_ParticipantCurrentStats_capped_weight, value) {
-			return
-		}
-	}
-	if x.Reputation != int32(0) {
-		value := protoreflect.ValueOfInt32(x.Reputation)
-		if !f(fd_ParticipantCurrentStats_reputation, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -39186,23 +39055,13 @@ func (x *fastReflection_ParticipantCurrentStats) Range(f func(protoreflect.Field
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ParticipantCurrentStats) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantCurrentStats.participant_id":
-		return x.ParticipantId != ""
-	case "inference.inference.ParticipantCurrentStats.weight":
-		return x.Weight != uint64(0)
-	case "inference.inference.ParticipantCurrentStats.effective_weight":
-		return x.EffectiveWeight != uint64(0)
-	case "inference.inference.ParticipantCurrentStats.capped_weight":
-		return x.CappedWeight != uint64(0)
-	case "inference.inference.ParticipantCurrentStats.reputation":
-		return x.Reputation != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39212,23 +39071,13 @@ func (x *fastReflection_ParticipantCurrentStats) Has(fd protoreflect.FieldDescri
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantCurrentStats) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantCurrentStats.participant_id":
-		x.ParticipantId = ""
-	case "inference.inference.ParticipantCurrentStats.weight":
-		x.Weight = uint64(0)
-	case "inference.inference.ParticipantCurrentStats.effective_weight":
-		x.EffectiveWeight = uint64(0)
-	case "inference.inference.ParticipantCurrentStats.capped_weight":
-		x.CappedWeight = uint64(0)
-	case "inference.inference.ParticipantCurrentStats.reputation":
-		x.Reputation = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39238,28 +39087,13 @@ func (x *fastReflection_ParticipantCurrentStats) Clear(fd protoreflect.FieldDesc
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ParticipantCurrentStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ParticipantCurrentStats.participant_id":
-		value := x.ParticipantId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.ParticipantCurrentStats.weight":
-		value := x.Weight
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.ParticipantCurrentStats.effective_weight":
-		value := x.EffectiveWeight
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.ParticipantCurrentStats.capped_weight":
-		value := x.CappedWeight
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.ParticipantCurrentStats.reputation":
-		value := x.Reputation
-		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -39273,23 +39107,13 @@ func (x *fastReflection_ParticipantCurrentStats) Get(descriptor protoreflect.Fie
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantCurrentStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantCurrentStats.participant_id":
-		x.ParticipantId = value.Interface().(string)
-	case "inference.inference.ParticipantCurrentStats.weight":
-		x.Weight = value.Uint()
-	case "inference.inference.ParticipantCurrentStats.effective_weight":
-		x.EffectiveWeight = value.Uint()
-	case "inference.inference.ParticipantCurrentStats.capped_weight":
-		x.CappedWeight = value.Uint()
-	case "inference.inference.ParticipantCurrentStats.reputation":
-		x.Reputation = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39303,56 +39127,36 @@ func (x *fastReflection_ParticipantCurrentStats) Set(fd protoreflect.FieldDescri
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantCurrentStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantCurrentStats.participant_id":
-		panic(fmt.Errorf("field participant_id of message inference.inference.ParticipantCurrentStats is not mutable"))
-	case "inference.inference.ParticipantCurrentStats.weight":
-		panic(fmt.Errorf("field weight of message inference.inference.ParticipantCurrentStats is not mutable"))
-	case "inference.inference.ParticipantCurrentStats.effective_weight":
-		panic(fmt.Errorf("field effective_weight of message inference.inference.ParticipantCurrentStats is not mutable"))
-	case "inference.inference.ParticipantCurrentStats.capped_weight":
-		panic(fmt.Errorf("field capped_weight of message inference.inference.ParticipantCurrentStats is not mutable"))
-	case "inference.inference.ParticipantCurrentStats.reputation":
-		panic(fmt.Errorf("field reputation of message inference.inference.ParticipantCurrentStats is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ParticipantCurrentStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantCurrentStats.participant_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.ParticipantCurrentStats.weight":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.ParticipantCurrentStats.effective_weight":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.ParticipantCurrentStats.capped_weight":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.ParticipantCurrentStats.reputation":
-		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ParticipantCurrentStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParticipantCurrentStats", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllParticipantCurrentStatsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -39360,7 +39164,7 @@ func (x *fastReflection_ParticipantCurrentStats) WhichOneof(d protoreflect.Oneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ParticipantCurrentStats) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -39371,7 +39175,7 @@ func (x *fastReflection_ParticipantCurrentStats) GetUnknown() protoreflect.RawFi
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantCurrentStats) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -39383,7 +39187,7 @@ func (x *fastReflection_ParticipantCurrentStats) SetUnknown(fields protoreflect.
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ParticipantCurrentStats) IsValid() bool {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -39393,9 +39197,9 @@ func (x *fastReflection_ParticipantCurrentStats) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ParticipantCurrentStats)
+		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -39407,22 +39211,6 @@ func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Meth
 		var n int
 		var l int
 		_ = l
-		l = len(x.ParticipantId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.Weight != 0 {
-			n += 1 + runtime.Sov(uint64(x.Weight))
-		}
-		if x.EffectiveWeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.EffectiveWeight))
-		}
-		if x.CappedWeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.CappedWeight))
-		}
-		if x.Reputation != 0 {
-			n += 1 + runtime.Sov(uint64(x.Reputation))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -39433,7 +39221,7 @@ func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Meth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ParticipantCurrentStats)
+		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -39452,33 +39240,6 @@ func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Meth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.CappedWeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.CappedWeight))
-			i--
-			dAtA[i] = 0x28
-		}
-		if x.EffectiveWeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EffectiveWeight))
-			i--
-			dAtA[i] = 0x20
-		}
-		if x.Reputation != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reputation))
-			i--
-			dAtA[i] = 0x18
-		}
-		if x.Weight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Weight))
-			i--
-			dAtA[i] = 0x10
-		}
-		if len(x.ParticipantId) > 0 {
-			i -= len(x.ParticipantId)
-			copy(dAtA[i:], x.ParticipantId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantId)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -39490,7 +39251,7 @@ func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Meth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ParticipantCurrentStats)
+		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -39522,120 +39283,12 @@ func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Meth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantCurrentStats: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantCurrentStats: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ParticipantId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
-				}
-				x.Weight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Weight |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 4:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EffectiveWeight", wireType)
-				}
-				x.EffectiveWeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EffectiveWeight |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 5:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CappedWeight", wireType)
-				}
-				x.CappedWeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.CappedWeight |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
-				}
-				x.Reputation = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Reputation |= int32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -39671,36 +39324,81 @@ func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Meth
 	}
 }
 
+var _ protoreflect.List = (*_QueryGetAllParticipantCurrentStatsResponse_1_list)(nil)
+
+type _QueryGetAllParticipantCurrentStatsResponse_1_list struct {
+	list *[]*ParticipantCurrentStats
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ParticipantCurrentStats)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ParticipantCurrentStats)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ParticipantCurrentStats)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ParticipantCurrentStats)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetAllParticipantCurrentStatsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_ParticipantFullStats                             protoreflect.MessageDescriptor
-	fd_ParticipantFullStats_account_address             protoreflect.FieldDescriptor
-	fd_ParticipantFullStats_operator_address            protoreflect.FieldDescriptor
-	fd_ParticipantFullStats_reputation                  protoreflect.FieldDescriptor
-	fd_ParticipantFullStats_earned_coins_current_epoch  protoreflect.FieldDescriptor
-	fd_ParticipantFullStats_rewarded_coins_latest_epoch protoreflect.FieldDescriptor
-	fd_ParticipantFullStats_epochs_completed            protoreflect.FieldDescriptor
+	md_QueryGetAllParticipantCurrentStatsResponse                           protoreflect.MessageDescriptor
+	fd_QueryGetAllParticipantCurrentStatsResponse_participant_current_stats protoreflect.FieldDescriptor
+	fd_QueryGetAllParticipantCurrentStatsResponse_block_height              protoreflect.FieldDescriptor
+	fd_QueryGetAllParticipantCurrentStatsResponse_epoch_id                  protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ParticipantFullStats = File_inference_inference_query_proto.Messages().ByName("ParticipantFullStats")
-	fd_ParticipantFullStats_account_address = md_ParticipantFullStats.Fields().ByName("account_address")
-	fd_ParticipantFullStats_operator_address = md_ParticipantFullStats.Fields().ByName("operator_address")
-	fd_ParticipantFullStats_reputation = md_ParticipantFullStats.Fields().ByName("reputation")
-	fd_ParticipantFullStats_earned_coins_current_epoch = md_ParticipantFullStats.Fields().ByName("earned_coins_current_epoch")
-	fd_ParticipantFullStats_rewarded_coins_latest_epoch = md_ParticipantFullStats.Fields().ByName("rewarded_coins_latest_epoch")
-	fd_ParticipantFullStats_epochs_completed = md_ParticipantFullStats.Fields().ByName("epochs_completed")
+	md_QueryGetAllParticipantCurrentStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetAllParticipantCurrentStatsResponse")
+	fd_QueryGetAllParticipantCurrentStatsResponse_participant_current_stats = md_QueryGetAllParticipantCurrentStatsResponse.Fields().ByName("participant_current_stats")
+	fd_QueryGetAllParticipantCurrentStatsResponse_block_height = md_QueryGetAllParticipantCurrentStatsResponse.Fields().ByName("block_height")
+	fd_QueryGetAllParticipantCurrentStatsResponse_epoch_id = md_QueryGetAllParticipantCurrentStatsResponse.Fields().ByName("epoch_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_ParticipantFullStats)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(nil)
 
-type fastReflection_ParticipantFullStats ParticipantFullStats
+type fastReflection_QueryGetAllParticipantCurrentStatsResponse QueryGetAllParticipantCurrentStatsResponse
 
-func (x *ParticipantFullStats) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ParticipantFullStats)(x)
+func (x *QueryGetAllParticipantCurrentStatsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(x)
 }
 
-func (x *ParticipantFullStats) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetAllParticipantCurrentStatsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[83]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -39712,43 +39410,43 @@ func (x *ParticipantFullStats) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ParticipantFullStats_messageType fastReflection_ParticipantFullStats_messageType
-var _ protoreflect.MessageType = fastReflection_ParticipantFullStats_messageType{}
+var _fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType{}
 
-type fastReflection_ParticipantFullStats_messageType struct{}
+type fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType struct{}
 
-func (x fastReflection_ParticipantFullStats_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ParticipantFullStats)(nil)
+func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetAllParticipantCurrentStatsResponse)(nil)
 }
-func (x fastReflection_ParticipantFullStats_messageType) New() protoreflect.Message {
-	return new(fastReflection_ParticipantFullStats)
+func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllParticipantCurrentStatsResponse)
 }
-func (x fastReflection_ParticipantFullStats_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ParticipantFullStats
+func (x fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllParticipantCurrentStatsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ParticipantFullStats) Descriptor() protoreflect.MessageDescriptor {
-	return md_ParticipantFullStats
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllParticipantCurrentStatsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ParticipantFullStats) Type() protoreflect.MessageType {
-	return _fastReflection_ParticipantFullStats_messageType
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetAllParticipantCurrentStatsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ParticipantFullStats) New() protoreflect.Message {
-	return new(fastReflection_ParticipantFullStats)
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllParticipantCurrentStatsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ParticipantFullStats) Interface() protoreflect.ProtoMessage {
-	return (*ParticipantFullStats)(x)
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetAllParticipantCurrentStatsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -39756,40 +39454,22 @@ func (x *fastReflection_ParticipantFullStats) Interface() protoreflect.ProtoMess
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ParticipantFullStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.AccountAddress != "" {
-		value := protoreflect.ValueOfString(x.AccountAddress)
-		if !f(fd_ParticipantFullStats_account_address, value) {
-			return
-		}
-	}
-	if x.OperatorAddress != "" {
-		value := protoreflect.ValueOfString(x.OperatorAddress)
-		if !f(fd_ParticipantFullStats_operator_address, value) {
-			return
-		}
-	}
-	if x.Reputation != int32(0) {
-		value := protoreflect.ValueOfInt32(x.Reputation)
-		if !f(fd_ParticipantFullStats_reputation, value) {
-			return
-		}
-	}
-	if x.EarnedCoinsCurrentEpoch != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EarnedCoinsCurrentEpoch)
-		if !f(fd_ParticipantFullStats_earned_coins_current_epoch, value) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.ParticipantCurrentStats) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &x.ParticipantCurrentStats})
+		if !f(fd_QueryGetAllParticipantCurrentStatsResponse_participant_current_stats, value) {
 			return
 		}
 	}
-	if x.RewardedCoinsLatestEpoch != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.RewardedCoinsLatestEpoch)
-		if !f(fd_ParticipantFullStats_rewarded_coins_latest_epoch, value) {
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_QueryGetAllParticipantCurrentStatsResponse_block_height, value) {
 			return
 		}
 	}
-	if x.EpochsCompleted != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.EpochsCompleted)
-		if !f(fd_ParticipantFullStats_epochs_completed, value) {
+	if x.EpochId != int64(0) {
+		value := protoreflect.ValueOfInt64(x.EpochId)
+		if !f(fd_QueryGetAllParticipantCurrentStatsResponse_epoch_id, value) {
 			return
 		}
 	}
@@ -39806,25 +39486,19 @@ func (x *fastReflection_ParticipantFullStats) Range(f func(protoreflect.FieldDes
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ParticipantFullStats) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantFullStats.account_address":
-		return x.AccountAddress != ""
-	case "inference.inference.ParticipantFullStats.operator_address":
-		return x.OperatorAddress != ""
-	case "inference.inference.ParticipantFullStats.reputation":
-		return x.Reputation != int32(0)
-	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
-		return x.EarnedCoinsCurrentEpoch != uint64(0)
-	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
-		return x.RewardedCoinsLatestEpoch != uint64(0)
-	case "inference.inference.ParticipantFullStats.epochs_completed":
-		return x.EpochsCompleted != uint32(0)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
+		return len(x.ParticipantCurrentStats) != 0
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
+		return x.BlockHeight != int64(0)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
+		return x.EpochId != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39834,25 +39508,19 @@ func (x *fastReflection_ParticipantFullStats) Has(fd protoreflect.FieldDescripto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantFullStats) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantFullStats.account_address":
-		x.AccountAddress = ""
-	case "inference.inference.ParticipantFullStats.operator_address":
-		x.OperatorAddress = ""
-	case "inference.inference.ParticipantFullStats.reputation":
-		x.Reputation = int32(0)
-	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
-		x.EarnedCoinsCurrentEpoch = uint64(0)
-	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
-		x.RewardedCoinsLatestEpoch = uint64(0)
-	case "inference.inference.ParticipantFullStats.epochs_completed":
-		x.EpochsCompleted = uint32(0)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
+		x.ParticipantCurrentStats = nil
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
+		x.BlockHeight = int64(0)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
+		x.EpochId = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39862,31 +39530,25 @@ func (x *fastReflection_ParticipantFullStats) Clear(fd protoreflect.FieldDescrip
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ParticipantFullStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ParticipantFullStats.account_address":
-		value := x.AccountAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.ParticipantFullStats.operator_address":
-		value := x.OperatorAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.ParticipantFullStats.reputation":
-		value := x.Reputation
-		return protoreflect.ValueOfInt32(value)
-	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
-		value := x.EarnedCoinsCurrentEpoch
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
-		value := x.RewardedCoinsLatestEpoch
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.ParticipantFullStats.epochs_completed":
-		value := x.EpochsCompleted
-		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
+		if len(x.ParticipantCurrentStats) == 0 {
+			return protoreflect.ValueOfList(&_QueryGetAllParticipantCurrentStatsResponse_1_list{})
+		}
+		listValue := &_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &x.ParticipantCurrentStats}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
+		value := x.EpochId
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -39900,25 +39562,21 @@ func (x *fastReflection_ParticipantFullStats) Get(descriptor protoreflect.FieldD
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantFullStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantFullStats.account_address":
-		x.AccountAddress = value.Interface().(string)
-	case "inference.inference.ParticipantFullStats.operator_address":
-		x.OperatorAddress = value.Interface().(string)
-	case "inference.inference.ParticipantFullStats.reputation":
-		x.Reputation = int32(value.Int())
-	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
-		x.EarnedCoinsCurrentEpoch = value.Uint()
-	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
-		x.RewardedCoinsLatestEpoch = value.Uint()
-	case "inference.inference.ParticipantFullStats.epochs_completed":
-		x.EpochsCompleted = uint32(value.Uint())
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
+		lv := value.List()
+		clv := lv.(*_QueryGetAllParticipantCurrentStatsResponse_1_list)
+		x.ParticipantCurrentStats = *clv.list
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
+		x.BlockHeight = value.Int()
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
+		x.EpochId = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39932,60 +39590,53 @@ func (x *fastReflection_ParticipantFullStats) Set(fd protoreflect.FieldDescripto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantFullStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantFullStats.account_address":
-		panic(fmt.Errorf("field account_address of message inference.inference.ParticipantFullStats is not mutable"))
-	case "inference.inference.ParticipantFullStats.operator_address":
-		panic(fmt.Errorf("field operator_address of message inference.inference.ParticipantFullStats is not mutable"))
-	case "inference.inference.ParticipantFullStats.reputation":
-		panic(fmt.Errorf("field reputation of message inference.inference.ParticipantFullStats is not mutable"))
-	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
-		panic(fmt.Errorf("field earned_coins_current_epoch of message inference.inference.ParticipantFullStats is not mutable"))
-	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
-		panic(fmt.Errorf("field rewarded_coins_latest_epoch of message inference.inference.ParticipantFullStats is not mutable"))
-	case "inference.inference.ParticipantFullStats.epochs_completed":
-		panic(fmt.Errorf("field epochs_completed of message inference.inference.ParticipantFullStats is not mutable"))
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
+		if x.ParticipantCurrentStats == nil {
+			x.ParticipantCurrentStats = []*ParticipantCurrentStats{}
+		}
+		value := &_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &x.ParticipantCurrentStats}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryGetAllParticipantCurrentStatsResponse is not mutable"))
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
+		panic(fmt.Errorf("field epoch_id of message inference.inference.QueryGetAllParticipantCurrentStatsResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ParticipantFullStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantFullStats.account_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.ParticipantFullStats.operator_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.ParticipantFullStats.reputation":
-		return protoreflect.ValueOfInt32(int32(0))
-	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.ParticipantFullStats.epochs_completed":
-		return protoreflect.ValueOfUint32(uint32(0))
-	default:
-		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats":
+		list := []*ParticipantCurrentStats{}
+		return protoreflect.ValueOfList(&_QueryGetAllParticipantCurrentStatsResponse_1_list{list: &list})
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryGetAllParticipantCurrentStatsResponse.epoch_id":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllParticipantCurrentStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllParticipantCurrentStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ParticipantFullStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParticipantFullStats", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllParticipantCurrentStatsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -39993,7 +39644,7 @@ func (x *fastReflection_ParticipantFullStats) WhichOneof(d protoreflect.OneofDes
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ParticipantFullStats) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -40004,7 +39655,7 @@ func (x *fastReflection_ParticipantFullStats) GetUnknown() protoreflect.RawField
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantFullStats) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -40016,7 +39667,7 @@ func (x *fastReflection_ParticipantFullStats) SetUnknown(fields protoreflect.Raw
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ParticipantFullStats) IsValid() bool {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -40026,9 +39677,9 @@ func (x *fastReflection_ParticipantFullStats) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetAllParticipantCurrentStatsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ParticipantFullStats)
+		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -40040,25 +39691,17 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 		var n int
 		var l int
 		_ = l
-		l = len(x.AccountAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.OperatorAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.Reputation != 0 {
-			n += 1 + runtime.Sov(uint64(x.Reputation))
-		}
-		if x.EarnedCoinsCurrentEpoch != 0 {
-			n += 1 + runtime.Sov(uint64(x.EarnedCoinsCurrentEpoch))
+		if len(x.ParticipantCurrentStats) > 0 {
+			for _, e := range x.ParticipantCurrentStats {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
-		if x.RewardedCoinsLatestEpoch != 0 {
-			n += 1 + runtime.Sov(uint64(x.RewardedCoinsLatestEpoch))
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
 		}
-		if x.EpochsCompleted != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochsCompleted))
+		if x.EpochId != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochId))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -40070,7 +39713,7 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ParticipantFullStats)
+		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -40089,39 +39732,31 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochsCompleted != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsCompleted))
-			i--
-			dAtA[i] = 0x30
-		}
-		if x.RewardedCoinsLatestEpoch != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.RewardedCoinsLatestEpoch))
-			i--
-			dAtA[i] = 0x28
-		}
-		if x.EarnedCoinsCurrentEpoch != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EarnedCoinsCurrentEpoch))
-			i--
-			dAtA[i] = 0x20
-		}
-		if x.Reputation != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reputation))
+		if x.EpochId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochId))
 			i--
 			dAtA[i] = 0x18
 		}
-		if len(x.OperatorAddress) > 0 {
-			i -= len(x.OperatorAddress)
-			copy(dAtA[i:], x.OperatorAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OperatorAddress)))
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if len(x.AccountAddress) > 0 {
-			i -= len(x.AccountAddress)
-			copy(dAtA[i:], x.AccountAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AccountAddress)))
-			i--
-			dAtA[i] = 0xa
+		if len(x.ParticipantCurrentStats) > 0 {
+			for iNdEx := len(x.ParticipantCurrentStats) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.ParticipantCurrentStats[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -40134,7 +39769,7 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ParticipantFullStats)
+		x := input.Message.Interface().(*QueryGetAllParticipantCurrentStatsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -40166,17 +39801,17 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantFullStats: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantFullStats: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantCurrentStats", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -40186,99 +39821,31 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.AccountAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				x.ParticipantCurrentStats = append(x.ParticipantCurrentStats, &ParticipantCurrentStats{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantCurrentStats[len(x.ParticipantCurrentStats)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				x.OperatorAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
-				}
-				x.Reputation = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Reputation |= int32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 4:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EarnedCoinsCurrentEpoch", wireType)
-				}
-				x.EarnedCoinsCurrentEpoch = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EarnedCoinsCurrentEpoch |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 5:
+			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RewardedCoinsLatestEpoch", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				x.RewardedCoinsLatestEpoch = 0
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -40288,16 +39855,16 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.RewardedCoinsLatestEpoch |= uint64(b&0x7F) << shift
+					x.BlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 6:
+			case 3:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochsCompleted", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
 				}
-				x.EpochsCompleted = 0
+				x.EpochId = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -40307,7 +39874,7 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochsCompleted |= uint32(b&0x7F) << shift
+					x.EpochId |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -40348,23 +39915,33 @@ func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods
 }
 
 var (
-	md_QueryParticipantsFullStatsRequest protoreflect.MessageDescriptor
+	md_ParticipantCurrentStats                  protoreflect.MessageDescriptor
+	fd_ParticipantCurrentStats_participant_id   protoreflect.FieldDescriptor
+	fd_ParticipantCurrentStats_weight           protoreflect.FieldDescriptor
+	fd_ParticipantCurrentStats_effective_weight protoreflect.FieldDescriptor
+	fd_ParticipantCurrentStats_capped_weight    protoreflect.FieldDescriptor
+	fd_ParticipantCurrentStats_reputation       protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryParticipantsFullStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsFullStatsRequest")
+	md_ParticipantCurrentStats = File_inference_inference_query_proto.Messages().ByName("ParticipantCurrentStats")
+	fd_ParticipantCurrentStats_participant_id = md_ParticipantCurrentStats.Fields().ByName("participant_id")
+	fd_ParticipantCurrentStats_weight = md_ParticipantCurrentStats.Fields().ByName("weight")
+	fd_ParticipantCurrentStats_effective_weight = md_ParticipantCurrentStats.Fields().ByName("effective_weight")
+	fd_ParticipantCurrentStats_capped_weight = md_ParticipantCurrentStats.Fields().ByName("capped_weight")
+	fd_ParticipantCurrentStats_reputation = md_ParticipantCurrentStats.Fields().ByName("reputation")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryParticipantsFullStatsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_ParticipantCurrentStats)(nil)
 
-type fastReflection_QueryParticipantsFullStatsRequest QueryParticipantsFullStatsRequest
+type fastReflection_ParticipantCurrentStats ParticipantCurrentStats
 
-func (x *QueryParticipantsFullStatsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsFullStatsRequest)(x)
+func (x *ParticipantCurrentStats) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ParticipantCurrentStats)(x)
 }
 
-func (x *QueryParticipantsFullStatsRequest) slowProtoReflect() protoreflect.Message {
+func (x *ParticipantCurrentStats) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[84]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -40376,43 +39953,43 @@ func (x *QueryParticipantsFullStatsRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryParticipantsFullStatsRequest_messageType fastReflection_QueryParticipantsFullStatsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryParticipantsFullStatsRequest_messageType{}
+var _fastReflection_ParticipantCurrentStats_messageType fastReflection_ParticipantCurrentStats_messageType
+var _ protoreflect.MessageType = fastReflection_ParticipantCurrentStats_messageType{}
 
-type fastReflection_QueryParticipantsFullStatsRequest_messageType struct{}
+type fastReflection_ParticipantCurrentStats_messageType struct{}
 
-func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsFullStatsRequest)(nil)
+func (x fastReflection_ParticipantCurrentStats_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ParticipantCurrentStats)(nil)
 }
-func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsFullStatsRequest)
+func (x fastReflection_ParticipantCurrentStats_messageType) New() protoreflect.Message {
+	return new(fastReflection_ParticipantCurrentStats)
 }
-func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsFullStatsRequest
+func (x fastReflection_ParticipantCurrentStats_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ParticipantCurrentStats
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsFullStatsRequest
+func (x *fastReflection_ParticipantCurrentStats) Descriptor() protoreflect.MessageDescriptor {
+	return md_ParticipantCurrentStats
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryParticipantsFullStatsRequest_messageType
+func (x *fastReflection_ParticipantCurrentStats) Type() protoreflect.MessageType {
+	return _fastReflection_ParticipantCurrentStats_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsFullStatsRequest)
+func (x *fastReflection_ParticipantCurrentStats) New() protoreflect.Message {
+	return new(fastReflection_ParticipantCurrentStats)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryParticipantsFullStatsRequest)(x)
+func (x *fastReflection_ParticipantCurrentStats) Interface() protoreflect.ProtoMessage {
+	return (*ParticipantCurrentStats)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -40420,7 +39997,37 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_ParticipantCurrentStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ParticipantId != "" {
+		value := protoreflect.ValueOfString(x.ParticipantId)
+		if !f(fd_ParticipantCurrentStats_participant_id, value) {
+			return
+		}
+	}
+	if x.Weight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Weight)
+		if !f(fd_ParticipantCurrentStats_weight, value) {
+			return
+		}
+	}
+	if x.EffectiveWeight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EffectiveWeight)
+		if !f(fd_ParticipantCurrentStats_effective_weight, value) {
+			return
+		}
+	}
+	if x.CappedWeight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.CappedWeight)
+		if !f(fd_ParticipantCurrentStats_capped_weight, value) {
+			return
+		}
+	}
+	if x.Reputation != int32(0) {
+		value := protoreflect.ValueOfInt32(x.Reputation)
+		if !f(fd_ParticipantCurrentStats_reputation, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -40434,13 +40041,23 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ParticipantCurrentStats) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.ParticipantCurrentStats.participant_id":
+		return x.ParticipantId != ""
+	case "inference.inference.ParticipantCurrentStats.weight":
+		return x.Weight != uint64(0)
+	case "inference.inference.ParticipantCurrentStats.effective_weight":
+		return x.EffectiveWeight != uint64(0)
+	case "inference.inference.ParticipantCurrentStats.capped_weight":
+		return x.CappedWeight != uint64(0)
+	case "inference.inference.ParticipantCurrentStats.reputation":
+		return x.Reputation != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -40450,13 +40067,23 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ParticipantCurrentStats) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.ParticipantCurrentStats.participant_id":
+		x.ParticipantId = ""
+	case "inference.inference.ParticipantCurrentStats.weight":
+		x.Weight = uint64(0)
+	case "inference.inference.ParticipantCurrentStats.effective_weight":
+		x.EffectiveWeight = uint64(0)
+	case "inference.inference.ParticipantCurrentStats.capped_weight":
+		x.CappedWeight = uint64(0)
+	case "inference.inference.ParticipantCurrentStats.reputation":
+		x.Reputation = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -40466,13 +40093,28 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantCurrentStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.ParticipantCurrentStats.participant_id":
+		value := x.ParticipantId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.ParticipantCurrentStats.weight":
+		value := x.Weight
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ParticipantCurrentStats.effective_weight":
+		value := x.EffectiveWeight
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ParticipantCurrentStats.capped_weight":
+		value := x.CappedWeight
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ParticipantCurrentStats.reputation":
+		value := x.Reputation
+		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -40486,13 +40128,23 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ParticipantCurrentStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.ParticipantCurrentStats.participant_id":
+		x.ParticipantId = value.Interface().(string)
+	case "inference.inference.ParticipantCurrentStats.weight":
+		x.Weight = value.Uint()
+	case "inference.inference.ParticipantCurrentStats.effective_weight":
+		x.EffectiveWeight = value.Uint()
+	case "inference.inference.ParticipantCurrentStats.capped_weight":
+		x.CappedWeight = value.Uint()
+	case "inference.inference.ParticipantCurrentStats.reputation":
+		x.Reputation = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -40506,36 +40158,56 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantCurrentStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.ParticipantCurrentStats.participant_id":
+		panic(fmt.Errorf("field participant_id of message inference.inference.ParticipantCurrentStats is not mutable"))
+	case "inference.inference.ParticipantCurrentStats.weight":
+		panic(fmt.Errorf("field weight of message inference.inference.ParticipantCurrentStats is not mutable"))
+	case "inference.inference.ParticipantCurrentStats.effective_weight":
+		panic(fmt.Errorf("field effective_weight of message inference.inference.ParticipantCurrentStats is not mutable"))
+	case "inference.inference.ParticipantCurrentStats.capped_weight":
+		panic(fmt.Errorf("field capped_weight of message inference.inference.ParticipantCurrentStats is not mutable"))
+	case "inference.inference.ParticipantCurrentStats.reputation":
+		panic(fmt.Errorf("field reputation of message inference.inference.ParticipantCurrentStats is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantCurrentStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.ParticipantCurrentStats.participant_id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.ParticipantCurrentStats.weight":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ParticipantCurrentStats.effective_weight":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ParticipantCurrentStats.capped_weight":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ParticipantCurrentStats.reputation":
+		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantCurrentStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantCurrentStats does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ParticipantCurrentStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsFullStatsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParticipantCurrentStats", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -40543,7 +40215,7 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ParticipantCurrentStats) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -40554,7 +40226,7 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ParticipantCurrentStats) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -40566,7 +40238,7 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) IsValid() bool {
+func (x *fastReflection_ParticipantCurrentStats) IsValid() bool {
 	return x != nil
 }
 
@@ -40576,9 +40248,9 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ParticipantCurrentStats) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
+		x := input.Message.Interface().(*ParticipantCurrentStats)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -40590,6 +40262,22 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
+		l = len(x.ParticipantId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Weight != 0 {
+			n += 1 + runtime.Sov(uint64(x.Weight))
+		}
+		if x.EffectiveWeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.EffectiveWeight))
+		}
+		if x.CappedWeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.CappedWeight))
+		}
+		if x.Reputation != 0 {
+			n += 1 + runtime.Sov(uint64(x.Reputation))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -40600,7 +40288,7 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
+		x := input.Message.Interface().(*ParticipantCurrentStats)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -40619,6 +40307,33 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.CappedWeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CappedWeight))
+			i--
+			dAtA[i] = 0x28
+		}
+		if x.EffectiveWeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EffectiveWeight))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.Reputation != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reputation))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.Weight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Weight))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.ParticipantId) > 0 {
+			i -= len(x.ParticipantId)
+			copy(dAtA[i:], x.ParticipantId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ParticipantId)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -40630,7 +40345,7 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
+		x := input.Message.Interface().(*ParticipantCurrentStats)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -40662,36 +40377,144 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantCurrentStats: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantCurrentStats: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
 				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				if (iNdEx + skippy) > l {
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if !options.DiscardUnknown {
-					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				x.ParticipantId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
 				}
-				iNdEx += skippy
-			}
-		}
-
-		if iNdEx > l {
-			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-		}
-		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
-	}
+				x.Weight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Weight |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EffectiveWeight", wireType)
+				}
+				x.EffectiveWeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EffectiveWeight |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CappedWeight", wireType)
+				}
+				x.CappedWeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.CappedWeight |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
+				}
+				x.Reputation = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Reputation |= int32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
 	return &protoiface.Methods{
 		NoUnkeyedLiterals: struct{}{},
 		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
@@ -40703,77 +40526,36 @@ func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *proto
 	}
 }
 
-var _ protoreflect.List = (*_QueryParticipantsFullStatsResponse_1_list)(nil)
-
-type _QueryParticipantsFullStatsResponse_1_list struct {
-	list *[]*ParticipantFullStats
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ParticipantFullStats)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ParticipantFullStats)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ParticipantFullStats)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ParticipantFullStats)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryParticipantsFullStatsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryParticipantsFullStatsResponse                    protoreflect.MessageDescriptor
-	fd_QueryParticipantsFullStatsResponse_participants_stats protoreflect.FieldDescriptor
+	md_ParticipantFullStats                             protoreflect.MessageDescriptor
+	fd_ParticipantFullStats_account_address             protoreflect.FieldDescriptor
+	fd_ParticipantFullStats_operator_address            protoreflect.FieldDescriptor
+	fd_ParticipantFullStats_reputation                  protoreflect.FieldDescriptor
+	fd_ParticipantFullStats_earned_coins_current_epoch  protoreflect.FieldDescriptor
+	fd_ParticipantFullStats_rewarded_coins_latest_epoch protoreflect.FieldDescriptor
+	fd_ParticipantFullStats_epochs_completed            protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryParticipantsFullStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsFullStatsResponse")
-	fd_QueryParticipantsFullStatsResponse_participants_stats = md_QueryParticipantsFullStatsResponse.Fields().ByName("participants_stats")
+	md_ParticipantFullStats = File_inference_inference_query_proto.Messages().ByName("ParticipantFullStats")
+	fd_ParticipantFullStats_account_address = md_ParticipantFullStats.Fields().ByName("account_address")
+	fd_ParticipantFullStats_operator_address = md_ParticipantFullStats.Fields().ByName("operator_address")
+	fd_ParticipantFullStats_reputation = md_ParticipantFullStats.Fields().ByName("reputation")
+	fd_ParticipantFullStats_earned_coins_current_epoch = md_ParticipantFullStats.Fields().ByName("earned_coins_current_epoch")
+	fd_ParticipantFullStats_rewarded_coins_latest_epoch = md_ParticipantFullStats.Fields().ByName("rewarded_coins_latest_epoch")
+	fd_ParticipantFullStats_epochs_completed = md_ParticipantFullStats.Fields().ByName("epochs_completed")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryParticipantsFullStatsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_ParticipantFullStats)(nil)
 
-type fastReflection_QueryParticipantsFullStatsResponse QueryParticipantsFullStatsResponse
+type fastReflection_ParticipantFullStats ParticipantFullStats
 
-func (x *QueryParticipantsFullStatsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsFullStatsResponse)(x)
+func (x *ParticipantFullStats) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ParticipantFullStats)(x)
 }
 
-func (x *QueryParticipantsFullStatsResponse) slowProtoReflect() protoreflect.Message {
+func (x *ParticipantFullStats) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[85]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -40785,43 +40567,43 @@ func (x *QueryParticipantsFullStatsResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryParticipantsFullStatsResponse_messageType fastReflection_QueryParticipantsFullStatsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryParticipantsFullStatsResponse_messageType{}
+var _fastReflection_ParticipantFullStats_messageType fastReflection_ParticipantFullStats_messageType
+var _ protoreflect.MessageType = fastReflection_ParticipantFullStats_messageType{}
 
-type fastReflection_QueryParticipantsFullStatsResponse_messageType struct{}
+type fastReflection_ParticipantFullStats_messageType struct{}
 
-func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsFullStatsResponse)(nil)
+func (x fastReflection_ParticipantFullStats_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ParticipantFullStats)(nil)
 }
-func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsFullStatsResponse)
+func (x fastReflection_ParticipantFullStats_messageType) New() protoreflect.Message {
+	return new(fastReflection_ParticipantFullStats)
 }
-func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsFullStatsResponse
+func (x fastReflection_ParticipantFullStats_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ParticipantFullStats
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsFullStatsResponse
+func (x *fastReflection_ParticipantFullStats) Descriptor() protoreflect.MessageDescriptor {
+	return md_ParticipantFullStats
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryParticipantsFullStatsResponse_messageType
+func (x *fastReflection_ParticipantFullStats) Type() protoreflect.MessageType {
+	return _fastReflection_ParticipantFullStats_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsFullStatsResponse)
+func (x *fastReflection_ParticipantFullStats) New() protoreflect.Message {
+	return new(fastReflection_ParticipantFullStats)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryParticipantsFullStatsResponse)(x)
+func (x *fastReflection_ParticipantFullStats) Interface() protoreflect.ProtoMessage {
+	return (*ParticipantFullStats)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -40829,10 +40611,40 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.ParticipantsStats) != 0 {
-		value := protoreflect.ValueOfList(&_QueryParticipantsFullStatsResponse_1_list{list: &x.ParticipantsStats})
-		if !f(fd_QueryParticipantsFullStatsResponse_participants_stats, value) {
+func (x *fastReflection_ParticipantFullStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.AccountAddress != "" {
+		value := protoreflect.ValueOfString(x.AccountAddress)
+		if !f(fd_ParticipantFullStats_account_address, value) {
+			return
+		}
+	}
+	if x.OperatorAddress != "" {
+		value := protoreflect.ValueOfString(x.OperatorAddress)
+		if !f(fd_ParticipantFullStats_operator_address, value) {
+			return
+		}
+	}
+	if x.Reputation != int32(0) {
+		value := protoreflect.ValueOfInt32(x.Reputation)
+		if !f(fd_ParticipantFullStats_reputation, value) {
+			return
+		}
+	}
+	if x.EarnedCoinsCurrentEpoch != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EarnedCoinsCurrentEpoch)
+		if !f(fd_ParticipantFullStats_earned_coins_current_epoch, value) {
+			return
+		}
+	}
+	if x.RewardedCoinsLatestEpoch != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.RewardedCoinsLatestEpoch)
+		if !f(fd_ParticipantFullStats_rewarded_coins_latest_epoch, value) {
+			return
+		}
+	}
+	if x.EpochsCompleted != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.EpochsCompleted)
+		if !f(fd_ParticipantFullStats_epochs_completed, value) {
 			return
 		}
 	}
@@ -40849,15 +40661,25 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ParticipantFullStats) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
-		return len(x.ParticipantsStats) != 0
+	case "inference.inference.ParticipantFullStats.account_address":
+		return x.AccountAddress != ""
+	case "inference.inference.ParticipantFullStats.operator_address":
+		return x.OperatorAddress != ""
+	case "inference.inference.ParticipantFullStats.reputation":
+		return x.Reputation != int32(0)
+	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
+		return x.EarnedCoinsCurrentEpoch != uint64(0)
+	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
+		return x.RewardedCoinsLatestEpoch != uint64(0)
+	case "inference.inference.ParticipantFullStats.epochs_completed":
+		return x.EpochsCompleted != uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -40867,15 +40689,25 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ParticipantFullStats) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
-		x.ParticipantsStats = nil
+	case "inference.inference.ParticipantFullStats.account_address":
+		x.AccountAddress = ""
+	case "inference.inference.ParticipantFullStats.operator_address":
+		x.OperatorAddress = ""
+	case "inference.inference.ParticipantFullStats.reputation":
+		x.Reputation = int32(0)
+	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
+		x.EarnedCoinsCurrentEpoch = uint64(0)
+	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
+		x.RewardedCoinsLatestEpoch = uint64(0)
+	case "inference.inference.ParticipantFullStats.epochs_completed":
+		x.EpochsCompleted = uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -40885,19 +40717,31 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantFullStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
-		if len(x.ParticipantsStats) == 0 {
-			return protoreflect.ValueOfList(&_QueryParticipantsFullStatsResponse_1_list{})
-		}
-		listValue := &_QueryParticipantsFullStatsResponse_1_list{list: &x.ParticipantsStats}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.ParticipantFullStats.account_address":
+		value := x.AccountAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.ParticipantFullStats.operator_address":
+		value := x.OperatorAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.ParticipantFullStats.reputation":
+		value := x.Reputation
+		return protoreflect.ValueOfInt32(value)
+	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
+		value := x.EarnedCoinsCurrentEpoch
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
+		value := x.RewardedCoinsLatestEpoch
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.ParticipantFullStats.epochs_completed":
+		value := x.EpochsCompleted
+		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -40911,17 +40755,25 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ParticipantFullStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
-		lv := value.List()
-		clv := lv.(*_QueryParticipantsFullStatsResponse_1_list)
-		x.ParticipantsStats = *clv.list
+	case "inference.inference.ParticipantFullStats.account_address":
+		x.AccountAddress = value.Interface().(string)
+	case "inference.inference.ParticipantFullStats.operator_address":
+		x.OperatorAddress = value.Interface().(string)
+	case "inference.inference.ParticipantFullStats.reputation":
+		x.Reputation = int32(value.Int())
+	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
+		x.EarnedCoinsCurrentEpoch = value.Uint()
+	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
+		x.RewardedCoinsLatestEpoch = value.Uint()
+	case "inference.inference.ParticipantFullStats.epochs_completed":
+		x.EpochsCompleted = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -40935,45 +40787,60 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantFullStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
-		if x.ParticipantsStats == nil {
-			x.ParticipantsStats = []*ParticipantFullStats{}
-		}
-		value := &_QueryParticipantsFullStatsResponse_1_list{list: &x.ParticipantsStats}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.ParticipantFullStats.account_address":
+		panic(fmt.Errorf("field account_address of message inference.inference.ParticipantFullStats is not mutable"))
+	case "inference.inference.ParticipantFullStats.operator_address":
+		panic(fmt.Errorf("field operator_address of message inference.inference.ParticipantFullStats is not mutable"))
+	case "inference.inference.ParticipantFullStats.reputation":
+		panic(fmt.Errorf("field reputation of message inference.inference.ParticipantFullStats is not mutable"))
+	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
+		panic(fmt.Errorf("field earned_coins_current_epoch of message inference.inference.ParticipantFullStats is not mutable"))
+	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
+		panic(fmt.Errorf("field rewarded_coins_latest_epoch of message inference.inference.ParticipantFullStats is not mutable"))
+	case "inference.inference.ParticipantFullStats.epochs_completed":
+		panic(fmt.Errorf("field epochs_completed of message inference.inference.ParticipantFullStats is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantFullStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
-		list := []*ParticipantFullStats{}
-		return protoreflect.ValueOfList(&_QueryParticipantsFullStatsResponse_1_list{list: &list})
+	case "inference.inference.ParticipantFullStats.account_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.ParticipantFullStats.operator_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.ParticipantFullStats.reputation":
+		return protoreflect.ValueOfInt32(int32(0))
+	case "inference.inference.ParticipantFullStats.earned_coins_current_epoch":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ParticipantFullStats.rewarded_coins_latest_epoch":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.ParticipantFullStats.epochs_completed":
+		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantFullStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantFullStats does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ParticipantFullStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsFullStatsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParticipantFullStats", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -40981,7 +40848,7 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ParticipantFullStats) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -40992,7 +40859,7 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ParticipantFullStats) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -41004,7 +40871,7 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) IsValid() bool {
+func (x *fastReflection_ParticipantFullStats) IsValid() bool {
 	return x != nil
 }
 
@@ -41014,9 +40881,9 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ParticipantFullStats) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
+		x := input.Message.Interface().(*ParticipantFullStats)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -41028,11 +40895,25 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if len(x.ParticipantsStats) > 0 {
-			for _, e := range x.ParticipantsStats {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		l = len(x.AccountAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.OperatorAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Reputation != 0 {
+			n += 1 + runtime.Sov(uint64(x.Reputation))
+		}
+		if x.EarnedCoinsCurrentEpoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.EarnedCoinsCurrentEpoch))
+		}
+		if x.RewardedCoinsLatestEpoch != 0 {
+			n += 1 + runtime.Sov(uint64(x.RewardedCoinsLatestEpoch))
+		}
+		if x.EpochsCompleted != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochsCompleted))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -41044,7 +40925,7 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
+		x := input.Message.Interface().(*ParticipantFullStats)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -41063,21 +40944,39 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ParticipantsStats) > 0 {
-			for iNdEx := len(x.ParticipantsStats) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.ParticipantsStats[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if x.EpochsCompleted != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsCompleted))
+			i--
+			dAtA[i] = 0x30
+		}
+		if x.RewardedCoinsLatestEpoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.RewardedCoinsLatestEpoch))
+			i--
+			dAtA[i] = 0x28
+		}
+		if x.EarnedCoinsCurrentEpoch != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EarnedCoinsCurrentEpoch))
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.Reputation != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reputation))
+			i--
+			dAtA[i] = 0x18
+		}
+		if len(x.OperatorAddress) > 0 {
+			i -= len(x.OperatorAddress)
+			copy(dAtA[i:], x.OperatorAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OperatorAddress)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.AccountAddress) > 0 {
+			i -= len(x.AccountAddress)
+			copy(dAtA[i:], x.AccountAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AccountAddress)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -41090,7 +40989,7 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
+		x := input.Message.Interface().(*ParticipantFullStats)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -41122,17 +41021,17 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantFullStats: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantFullStats: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantsStats", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -41142,42 +41041,148 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ParticipantsStats = append(x.ParticipantsStats, &ParticipantFullStats{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantsStats[len(x.ParticipantsStats)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.AccountAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if (iNdEx + skippy) > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if !options.DiscardUnknown {
-					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
 				}
-				iNdEx += skippy
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.OperatorAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
+				}
+				x.Reputation = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Reputation |= int32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EarnedCoinsCurrentEpoch", wireType)
+				}
+				x.EarnedCoinsCurrentEpoch = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EarnedCoinsCurrentEpoch |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RewardedCoinsLatestEpoch", wireType)
+				}
+				x.RewardedCoinsLatestEpoch = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.RewardedCoinsLatestEpoch |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochsCompleted", wireType)
+				}
+				x.EpochsCompleted = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochsCompleted |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
 			}
 		}
 
@@ -41198,29 +41203,23 @@ func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *prot
 }
 
 var (
-	md_QueryStatsByTimePeriodByDeveloperRequest           protoreflect.MessageDescriptor
-	fd_QueryStatsByTimePeriodByDeveloperRequest_developer protoreflect.FieldDescriptor
-	fd_QueryStatsByTimePeriodByDeveloperRequest_time_from protoreflect.FieldDescriptor
-	fd_QueryStatsByTimePeriodByDeveloperRequest_time_to   protoreflect.FieldDescriptor
+	md_QueryParticipantsFullStatsRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryStatsByTimePeriodByDeveloperRequest = File_inference_inference_query_proto.Messages().ByName("QueryStatsByTimePeriodByDeveloperRequest")
-	fd_QueryStatsByTimePeriodByDeveloperRequest_developer = md_QueryStatsByTimePeriodByDeveloperRequest.Fields().ByName("developer")
-	fd_QueryStatsByTimePeriodByDeveloperRequest_time_from = md_QueryStatsByTimePeriodByDeveloperRequest.Fields().ByName("time_from")
-	fd_QueryStatsByTimePeriodByDeveloperRequest_time_to = md_QueryStatsByTimePeriodByDeveloperRequest.Fields().ByName("time_to")
+	md_QueryParticipantsFullStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsFullStatsRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryParticipantsFullStatsRequest)(nil)
 
-type fastReflection_QueryStatsByTimePeriodByDeveloperRequest QueryStatsByTimePeriodByDeveloperRequest
+type fastReflection_QueryParticipantsFullStatsRequest QueryParticipantsFullStatsRequest
 
-func (x *QueryStatsByTimePeriodByDeveloperRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(x)
+func (x *QueryParticipantsFullStatsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsFullStatsRequest)(x)
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryParticipantsFullStatsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[86]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -41232,43 +41231,43 @@ func (x *QueryStatsByTimePeriodByDeveloperRequest) slowProtoReflect() protorefle
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType{}
+var _fastReflection_QueryParticipantsFullStatsRequest_messageType fastReflection_QueryParticipantsFullStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantsFullStatsRequest_messageType{}
 
-type fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType struct{}
+type fastReflection_QueryParticipantsFullStatsRequest_messageType struct{}
 
-func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(nil)
+func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsFullStatsRequest)(nil)
 }
-func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryStatsByTimePeriodByDeveloperRequest)
+func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsFullStatsRequest)
 }
-func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryStatsByTimePeriodByDeveloperRequest
+func (x fastReflection_QueryParticipantsFullStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsFullStatsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryStatsByTimePeriodByDeveloperRequest
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsFullStatsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParticipantsFullStatsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryStatsByTimePeriodByDeveloperRequest)
+func (x *fastReflection_QueryParticipantsFullStatsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsFullStatsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryStatsByTimePeriodByDeveloperRequest)(x)
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryParticipantsFullStatsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -41276,25 +41275,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Interface() pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Developer != "" {
-		value := protoreflect.ValueOfString(x.Developer)
-		if !f(fd_QueryStatsByTimePeriodByDeveloperRequest_developer, value) {
-			return
-		}
-	}
-	if x.TimeFrom != int64(0) {
-		value := protoreflect.ValueOfInt64(x.TimeFrom)
-		if !f(fd_QueryStatsByTimePeriodByDeveloperRequest_time_from, value) {
-			return
-		}
-	}
-	if x.TimeTo != int64(0) {
-		value := protoreflect.ValueOfInt64(x.TimeTo)
-		if !f(fd_QueryStatsByTimePeriodByDeveloperRequest_time_to, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -41308,19 +41289,13 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Range(f func(p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
-		return x.Developer != ""
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
-		return x.TimeFrom != int64(0)
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
-		return x.TimeTo != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -41330,19 +41305,13 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Has(fd protore
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
-		x.Developer = ""
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
-		x.TimeFrom = int64(0)
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
-		x.TimeTo = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -41352,22 +41321,13 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Clear(fd proto
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
-		value := x.Developer
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
-		value := x.TimeFrom
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
-		value := x.TimeTo
-		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -41381,19 +41341,13 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
-		x.Developer = value.Interface().(string)
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
-		x.TimeFrom = value.Int()
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
-		x.TimeTo = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -41407,48 +41361,36 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Set(fd protore
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
-		panic(fmt.Errorf("field developer of message inference.inference.QueryStatsByTimePeriodByDeveloperRequest is not mutable"))
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
-		panic(fmt.Errorf("field time_from of message inference.inference.QueryStatsByTimePeriodByDeveloperRequest is not mutable"))
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
-		panic(fmt.Errorf("field time_to of message inference.inference.QueryStatsByTimePeriodByDeveloperRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
-		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryStatsByTimePeriodByDeveloperRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsFullStatsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -41456,7 +41398,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) WhichOneof(d p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -41467,7 +41409,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) GetUnknown() p
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -41479,7 +41421,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) SetUnknown(fie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) IsValid() bool {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -41489,9 +41431,9 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryParticipantsFullStatsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
+		x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -41503,16 +41445,6 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods()
 		var n int
 		var l int
 		_ = l
-		l = len(x.Developer)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.TimeFrom != 0 {
-			n += 1 + runtime.Sov(uint64(x.TimeFrom))
-		}
-		if x.TimeTo != 0 {
-			n += 1 + runtime.Sov(uint64(x.TimeTo))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -41523,7 +41455,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
+		x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -41542,23 +41474,6 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.TimeTo != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeTo))
-			i--
-			dAtA[i] = 0x18
-		}
-		if x.TimeFrom != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeFrom))
-			i--
-			dAtA[i] = 0x10
-		}
-		if len(x.Developer) > 0 {
-			i -= len(x.Developer)
-			copy(dAtA[i:], x.Developer)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Developer)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -41570,7 +41485,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
+		x := input.Message.Interface().(*QueryParticipantsFullStatsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -41602,82 +41517,12 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Developer = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
-				}
-				x.TimeFrom = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.TimeFrom |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
-				}
-				x.TimeTo = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.TimeTo |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -41713,77 +41558,77 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods()
 	}
 }
 
-var _ protoreflect.List = (*_QueryStatsByTimePeriodByDeveloperResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryParticipantsFullStatsResponse_1_list)(nil)
 
-type _QueryStatsByTimePeriodByDeveloperResponse_1_list struct {
-	list *[]*DeveloperStatsByTime
+type _QueryParticipantsFullStatsResponse_1_list struct {
+	list *[]*ParticipantFullStats
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Len() int {
+func (x *_QueryParticipantsFullStatsResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryParticipantsFullStatsResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryParticipantsFullStatsResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
+	concreteValue := valueUnwrapped.Interface().(*ParticipantFullStats)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryParticipantsFullStatsResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
+	concreteValue := valueUnwrapped.Interface().(*ParticipantFullStats)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(DeveloperStatsByTime)
+func (x *_QueryParticipantsFullStatsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ParticipantFullStats)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Truncate(n int) {
+func (x *_QueryParticipantsFullStatsResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) NewElement() protoreflect.Value {
-	v := new(DeveloperStatsByTime)
+func (x *_QueryParticipantsFullStatsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ParticipantFullStats)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) IsValid() bool {
+func (x *_QueryParticipantsFullStatsResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryStatsByTimePeriodByDeveloperResponse       protoreflect.MessageDescriptor
-	fd_QueryStatsByTimePeriodByDeveloperResponse_stats protoreflect.FieldDescriptor
+	md_QueryParticipantsFullStatsResponse                    protoreflect.MessageDescriptor
+	fd_QueryParticipantsFullStatsResponse_participants_stats protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryStatsByTimePeriodByDeveloperResponse = File_inference_inference_query_proto.Messages().ByName("QueryStatsByTimePeriodByDeveloperResponse")
-	fd_QueryStatsByTimePeriodByDeveloperResponse_stats = md_QueryStatsByTimePeriodByDeveloperResponse.Fields().ByName("stats")
+	md_QueryParticipantsFullStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsFullStatsResponse")
+	fd_QueryParticipantsFullStatsResponse_participants_stats = md_QueryParticipantsFullStatsResponse.Fields().ByName("participants_stats")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryParticipantsFullStatsResponse)(nil)
 
-type fastReflection_QueryStatsByTimePeriodByDeveloperResponse QueryStatsByTimePeriodByDeveloperResponse
+type fastReflection_QueryParticipantsFullStatsResponse QueryParticipantsFullStatsResponse
 
-func (x *QueryStatsByTimePeriodByDeveloperResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(x)
+func (x *QueryParticipantsFullStatsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsFullStatsResponse)(x)
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryParticipantsFullStatsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[87]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -41795,43 +41640,43 @@ func (x *QueryStatsByTimePeriodByDeveloperResponse) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType{}
+var _fastReflection_QueryParticipantsFullStatsResponse_messageType fastReflection_QueryParticipantsFullStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantsFullStatsResponse_messageType{}
 
-type fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType struct{}
+type fastReflection_QueryParticipantsFullStatsResponse_messageType struct{}
 
-func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(nil)
+func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsFullStatsResponse)(nil)
 }
-func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryStatsByTimePeriodByDeveloperResponse)
+func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsFullStatsResponse)
 }
-func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryStatsByTimePeriodByDeveloperResponse
+func (x fastReflection_QueryParticipantsFullStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsFullStatsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryStatsByTimePeriodByDeveloperResponse
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsFullStatsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParticipantsFullStatsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryStatsByTimePeriodByDeveloperResponse)
+func (x *fastReflection_QueryParticipantsFullStatsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsFullStatsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryStatsByTimePeriodByDeveloperResponse)(x)
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryParticipantsFullStatsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -41839,10 +41684,10 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Stats) != 0 {
-		value := protoreflect.ValueOfList(&_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &x.Stats})
-		if !f(fd_QueryStatsByTimePeriodByDeveloperResponse_stats, value) {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.ParticipantsStats) != 0 {
+		value := protoreflect.ValueOfList(&_QueryParticipantsFullStatsResponse_1_list{list: &x.ParticipantsStats})
+		if !f(fd_QueryParticipantsFullStatsResponse_participants_stats, value) {
 			return
 		}
 	}
@@ -41859,15 +41704,15 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
-		return len(x.Stats) != 0
+	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
+		return len(x.ParticipantsStats) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -41877,15 +41722,15 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
-		x.Stats = nil
+	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
+		x.ParticipantsStats = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -41895,19 +41740,19 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
-		if len(x.Stats) == 0 {
-			return protoreflect.ValueOfList(&_QueryStatsByTimePeriodByDeveloperResponse_1_list{})
+	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
+		if len(x.ParticipantsStats) == 0 {
+			return protoreflect.ValueOfList(&_QueryParticipantsFullStatsResponse_1_list{})
 		}
-		listValue := &_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &x.Stats}
+		listValue := &_QueryParticipantsFullStatsResponse_1_list{list: &x.ParticipantsStats}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -41921,17 +41766,17 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
 		lv := value.List()
-		clv := lv.(*_QueryStatsByTimePeriodByDeveloperResponse_1_list)
-		x.Stats = *clv.list
+		clv := lv.(*_QueryParticipantsFullStatsResponse_1_list)
+		x.ParticipantsStats = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -41945,45 +41790,45 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
-		if x.Stats == nil {
-			x.Stats = []*DeveloperStatsByTime{}
+	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
+		if x.ParticipantsStats == nil {
+			x.ParticipantsStats = []*ParticipantFullStats{}
 		}
-		value := &_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &x.Stats}
+		value := &_QueryParticipantsFullStatsResponse_1_list{list: &x.ParticipantsStats}
 		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
-		list := []*DeveloperStatsByTime{}
-		return protoreflect.ValueOfList(&_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &list})
+	case "inference.inference.QueryParticipantsFullStatsResponse.participants_stats":
+		list := []*ParticipantFullStats{}
+		return protoreflect.ValueOfList(&_QueryParticipantsFullStatsResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsFullStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsFullStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryStatsByTimePeriodByDeveloperResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsFullStatsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -41991,7 +41836,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -42002,7 +41847,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -42014,7 +41859,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) IsValid() bool {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -42024,9 +41869,9 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryParticipantsFullStatsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
+		x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42038,8 +41883,8 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		if len(x.Stats) > 0 {
-			for _, e := range x.Stats {
+		if len(x.ParticipantsStats) > 0 {
+			for _, e := range x.ParticipantsStats {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -42054,7 +41899,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
+		x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42073,9 +41918,9 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Stats) > 0 {
-			for iNdEx := len(x.Stats) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Stats[iNdEx])
+		if len(x.ParticipantsStats) > 0 {
+			for iNdEx := len(x.ParticipantsStats) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.ParticipantsStats[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42100,7 +41945,7 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
+		x := input.Message.Interface().(*QueryParticipantsFullStatsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42132,15 +41977,15 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsFullStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ParticipantsStats", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -42167,8 +42012,8 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Stats = append(x.Stats, &DeveloperStatsByTime{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats[len(x.Stats)-1]); err != nil {
+				x.ParticipantsStats = append(x.ParticipantsStats, &ParticipantFullStats{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ParticipantsStats[len(x.ParticipantsStats)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -42208,27 +42053,29 @@ func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods(
 }
 
 var (
-	md_QueryStatsByDeveloperAndEpochBackwardsRequest           protoreflect.MessageDescriptor
-	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer protoreflect.FieldDescriptor
-	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n  protoreflect.FieldDescriptor
+	md_QueryStatsByTimePeriodByDeveloperRequest           protoreflect.MessageDescriptor
+	fd_QueryStatsByTimePeriodByDeveloperRequest_developer protoreflect.FieldDescriptor
+	fd_QueryStatsByTimePeriodByDeveloperRequest_time_from protoreflect.FieldDescriptor
+	fd_QueryStatsByTimePeriodByDeveloperRequest_time_to   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryStatsByDeveloperAndEpochBackwardsRequest = File_inference_inference_query_proto.Messages().ByName("QueryStatsByDeveloperAndEpochBackwardsRequest")
-	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer = md_QueryStatsByDeveloperAndEpochBackwardsRequest.Fields().ByName("developer")
-	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n = md_QueryStatsByDeveloperAndEpochBackwardsRequest.Fields().ByName("epochs_n")
+	md_QueryStatsByTimePeriodByDeveloperRequest = File_inference_inference_query_proto.Messages().ByName("QueryStatsByTimePeriodByDeveloperRequest")
+	fd_QueryStatsByTimePeriodByDeveloperRequest_developer = md_QueryStatsByTimePeriodByDeveloperRequest.Fields().ByName("developer")
+	fd_QueryStatsByTimePeriodByDeveloperRequest_time_from = md_QueryStatsByTimePeriodByDeveloperRequest.Fields().ByName("time_from")
+	fd_QueryStatsByTimePeriodByDeveloperRequest_time_to = md_QueryStatsByTimePeriodByDeveloperRequest.Fields().ByName("time_to")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(nil)
 
-type fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest QueryStatsByDeveloperAndEpochBackwardsRequest
+type fastReflection_QueryStatsByTimePeriodByDeveloperRequest QueryStatsByTimePeriodByDeveloperRequest
 
-func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(x)
+func (x *QueryStatsByTimePeriodByDeveloperRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(x)
 }
 
-func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryStatsByTimePeriodByDeveloperRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[88]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -42240,43 +42087,43 @@ func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) slowProtoReflect() proto
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType{}
+var _fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType{}
 
-type fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType struct{}
+type fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType struct{}
 
-func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(nil)
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryStatsByTimePeriodByDeveloperRequest)(nil)
 }
-func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryStatsByTimePeriodByDeveloperRequest)
 }
-func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryStatsByDeveloperAndEpochBackwardsRequest
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryStatsByTimePeriodByDeveloperRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryStatsByDeveloperAndEpochBackwardsRequest
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryStatsByTimePeriodByDeveloperRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryStatsByTimePeriodByDeveloperRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryStatsByTimePeriodByDeveloperRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryStatsByDeveloperAndEpochBackwardsRequest)(x)
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryStatsByTimePeriodByDeveloperRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -42284,16 +42131,22 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Interface
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Developer != "" {
 		value := protoreflect.ValueOfString(x.Developer)
-		if !f(fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer, value) {
+		if !f(fd_QueryStatsByTimePeriodByDeveloperRequest_developer, value) {
 			return
 		}
 	}
-	if x.EpochsN != int32(0) {
-		value := protoreflect.ValueOfInt32(x.EpochsN)
-		if !f(fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n, value) {
+	if x.TimeFrom != int64(0) {
+		value := protoreflect.ValueOfInt64(x.TimeFrom)
+		if !f(fd_QueryStatsByTimePeriodByDeveloperRequest_time_from, value) {
+			return
+		}
+	}
+	if x.TimeTo != int64(0) {
+		value := protoreflect.ValueOfInt64(x.TimeTo)
+		if !f(fd_QueryStatsByTimePeriodByDeveloperRequest_time_to, value) {
 			return
 		}
 	}
@@ -42310,17 +42163,19 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Range(f f
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
 		return x.Developer != ""
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
-		return x.EpochsN != int32(0)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
+		return x.TimeFrom != int64(0)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
+		return x.TimeTo != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -42330,17 +42185,19 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Has(fd pr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
 		x.Developer = ""
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
-		x.EpochsN = int32(0)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
+		x.TimeFrom = int64(0)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
+		x.TimeTo = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -42350,19 +42207,22 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Clear(fd
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
 		value := x.Developer
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
-		value := x.EpochsN
-		return protoreflect.ValueOfInt32(value)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
+		value := x.TimeFrom
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
+		value := x.TimeTo
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -42376,17 +42236,19 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Get(descr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
 		x.Developer = value.Interface().(string)
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
-		x.EpochsN = int32(value.Int())
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
+		x.TimeFrom = value.Int()
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
+		x.TimeTo = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -42400,44 +42262,48 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Set(fd pr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
-		panic(fmt.Errorf("field developer of message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest is not mutable"))
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
-		panic(fmt.Errorf("field epochs_n of message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest is not mutable"))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
+		panic(fmt.Errorf("field developer of message inference.inference.QueryStatsByTimePeriodByDeveloperRequest is not mutable"))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
+		panic(fmt.Errorf("field time_from of message inference.inference.QueryStatsByTimePeriodByDeveloperRequest is not mutable"))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
+		panic(fmt.Errorf("field time_to of message inference.inference.QueryStatsByTimePeriodByDeveloperRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.developer":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
-		return protoreflect.ValueOfInt32(int32(0))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_from":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperRequest.time_to":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryStatsByTimePeriodByDeveloperRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -42445,7 +42311,7 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) WhichOneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -42456,7 +42322,7 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) GetUnknow
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -42468,7 +42334,7 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) SetUnknow
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) IsValid() bool {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -42478,9 +42344,9 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) IsValid()
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
+		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42496,8 +42362,11 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.EpochsN != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochsN))
+		if x.TimeFrom != 0 {
+			n += 1 + runtime.Sov(uint64(x.TimeFrom))
+		}
+		if x.TimeTo != 0 {
+			n += 1 + runtime.Sov(uint64(x.TimeTo))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -42509,7 +42378,7 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
+		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42528,8 +42397,13 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochsN != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsN))
+		if x.TimeTo != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeTo))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.TimeFrom != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeFrom))
 			i--
 			dAtA[i] = 0x10
 		}
@@ -42551,7 +42425,7 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
+		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42583,10 +42457,10 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -42623,9 +42497,9 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
 				}
-				x.EpochsN = 0
+				x.TimeFrom = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -42635,7 +42509,26 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochsN |= int32(b&0x7F) << shift
+					x.TimeFrom |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+				}
+				x.TimeTo = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.TimeTo |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -42675,26 +42568,77 @@ func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMeth
 	}
 }
 
+var _ protoreflect.List = (*_QueryStatsByTimePeriodByDeveloperResponse_1_list)(nil)
+
+type _QueryStatsByTimePeriodByDeveloperResponse_1_list struct {
+	list *[]*DeveloperStatsByTime
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(DeveloperStatsByTime)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) NewElement() protoreflect.Value {
+	v := new(DeveloperStatsByTime)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryStatsByTimePeriodByDeveloperResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest          protoreflect.MessageDescriptor
-	fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n protoreflect.FieldDescriptor
+	md_QueryStatsByTimePeriodByDeveloperResponse       protoreflect.MessageDescriptor
+	fd_QueryStatsByTimePeriodByDeveloperResponse_stats protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByEpochsBackwardsRequest")
-	fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n = md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest.Fields().ByName("epochs_n")
+	md_QueryStatsByTimePeriodByDeveloperResponse = File_inference_inference_query_proto.Messages().ByName("QueryStatsByTimePeriodByDeveloperResponse")
+	fd_QueryStatsByTimePeriodByDeveloperResponse_stats = md_QueryStatsByTimePeriodByDeveloperResponse.Fields().ByName("stats")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(nil)
 
-type fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest QueryInferencesAndTokensStatsByEpochsBackwardsRequest
+type fastReflection_QueryStatsByTimePeriodByDeveloperResponse QueryStatsByTimePeriodByDeveloperResponse
 
-func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(x)
+func (x *QueryStatsByTimePeriodByDeveloperResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(x)
 }
 
-func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryStatsByTimePeriodByDeveloperResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[89]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -42706,43 +42650,43 @@ func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) slowProtoReflect
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType{}
+var _fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType{}
 
-type fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType struct{}
+type fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType struct{}
 
-func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil)
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryStatsByTimePeriodByDeveloperResponse)(nil)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryStatsByTimePeriodByDeveloperResponse)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest
+func (x fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryStatsByTimePeriodByDeveloperResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryStatsByTimePeriodByDeveloperResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryStatsByTimePeriodByDeveloperResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryStatsByTimePeriodByDeveloperResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(x)
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryStatsByTimePeriodByDeveloperResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -42750,10 +42694,10 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) I
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochsN != int32(0) {
-		value := protoreflect.ValueOfInt32(x.EpochsN)
-		if !f(fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n, value) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Stats) != 0 {
+		value := protoreflect.ValueOfList(&_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &x.Stats})
+		if !f(fd_QueryStatsByTimePeriodByDeveloperResponse_stats, value) {
 			return
 		}
 	}
@@ -42770,15 +42714,15 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) R
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
-		return x.EpochsN != int32(0)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+		return len(x.Stats) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -42788,15 +42732,15 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) H
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
-		x.EpochsN = int32(0)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+		x.Stats = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -42806,16 +42750,19 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) C
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
-		value := x.EpochsN
-		return protoreflect.ValueOfInt32(value)
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+		if len(x.Stats) == 0 {
+			return protoreflect.ValueOfList(&_QueryStatsByTimePeriodByDeveloperResponse_1_list{})
+		}
+		listValue := &_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &x.Stats}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -42829,15 +42776,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) G
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
-		x.EpochsN = int32(value.Int())
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+		lv := value.List()
+		clv := lv.(*_QueryStatsByTimePeriodByDeveloperResponse_1_list)
+		x.Stats = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -42851,40 +42800,45 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) S
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
-		panic(fmt.Errorf("field epochs_n of message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest is not mutable"))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+		if x.Stats == nil {
+			x.Stats = []*DeveloperStatsByTime{}
+		}
+		value := &_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &x.Stats}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
-		return protoreflect.ValueOfInt32(int32(0))
+	case "inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats":
+		list := []*DeveloperStatsByTime{}
+		return protoreflect.ValueOfList(&_QueryStatsByTimePeriodByDeveloperResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByTimePeriodByDeveloperResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByTimePeriodByDeveloperResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryStatsByTimePeriodByDeveloperResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -42892,7 +42846,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) W
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -42903,7 +42857,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) G
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -42915,7 +42869,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) S
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) IsValid() bool {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -42925,9 +42879,9 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) I
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryStatsByTimePeriodByDeveloperResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42939,8 +42893,11 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 		var n int
 		var l int
 		_ = l
-		if x.EpochsN != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochsN))
+		if len(x.Stats) > 0 {
+			for _, e := range x.Stats {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -42952,7 +42909,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -42971,10 +42928,21 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochsN != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsN))
-			i--
-			dAtA[i] = 0x8
+		if len(x.Stats) > 0 {
+			for iNdEx := len(x.Stats) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Stats[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -42987,7 +42955,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
+		x := input.Message.Interface().(*QueryStatsByTimePeriodByDeveloperResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43019,17 +42987,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
 				}
-				x.EpochsN = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -43039,11 +43007,26 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochsN |= int32(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Stats = append(x.Stats, &DeveloperStatsByTime{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats[len(x.Stats)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -43080,27 +43063,27 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) P
 }
 
 var (
-	md_QueryInferencesAndTokensStatsByTimePeriodRequest           protoreflect.MessageDescriptor
-	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from protoreflect.FieldDescriptor
-	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to   protoreflect.FieldDescriptor
+	md_QueryStatsByDeveloperAndEpochBackwardsRequest           protoreflect.MessageDescriptor
+	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer protoreflect.FieldDescriptor
+	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n  protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryInferencesAndTokensStatsByTimePeriodRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByTimePeriodRequest")
-	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from = md_QueryInferencesAndTokensStatsByTimePeriodRequest.Fields().ByName("time_from")
-	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to = md_QueryInferencesAndTokensStatsByTimePeriodRequest.Fields().ByName("time_to")
+	md_QueryStatsByDeveloperAndEpochBackwardsRequest = File_inference_inference_query_proto.Messages().ByName("QueryStatsByDeveloperAndEpochBackwardsRequest")
+	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer = md_QueryStatsByDeveloperAndEpochBackwardsRequest.Fields().ByName("developer")
+	fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n = md_QueryStatsByDeveloperAndEpochBackwardsRequest.Fields().ByName("epochs_n")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(nil)
 
-type fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest QueryInferencesAndTokensStatsByTimePeriodRequest
+type fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest QueryStatsByDeveloperAndEpochBackwardsRequest
 
-func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(x)
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(x)
 }
 
-func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[90]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -43112,43 +43095,43 @@ func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) slowProtoReflect() pr
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType{}
+var _fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType{}
 
-type fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType struct{}
+type fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType struct{}
 
-func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(nil)
+func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)(nil)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)
+func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByTimePeriodRequest
+func (x fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryStatsByDeveloperAndEpochBackwardsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByTimePeriodRequest
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryStatsByDeveloperAndEpochBackwardsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryInferencesAndTokensStatsByTimePeriodRequest)(x)
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryStatsByDeveloperAndEpochBackwardsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -43156,16 +43139,16 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Interf
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.TimeFrom != int64(0) {
-		value := protoreflect.ValueOfInt64(x.TimeFrom)
-		if !f(fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from, value) {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Developer != "" {
+		value := protoreflect.ValueOfString(x.Developer)
+		if !f(fd_QueryStatsByDeveloperAndEpochBackwardsRequest_developer, value) {
 			return
 		}
 	}
-	if x.TimeTo != int64(0) {
-		value := protoreflect.ValueOfInt64(x.TimeTo)
-		if !f(fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to, value) {
+	if x.EpochsN != int32(0) {
+		value := protoreflect.ValueOfInt32(x.EpochsN)
+		if !f(fd_QueryStatsByDeveloperAndEpochBackwardsRequest_epochs_n, value) {
 			return
 		}
 	}
@@ -43182,17 +43165,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Range(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
-		return x.TimeFrom != int64(0)
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
-		return x.TimeTo != int64(0)
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+		return x.Developer != ""
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
+		return x.EpochsN != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -43202,17 +43185,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Has(fd
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
-		x.TimeFrom = int64(0)
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
-		x.TimeTo = int64(0)
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+		x.Developer = ""
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
+		x.EpochsN = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -43222,19 +43205,19 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Clear(
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
-		value := x.TimeFrom
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
-		value := x.TimeTo
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+		value := x.Developer
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
+		value := x.EpochsN
+		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -43248,17 +43231,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Get(de
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
-		x.TimeFrom = value.Int()
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
-		x.TimeTo = value.Int()
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+		x.Developer = value.Interface().(string)
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
+		x.EpochsN = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -43272,44 +43255,44 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Set(fd
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
-		panic(fmt.Errorf("field time_from of message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest is not mutable"))
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
-		panic(fmt.Errorf("field time_to of message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest is not mutable"))
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+		panic(fmt.Errorf("field developer of message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest is not mutable"))
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
+		panic(fmt.Errorf("field epochs_n of message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.developer":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest.epochs_n":
+		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -43317,7 +43300,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) WhichO
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -43328,7 +43311,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) GetUnk
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -43340,7 +43323,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) SetUnk
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) IsValid() bool {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -43350,9 +43333,9 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) IsVali
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
+		x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43364,11 +43347,12 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 		var n int
 		var l int
 		_ = l
-		if x.TimeFrom != 0 {
-			n += 1 + runtime.Sov(uint64(x.TimeFrom))
+		l = len(x.Developer)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.TimeTo != 0 {
-			n += 1 + runtime.Sov(uint64(x.TimeTo))
+		if x.EpochsN != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochsN))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -43380,7 +43364,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
+		x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43399,15 +43383,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.TimeTo != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeTo))
+		if x.EpochsN != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsN))
 			i--
-			dAtA[i] = 0x18
+			dAtA[i] = 0x10
 		}
-		if x.TimeFrom != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeFrom))
+		if len(x.Developer) > 0 {
+			i -= len(x.Developer)
+			copy(dAtA[i:], x.Developer)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Developer)))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -43420,7 +43406,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
+		x := input.Message.Interface().(*QueryStatsByDeveloperAndEpochBackwardsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43452,17 +43438,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
 				}
-				x.TimeFrom = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -43472,26 +43458,39 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.TimeFrom |= int64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				x.TimeTo = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.TimeTo |= int64(b&0x7F) << shift
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Developer = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
+				}
+				x.EpochsN = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochsN |= int32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -43532,27 +43531,25 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoM
 }
 
 var (
-	md_QueryInferencesAndTokensStatsByModelsRequest           protoreflect.MessageDescriptor
-	fd_QueryInferencesAndTokensStatsByModelsRequest_time_from protoreflect.FieldDescriptor
-	fd_QueryInferencesAndTokensStatsByModelsRequest_time_to   protoreflect.FieldDescriptor
+	md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest          protoreflect.MessageDescriptor
+	fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryInferencesAndTokensStatsByModelsRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByModelsRequest")
-	fd_QueryInferencesAndTokensStatsByModelsRequest_time_from = md_QueryInferencesAndTokensStatsByModelsRequest.Fields().ByName("time_from")
-	fd_QueryInferencesAndTokensStatsByModelsRequest_time_to = md_QueryInferencesAndTokensStatsByModelsRequest.Fields().ByName("time_to")
+	md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByEpochsBackwardsRequest")
+	fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n = md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest.Fields().ByName("epochs_n")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil)
 
-type fastReflection_QueryInferencesAndTokensStatsByModelsRequest QueryInferencesAndTokensStatsByModelsRequest
+type fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest QueryInferencesAndTokensStatsByEpochsBackwardsRequest
 
-func (x *QueryInferencesAndTokensStatsByModelsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(x)
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(x)
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[91]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -43564,43 +43561,43 @@ func (x *QueryInferencesAndTokensStatsByModelsRequest) slowProtoReflect() protor
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType{}
+var _fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType{}
 
-type fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType struct{}
+type fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType struct{}
 
-func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(nil)
+func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByModelsRequest)
+func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByModelsRequest
+func (x fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByModelsRequest
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByEpochsBackwardsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByModelsRequest)
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryInferencesAndTokensStatsByModelsRequest)(x)
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -43608,16 +43605,10 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Interface(
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.TimeFrom != int64(0) {
-		value := protoreflect.ValueOfInt64(x.TimeFrom)
-		if !f(fd_QueryInferencesAndTokensStatsByModelsRequest_time_from, value) {
-			return
-		}
-	}
-	if x.TimeTo != int64(0) {
-		value := protoreflect.ValueOfInt64(x.TimeTo)
-		if !f(fd_QueryInferencesAndTokensStatsByModelsRequest_time_to, value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochsN != int32(0) {
+		value := protoreflect.ValueOfInt32(x.EpochsN)
+		if !f(fd_QueryInferencesAndTokensStatsByEpochsBackwardsRequest_epochs_n, value) {
 			return
 		}
 	}
@@ -43634,17 +43625,15 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Range(f fu
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
-		return x.TimeFrom != int64(0)
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
-		return x.TimeTo != int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
+		return x.EpochsN != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -43654,17 +43643,15 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Has(fd pro
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
-		x.TimeFrom = int64(0)
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
-		x.TimeTo = int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
+		x.EpochsN = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -43674,19 +43661,16 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Clear(fd p
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
-		value := x.TimeFrom
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
-		value := x.TimeTo
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
+		value := x.EpochsN
+		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -43700,17 +43684,15 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Get(descri
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
-		x.TimeFrom = value.Int()
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
-		x.TimeTo = value.Int()
+	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
+		x.EpochsN = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -43724,44 +43706,40 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Set(fd pro
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
-		panic(fmt.Errorf("field time_from of message inference.inference.QueryInferencesAndTokensStatsByModelsRequest is not mutable"))
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
-		panic(fmt.Errorf("field time_to of message inference.inference.QueryInferencesAndTokensStatsByModelsRequest is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
+		panic(fmt.Errorf("field epochs_n of message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest.epochs_n":
+		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByModelsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -43769,7 +43747,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) WhichOneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -43780,7 +43758,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) GetUnknown
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -43792,7 +43770,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) SetUnknown
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) IsValid() bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -43802,9 +43780,9 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) IsValid()
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43816,11 +43794,8 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 		var n int
 		var l int
 		_ = l
-		if x.TimeFrom != 0 {
-			n += 1 + runtime.Sov(uint64(x.TimeFrom))
-		}
-		if x.TimeTo != 0 {
-			n += 1 + runtime.Sov(uint64(x.TimeTo))
+		if x.EpochsN != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochsN))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -43832,7 +43807,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43851,15 +43826,10 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.TimeTo != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeTo))
-			i--
-			dAtA[i] = 0x18
-		}
-		if x.TimeFrom != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeFrom))
+		if x.EpochsN != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochsN))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -43872,7 +43842,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -43904,36 +43874,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
-				}
-				x.TimeFrom = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.TimeFrom |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
+			case 1:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
 				}
-				x.TimeTo = 0
+				x.EpochsN = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -43943,7 +43894,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.TimeTo |= int64(b&0x7F) << shift
+					x.EpochsN |= int32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -43984,29 +43935,27 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMetho
 }
 
 var (
-	md_ModelStats            protoreflect.MessageDescriptor
-	fd_ModelStats_model      protoreflect.FieldDescriptor
-	fd_ModelStats_ai_tokens  protoreflect.FieldDescriptor
-	fd_ModelStats_inferences protoreflect.FieldDescriptor
+	md_QueryInferencesAndTokensStatsByTimePeriodRequest           protoreflect.MessageDescriptor
+	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from protoreflect.FieldDescriptor
+	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ModelStats = File_inference_inference_query_proto.Messages().ByName("ModelStats")
-	fd_ModelStats_model = md_ModelStats.Fields().ByName("model")
-	fd_ModelStats_ai_tokens = md_ModelStats.Fields().ByName("ai_tokens")
-	fd_ModelStats_inferences = md_ModelStats.Fields().ByName("inferences")
+	md_QueryInferencesAndTokensStatsByTimePeriodRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByTimePeriodRequest")
+	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from = md_QueryInferencesAndTokensStatsByTimePeriodRequest.Fields().ByName("time_from")
+	fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to = md_QueryInferencesAndTokensStatsByTimePeriodRequest.Fields().ByName("time_to")
 }
 
-var _ protoreflect.Message = (*fastReflection_ModelStats)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(nil)
 
-type fastReflection_ModelStats ModelStats
+type fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest QueryInferencesAndTokensStatsByTimePeriodRequest
 
-func (x *ModelStats) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ModelStats)(x)
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(x)
 }
 
-func (x *ModelStats) slowProtoReflect() protoreflect.Message {
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[92]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -44018,43 +43967,43 @@ func (x *ModelStats) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ModelStats_messageType fastReflection_ModelStats_messageType
-var _ protoreflect.MessageType = fastReflection_ModelStats_messageType{}
+var _fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType{}
 
-type fastReflection_ModelStats_messageType struct{}
+type fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType struct{}
 
-func (x fastReflection_ModelStats_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ModelStats)(nil)
+func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)(nil)
 }
-func (x fastReflection_ModelStats_messageType) New() protoreflect.Message {
-	return new(fastReflection_ModelStats)
+func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)
 }
-func (x fastReflection_ModelStats_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ModelStats
+func (x fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByTimePeriodRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ModelStats) Descriptor() protoreflect.MessageDescriptor {
-	return md_ModelStats
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByTimePeriodRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ModelStats) Type() protoreflect.MessageType {
-	return _fastReflection_ModelStats_messageType
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ModelStats) New() protoreflect.Message {
-	return new(fastReflection_ModelStats)
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ModelStats) Interface() protoreflect.ProtoMessage {
-	return (*ModelStats)(x)
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryInferencesAndTokensStatsByTimePeriodRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -44062,22 +44011,16 @@ func (x *fastReflection_ModelStats) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ModelStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Model != "" {
-		value := protoreflect.ValueOfString(x.Model)
-		if !f(fd_ModelStats_model, value) {
-			return
-		}
-	}
-	if x.AiTokens != int64(0) {
-		value := protoreflect.ValueOfInt64(x.AiTokens)
-		if !f(fd_ModelStats_ai_tokens, value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.TimeFrom != int64(0) {
+		value := protoreflect.ValueOfInt64(x.TimeFrom)
+		if !f(fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_from, value) {
 			return
 		}
 	}
-	if x.Inferences != int32(0) {
-		value := protoreflect.ValueOfInt32(x.Inferences)
-		if !f(fd_ModelStats_inferences, value) {
+	if x.TimeTo != int64(0) {
+		value := protoreflect.ValueOfInt64(x.TimeTo)
+		if !f(fd_QueryInferencesAndTokensStatsByTimePeriodRequest_time_to, value) {
 			return
 		}
 	}
@@ -44094,19 +44037,17 @@ func (x *fastReflection_ModelStats) Range(f func(protoreflect.FieldDescriptor, p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ModelStats) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ModelStats.model":
-		return x.Model != ""
-	case "inference.inference.ModelStats.ai_tokens":
-		return x.AiTokens != int64(0)
-	case "inference.inference.ModelStats.inferences":
-		return x.Inferences != int32(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
+		return x.TimeFrom != int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
+		return x.TimeTo != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -44116,19 +44057,17 @@ func (x *fastReflection_ModelStats) Has(fd protoreflect.FieldDescriptor) bool {
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelStats) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ModelStats.model":
-		x.Model = ""
-	case "inference.inference.ModelStats.ai_tokens":
-		x.AiTokens = int64(0)
-	case "inference.inference.ModelStats.inferences":
-		x.Inferences = int32(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
+		x.TimeFrom = int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
+		x.TimeTo = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -44138,22 +44077,19 @@ func (x *fastReflection_ModelStats) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ModelStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ModelStats.model":
-		value := x.Model
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.ModelStats.ai_tokens":
-		value := x.AiTokens
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
+		value := x.TimeFrom
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
+		value := x.TimeTo
 		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.ModelStats.inferences":
-		value := x.Inferences
-		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -44167,19 +44103,17 @@ func (x *fastReflection_ModelStats) Get(descriptor protoreflect.FieldDescriptor)
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ModelStats.model":
-		x.Model = value.Interface().(string)
-	case "inference.inference.ModelStats.ai_tokens":
-		x.AiTokens = value.Int()
-	case "inference.inference.ModelStats.inferences":
-		x.Inferences = int32(value.Int())
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
+		x.TimeFrom = value.Int()
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
+		x.TimeTo = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -44193,48 +44127,44 @@ func (x *fastReflection_ModelStats) Set(fd protoreflect.FieldDescriptor, value p
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ModelStats.model":
-		panic(fmt.Errorf("field model of message inference.inference.ModelStats is not mutable"))
-	case "inference.inference.ModelStats.ai_tokens":
-		panic(fmt.Errorf("field ai_tokens of message inference.inference.ModelStats is not mutable"))
-	case "inference.inference.ModelStats.inferences":
-		panic(fmt.Errorf("field inferences of message inference.inference.ModelStats is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
+		panic(fmt.Errorf("field time_from of message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
+		panic(fmt.Errorf("field time_to of message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ModelStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ModelStats.model":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.ModelStats.ai_tokens":
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_from":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest.time_to":
 		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.ModelStats.inferences":
-		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ModelStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelStats", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -44242,7 +44172,7 @@ func (x *fastReflection_ModelStats) WhichOneof(d protoreflect.OneofDescriptor) p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ModelStats) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -44253,7 +44183,7 @@ func (x *fastReflection_ModelStats) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelStats) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -44265,7 +44195,7 @@ func (x *fastReflection_ModelStats) SetUnknown(fields protoreflect.RawFields) {
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ModelStats) IsValid() bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -44275,9 +44205,9 @@ func (x *fastReflection_ModelStats) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ModelStats)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -44289,15 +44219,11 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		l = len(x.Model)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.AiTokens != 0 {
-			n += 1 + runtime.Sov(uint64(x.AiTokens))
+		if x.TimeFrom != 0 {
+			n += 1 + runtime.Sov(uint64(x.TimeFrom))
 		}
-		if x.Inferences != 0 {
-			n += 1 + runtime.Sov(uint64(x.Inferences))
+		if x.TimeTo != 0 {
+			n += 1 + runtime.Sov(uint64(x.TimeTo))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -44309,7 +44235,7 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ModelStats)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -44328,23 +44254,16 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Inferences != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Inferences))
+		if x.TimeTo != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeTo))
 			i--
 			dAtA[i] = 0x18
 		}
-		if x.AiTokens != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.AiTokens))
+		if x.TimeFrom != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeFrom))
 			i--
 			dAtA[i] = 0x10
 		}
-		if len(x.Model) > 0 {
-			i -= len(x.Model)
-			copy(dAtA[i:], x.Model)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Model)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -44356,7 +44275,7 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ModelStats)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByTimePeriodRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -44388,49 +44307,17 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelStats: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelStats: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Model = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
 				}
-				x.AiTokens = 0
+				x.TimeFrom = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -44440,16 +44327,16 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.AiTokens |= int64(b&0x7F) << shift
+					x.TimeFrom |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
 			case 3:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
 				}
-				x.Inferences = 0
+				x.TimeTo = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -44459,7 +44346,7 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Inferences |= int32(b&0x7F) << shift
+					x.TimeTo |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -44499,77 +44386,28 @@ func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 	}
 }
 
-var _ protoreflect.List = (*_QueryInferencesAndTokensStatsByModelsResponse_1_list)(nil)
-
-type _QueryInferencesAndTokensStatsByModelsResponse_1_list struct {
-	list *[]*ModelStats
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ModelStats)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ModelStats)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ModelStats)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ModelStats)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var (
-	md_QueryInferencesAndTokensStatsByModelsResponse              protoreflect.MessageDescriptor
-	fd_QueryInferencesAndTokensStatsByModelsResponse_stats_models protoreflect.FieldDescriptor
-)
+var (
+	md_QueryInferencesAndTokensStatsByModelsRequest           protoreflect.MessageDescriptor
+	fd_QueryInferencesAndTokensStatsByModelsRequest_time_from protoreflect.FieldDescriptor
+	fd_QueryInferencesAndTokensStatsByModelsRequest_time_to   protoreflect.FieldDescriptor
+)
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryInferencesAndTokensStatsByModelsResponse = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByModelsResponse")
-	fd_QueryInferencesAndTokensStatsByModelsResponse_stats_models = md_QueryInferencesAndTokensStatsByModelsResponse.Fields().ByName("stats_models")
+	md_QueryInferencesAndTokensStatsByModelsRequest = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByModelsRequest")
+	fd_QueryInferencesAndTokensStatsByModelsRequest_time_from = md_QueryInferencesAndTokensStatsByModelsRequest.Fields().ByName("time_from")
+	fd_QueryInferencesAndTokensStatsByModelsRequest_time_to = md_QueryInferencesAndTokensStatsByModelsRequest.Fields().ByName("time_to")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(nil)
 
-type fastReflection_QueryInferencesAndTokensStatsByModelsResponse QueryInferencesAndTokensStatsByModelsResponse
+type fastReflection_QueryInferencesAndTokensStatsByModelsRequest QueryInferencesAndTokensStatsByModelsRequest
 
-func (x *QueryInferencesAndTokensStatsByModelsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(x)
+func (x *QueryInferencesAndTokensStatsByModelsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(x)
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryInferencesAndTokensStatsByModelsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[93]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -44581,43 +44419,43 @@ func (x *QueryInferencesAndTokensStatsByModelsResponse) slowProtoReflect() proto
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType{}
+var _fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType{}
 
-type fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType struct{}
+type fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType struct{}
 
-func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(nil)
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByModelsRequest)(nil)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByModelsResponse)
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByModelsRequest)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByModelsResponse
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByModelsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsByModelsResponse
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByModelsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryInferencesAndTokensStatsByModelsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsByModelsResponse)
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByModelsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryInferencesAndTokensStatsByModelsResponse)(x)
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryInferencesAndTokensStatsByModelsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -44625,10 +44463,16 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Interface
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.StatsModels) != 0 {
-		value := protoreflect.ValueOfList(&_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &x.StatsModels})
-		if !f(fd_QueryInferencesAndTokensStatsByModelsResponse_stats_models, value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.TimeFrom != int64(0) {
+		value := protoreflect.ValueOfInt64(x.TimeFrom)
+		if !f(fd_QueryInferencesAndTokensStatsByModelsRequest_time_from, value) {
+			return
+		}
+	}
+	if x.TimeTo != int64(0) {
+		value := protoreflect.ValueOfInt64(x.TimeTo)
+		if !f(fd_QueryInferencesAndTokensStatsByModelsRequest_time_to, value) {
 			return
 		}
 	}
@@ -44645,15 +44489,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Range(f f
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
-		return len(x.StatsModels) != 0
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
+		return x.TimeFrom != int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
+		return x.TimeTo != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -44663,15 +44509,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Has(fd pr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
-		x.StatsModels = nil
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
+		x.TimeFrom = int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
+		x.TimeTo = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -44681,19 +44529,19 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Clear(fd
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
-		if len(x.StatsModels) == 0 {
-			return protoreflect.ValueOfList(&_QueryInferencesAndTokensStatsByModelsResponse_1_list{})
-		}
-		listValue := &_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &x.StatsModels}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
+		value := x.TimeFrom
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
+		value := x.TimeTo
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -44707,17 +44555,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Get(descr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
-		lv := value.List()
-		clv := lv.(*_QueryInferencesAndTokensStatsByModelsResponse_1_list)
-		x.StatsModels = *clv.list
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
+		x.TimeFrom = value.Int()
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
+		x.TimeTo = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -44731,45 +44579,44 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Set(fd pr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
-		if x.StatsModels == nil {
-			x.StatsModels = []*ModelStats{}
-		}
-		value := &_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &x.StatsModels}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
+		panic(fmt.Errorf("field time_from of message inference.inference.QueryInferencesAndTokensStatsByModelsRequest is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
+		panic(fmt.Errorf("field time_to of message inference.inference.QueryInferencesAndTokensStatsByModelsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
-		list := []*ModelStats{}
-		return protoreflect.ValueOfList(&_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &list})
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_from":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsRequest.time_to":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByModelsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByModelsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -44777,7 +44624,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) WhichOneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -44788,7 +44635,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) GetUnknow
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -44800,7 +44647,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) SetUnknow
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) IsValid() bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -44810,9 +44657,9 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) IsValid()
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -44824,11 +44671,11 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 		var n int
 		var l int
 		_ = l
-		if len(x.StatsModels) > 0 {
-			for _, e := range x.StatsModels {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.TimeFrom != 0 {
+			n += 1 + runtime.Sov(uint64(x.TimeFrom))
+		}
+		if x.TimeTo != 0 {
+			n += 1 + runtime.Sov(uint64(x.TimeTo))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -44840,7 +44687,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -44859,21 +44706,15 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.StatsModels) > 0 {
-			for iNdEx := len(x.StatsModels) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.StatsModels[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if x.TimeTo != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeTo))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.TimeFrom != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeFrom))
+			i--
+			dAtA[i] = 0x10
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -44886,7 +44727,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -44918,17 +44759,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StatsModels", wireType)
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
 				}
-				var msglen int
+				x.TimeFrom = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -44938,26 +44779,30 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.TimeFrom |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
 				}
-				x.StatsModels = append(x.StatsModels, &ModelStats{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StatsModels[len(x.StatsModels)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.TimeTo = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.TimeTo |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -44994,29 +44839,29 @@ func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMeth
 }
 
 var (
-	md_QueryInferencesAndTokensStatsResponse                        protoreflect.MessageDescriptor
-	fd_QueryInferencesAndTokensStatsResponse_ai_tokens              protoreflect.FieldDescriptor
-	fd_QueryInferencesAndTokensStatsResponse_inferences             protoreflect.FieldDescriptor
-	fd_QueryInferencesAndTokensStatsResponse_actual_inferences_cost protoreflect.FieldDescriptor
+	md_ModelStats            protoreflect.MessageDescriptor
+	fd_ModelStats_model      protoreflect.FieldDescriptor
+	fd_ModelStats_ai_tokens  protoreflect.FieldDescriptor
+	fd_ModelStats_inferences protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryInferencesAndTokensStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsResponse")
-	fd_QueryInferencesAndTokensStatsResponse_ai_tokens = md_QueryInferencesAndTokensStatsResponse.Fields().ByName("ai_tokens")
-	fd_QueryInferencesAndTokensStatsResponse_inferences = md_QueryInferencesAndTokensStatsResponse.Fields().ByName("inferences")
-	fd_QueryInferencesAndTokensStatsResponse_actual_inferences_cost = md_QueryInferencesAndTokensStatsResponse.Fields().ByName("actual_inferences_cost")
+	md_ModelStats = File_inference_inference_query_proto.Messages().ByName("ModelStats")
+	fd_ModelStats_model = md_ModelStats.Fields().ByName("model")
+	fd_ModelStats_ai_tokens = md_ModelStats.Fields().ByName("ai_tokens")
+	fd_ModelStats_inferences = md_ModelStats.Fields().ByName("inferences")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_ModelStats)(nil)
 
-type fastReflection_QueryInferencesAndTokensStatsResponse QueryInferencesAndTokensStatsResponse
+type fastReflection_ModelStats ModelStats
 
-func (x *QueryInferencesAndTokensStatsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsResponse)(x)
+func (x *ModelStats) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ModelStats)(x)
 }
 
-func (x *QueryInferencesAndTokensStatsResponse) slowProtoReflect() protoreflect.Message {
+func (x *ModelStats) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[94]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -45028,43 +44873,43 @@ func (x *QueryInferencesAndTokensStatsResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryInferencesAndTokensStatsResponse_messageType fastReflection_QueryInferencesAndTokensStatsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsResponse_messageType{}
+var _fastReflection_ModelStats_messageType fastReflection_ModelStats_messageType
+var _ protoreflect.MessageType = fastReflection_ModelStats_messageType{}
 
-type fastReflection_QueryInferencesAndTokensStatsResponse_messageType struct{}
+type fastReflection_ModelStats_messageType struct{}
 
-func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryInferencesAndTokensStatsResponse)(nil)
+func (x fastReflection_ModelStats_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ModelStats)(nil)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsResponse)
+func (x fastReflection_ModelStats_messageType) New() protoreflect.Message {
+	return new(fastReflection_ModelStats)
 }
-func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsResponse
+func (x fastReflection_ModelStats_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ModelStats
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryInferencesAndTokensStatsResponse
+func (x *fastReflection_ModelStats) Descriptor() protoreflect.MessageDescriptor {
+	return md_ModelStats
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryInferencesAndTokensStatsResponse_messageType
+func (x *fastReflection_ModelStats) Type() protoreflect.MessageType {
+	return _fastReflection_ModelStats_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryInferencesAndTokensStatsResponse)
+func (x *fastReflection_ModelStats) New() protoreflect.Message {
+	return new(fastReflection_ModelStats)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryInferencesAndTokensStatsResponse)(x)
+func (x *fastReflection_ModelStats) Interface() protoreflect.ProtoMessage {
+	return (*ModelStats)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -45072,22 +44917,22 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_ModelStats) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Model != "" {
+		value := protoreflect.ValueOfString(x.Model)
+		if !f(fd_ModelStats_model, value) {
+			return
+		}
+	}
 	if x.AiTokens != int64(0) {
 		value := protoreflect.ValueOfInt64(x.AiTokens)
-		if !f(fd_QueryInferencesAndTokensStatsResponse_ai_tokens, value) {
+		if !f(fd_ModelStats_ai_tokens, value) {
 			return
 		}
 	}
 	if x.Inferences != int32(0) {
 		value := protoreflect.ValueOfInt32(x.Inferences)
-		if !f(fd_QueryInferencesAndTokensStatsResponse_inferences, value) {
-			return
-		}
-	}
-	if x.ActualInferencesCost != int64(0) {
-		value := protoreflect.ValueOfInt64(x.ActualInferencesCost)
-		if !f(fd_QueryInferencesAndTokensStatsResponse_actual_inferences_cost, value) {
+		if !f(fd_ModelStats_inferences, value) {
 			return
 		}
 	}
@@ -45104,19 +44949,19 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ModelStats) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+	case "inference.inference.ModelStats.model":
+		return x.Model != ""
+	case "inference.inference.ModelStats.ai_tokens":
 		return x.AiTokens != int64(0)
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+	case "inference.inference.ModelStats.inferences":
 		return x.Inferences != int32(0)
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
-		return x.ActualInferencesCost != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45126,19 +44971,19 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ModelStats) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+	case "inference.inference.ModelStats.model":
+		x.Model = ""
+	case "inference.inference.ModelStats.ai_tokens":
 		x.AiTokens = int64(0)
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+	case "inference.inference.ModelStats.inferences":
 		x.Inferences = int32(0)
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
-		x.ActualInferencesCost = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45148,22 +44993,22 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelStats) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+	case "inference.inference.ModelStats.model":
+		value := x.Model
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.ModelStats.ai_tokens":
 		value := x.AiTokens
 		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+	case "inference.inference.ModelStats.inferences":
 		value := x.Inferences
 		return protoreflect.ValueOfInt32(value)
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
-		value := x.ActualInferencesCost
-		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -45177,19 +45022,19 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ModelStats) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+	case "inference.inference.ModelStats.model":
+		x.Model = value.Interface().(string)
+	case "inference.inference.ModelStats.ai_tokens":
 		x.AiTokens = value.Int()
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+	case "inference.inference.ModelStats.inferences":
 		x.Inferences = int32(value.Int())
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
-		x.ActualInferencesCost = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45203,48 +45048,48 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelStats) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
-		panic(fmt.Errorf("field ai_tokens of message inference.inference.QueryInferencesAndTokensStatsResponse is not mutable"))
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
-		panic(fmt.Errorf("field inferences of message inference.inference.QueryInferencesAndTokensStatsResponse is not mutable"))
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
-		panic(fmt.Errorf("field actual_inferences_cost of message inference.inference.QueryInferencesAndTokensStatsResponse is not mutable"))
+	case "inference.inference.ModelStats.model":
+		panic(fmt.Errorf("field model of message inference.inference.ModelStats is not mutable"))
+	case "inference.inference.ModelStats.ai_tokens":
+		panic(fmt.Errorf("field ai_tokens of message inference.inference.ModelStats is not mutable"))
+	case "inference.inference.ModelStats.inferences":
+		panic(fmt.Errorf("field inferences of message inference.inference.ModelStats is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelStats) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+	case "inference.inference.ModelStats.model":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.ModelStats.ai_tokens":
 		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+	case "inference.inference.ModelStats.inferences":
 		return protoreflect.ValueOfInt32(int32(0))
-	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
-		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelStats"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelStats does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ModelStats) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelStats", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -45252,7 +45097,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ModelStats) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -45263,7 +45108,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ModelStats) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -45275,7 +45120,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) IsValid() bool {
+func (x *fastReflection_ModelStats) IsValid() bool {
 	return x != nil
 }
 
@@ -45285,9 +45130,9 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ModelStats) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
+		x := input.Message.Interface().(*ModelStats)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -45299,15 +45144,16 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
+		l = len(x.Model)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.AiTokens != 0 {
 			n += 1 + runtime.Sov(uint64(x.AiTokens))
 		}
 		if x.Inferences != 0 {
 			n += 1 + runtime.Sov(uint64(x.Inferences))
 		}
-		if x.ActualInferencesCost != 0 {
-			n += 1 + runtime.Sov(uint64(x.ActualInferencesCost))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -45318,7 +45164,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
+		x := input.Message.Interface().(*ModelStats)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -45337,20 +45183,22 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.ActualInferencesCost != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.ActualInferencesCost))
-			i--
-			dAtA[i] = 0x18
-		}
 		if x.Inferences != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.Inferences))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x18
 		}
 		if x.AiTokens != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.AiTokens))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0x10
+		}
+		if len(x.Model) > 0 {
+			i -= len(x.Model)
+			copy(dAtA[i:], x.Model)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Model)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -45363,7 +45211,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
+		x := input.Message.Interface().(*ModelStats)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -45395,17 +45243,17 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelStats: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelStats: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
 				}
-				x.AiTokens = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -45415,16 +45263,29 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.AiTokens |= int64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Model = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
 				}
-				x.Inferences = 0
+				x.AiTokens = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -45434,16 +45295,16 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Inferences |= int32(b&0x7F) << shift
+					x.AiTokens |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
 			case 3:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActualInferencesCost", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
 				}
-				x.ActualInferencesCost = 0
+				x.Inferences = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -45453,7 +45314,7 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.ActualInferencesCost |= int64(b&0x7F) << shift
+					x.Inferences |= int32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -45493,24 +45354,77 @@ func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *p
 	}
 }
 
+var _ protoreflect.List = (*_QueryInferencesAndTokensStatsByModelsResponse_1_list)(nil)
+
+type _QueryInferencesAndTokensStatsByModelsResponse_1_list struct {
+	list *[]*ModelStats
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ModelStats)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ModelStats)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ModelStats)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ModelStats)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryInferencesAndTokensStatsByModelsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryCountAllParticipantsRequest protoreflect.MessageDescriptor
+	md_QueryInferencesAndTokensStatsByModelsResponse              protoreflect.MessageDescriptor
+	fd_QueryInferencesAndTokensStatsByModelsResponse_stats_models protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCountAllParticipantsRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountAllParticipantsRequest")
+	md_QueryInferencesAndTokensStatsByModelsResponse = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsByModelsResponse")
+	fd_QueryInferencesAndTokensStatsByModelsResponse_stats_models = md_QueryInferencesAndTokensStatsByModelsResponse.Fields().ByName("stats_models")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCountAllParticipantsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(nil)
 
-type fastReflection_QueryCountAllParticipantsRequest QueryCountAllParticipantsRequest
+type fastReflection_QueryInferencesAndTokensStatsByModelsResponse QueryInferencesAndTokensStatsByModelsResponse
 
-func (x *QueryCountAllParticipantsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCountAllParticipantsRequest)(x)
+func (x *QueryInferencesAndTokensStatsByModelsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(x)
 }
 
-func (x *QueryCountAllParticipantsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryInferencesAndTokensStatsByModelsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[95]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -45522,43 +45436,43 @@ func (x *QueryCountAllParticipantsRequest) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCountAllParticipantsRequest_messageType fastReflection_QueryCountAllParticipantsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCountAllParticipantsRequest_messageType{}
+var _fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType{}
 
-type fastReflection_QueryCountAllParticipantsRequest_messageType struct{}
+type fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType struct{}
 
-func (x fastReflection_QueryCountAllParticipantsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCountAllParticipantsRequest)(nil)
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsByModelsResponse)(nil)
 }
-func (x fastReflection_QueryCountAllParticipantsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCountAllParticipantsRequest)
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByModelsResponse)
 }
-func (x fastReflection_QueryCountAllParticipantsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountAllParticipantsRequest
+func (x fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByModelsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountAllParticipantsRequest
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsByModelsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCountAllParticipantsRequest_messageType
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryInferencesAndTokensStatsByModelsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCountAllParticipantsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryCountAllParticipantsRequest)
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsByModelsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryCountAllParticipantsRequest)(x)
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryInferencesAndTokensStatsByModelsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -45566,7 +45480,13 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.StatsModels) != 0 {
+		value := protoreflect.ValueOfList(&_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &x.StatsModels})
+		if !f(fd_QueryInferencesAndTokensStatsByModelsResponse_stats_models, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -45580,13 +45500,15 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
+		return len(x.StatsModels) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45596,13 +45518,15 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
+		x.StatsModels = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45612,13 +45536,19 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
+		if len(x.StatsModels) == 0 {
+			return protoreflect.ValueOfList(&_QueryInferencesAndTokensStatsByModelsResponse_1_list{})
+		}
+		listValue := &_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &x.StatsModels}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -45632,13 +45562,17 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
+		lv := value.List()
+		clv := lv.(*_QueryInferencesAndTokensStatsByModelsResponse_1_list)
+		x.StatsModels = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45652,36 +45586,45 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
+		if x.StatsModels == nil {
+			x.StatsModels = []*ModelStats{}
+		}
+		value := &_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &x.StatsModels}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCountAllParticipantsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models":
+		list := []*ModelStats{}
+		return protoreflect.ValueOfList(&_QueryInferencesAndTokensStatsByModelsResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsByModelsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsByModelsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCountAllParticipantsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountAllParticipantsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsByModelsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -45689,7 +45632,7 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCountAllParticipantsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -45700,7 +45643,7 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -45712,7 +45655,7 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCountAllParticipantsRequest) IsValid() bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -45722,9 +45665,9 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryInferencesAndTokensStatsByModelsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -45736,6 +45679,12 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
+		if len(x.StatsModels) > 0 {
+			for _, e := range x.StatsModels {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -45746,7 +45695,7 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -45765,6 +45714,22 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.StatsModels) > 0 {
+			for iNdEx := len(x.StatsModels) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.StatsModels[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -45776,7 +45741,7 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsByModelsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -45808,12 +45773,46 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StatsModels", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.StatsModels = append(x.StatsModels, &ModelStats{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StatsModels[len(x.StatsModels)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -45850,25 +45849,29 @@ func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoi
 }
 
 var (
-	md_QueryCountAllParticipantsResponse       protoreflect.MessageDescriptor
-	fd_QueryCountAllParticipantsResponse_total protoreflect.FieldDescriptor
+	md_QueryInferencesAndTokensStatsResponse                        protoreflect.MessageDescriptor
+	fd_QueryInferencesAndTokensStatsResponse_ai_tokens              protoreflect.FieldDescriptor
+	fd_QueryInferencesAndTokensStatsResponse_inferences             protoreflect.FieldDescriptor
+	fd_QueryInferencesAndTokensStatsResponse_actual_inferences_cost protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCountAllParticipantsResponse = File_inference_inference_query_proto.Messages().ByName("QueryCountAllParticipantsResponse")
-	fd_QueryCountAllParticipantsResponse_total = md_QueryCountAllParticipantsResponse.Fields().ByName("total")
+	md_QueryInferencesAndTokensStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryInferencesAndTokensStatsResponse")
+	fd_QueryInferencesAndTokensStatsResponse_ai_tokens = md_QueryInferencesAndTokensStatsResponse.Fields().ByName("ai_tokens")
+	fd_QueryInferencesAndTokensStatsResponse_inferences = md_QueryInferencesAndTokensStatsResponse.Fields().ByName("inferences")
+	fd_QueryInferencesAndTokensStatsResponse_actual_inferences_cost = md_QueryInferencesAndTokensStatsResponse.Fields().ByName("actual_inferences_cost")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCountAllParticipantsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryInferencesAndTokensStatsResponse)(nil)
 
-type fastReflection_QueryCountAllParticipantsResponse QueryCountAllParticipantsResponse
+type fastReflection_QueryInferencesAndTokensStatsResponse QueryInferencesAndTokensStatsResponse
 
-func (x *QueryCountAllParticipantsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCountAllParticipantsResponse)(x)
+func (x *QueryInferencesAndTokensStatsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsResponse)(x)
 }
 
-func (x *QueryCountAllParticipantsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryInferencesAndTokensStatsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[96]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -45880,43 +45883,43 @@ func (x *QueryCountAllParticipantsResponse) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCountAllParticipantsResponse_messageType fastReflection_QueryCountAllParticipantsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCountAllParticipantsResponse_messageType{}
+var _fastReflection_QueryInferencesAndTokensStatsResponse_messageType fastReflection_QueryInferencesAndTokensStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryInferencesAndTokensStatsResponse_messageType{}
 
-type fastReflection_QueryCountAllParticipantsResponse_messageType struct{}
+type fastReflection_QueryInferencesAndTokensStatsResponse_messageType struct{}
 
-func (x fastReflection_QueryCountAllParticipantsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCountAllParticipantsResponse)(nil)
+func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryInferencesAndTokensStatsResponse)(nil)
 }
-func (x fastReflection_QueryCountAllParticipantsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCountAllParticipantsResponse)
+func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsResponse)
 }
-func (x fastReflection_QueryCountAllParticipantsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountAllParticipantsResponse
+func (x fastReflection_QueryInferencesAndTokensStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountAllParticipantsResponse
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryInferencesAndTokensStatsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCountAllParticipantsResponse_messageType
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryInferencesAndTokensStatsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCountAllParticipantsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryCountAllParticipantsResponse)
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryInferencesAndTokensStatsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryCountAllParticipantsResponse)(x)
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryInferencesAndTokensStatsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -45924,10 +45927,22 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Total != int64(0) {
-		value := protoreflect.ValueOfInt64(x.Total)
-		if !f(fd_QueryCountAllParticipantsResponse_total, value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.AiTokens != int64(0) {
+		value := protoreflect.ValueOfInt64(x.AiTokens)
+		if !f(fd_QueryInferencesAndTokensStatsResponse_ai_tokens, value) {
+			return
+		}
+	}
+	if x.Inferences != int32(0) {
+		value := protoreflect.ValueOfInt32(x.Inferences)
+		if !f(fd_QueryInferencesAndTokensStatsResponse_inferences, value) {
+			return
+		}
+	}
+	if x.ActualInferencesCost != int64(0) {
+		value := protoreflect.ValueOfInt64(x.ActualInferencesCost)
+		if !f(fd_QueryInferencesAndTokensStatsResponse_actual_inferences_cost, value) {
 			return
 		}
 	}
@@ -45944,15 +45959,19 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountAllParticipantsResponse.total":
-		return x.Total != int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+		return x.AiTokens != int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+		return x.Inferences != int32(0)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
+		return x.ActualInferencesCost != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45962,15 +45981,19 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountAllParticipantsResponse.total":
-		x.Total = int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+		x.AiTokens = int64(0)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+		x.Inferences = int32(0)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
+		x.ActualInferencesCost = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -45980,16 +46003,22 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryCountAllParticipantsResponse.total":
-		value := x.Total
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+		value := x.AiTokens
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+		value := x.Inferences
+		return protoreflect.ValueOfInt32(value)
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
+		value := x.ActualInferencesCost
 		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -46003,15 +46032,19 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountAllParticipantsResponse.total":
-		x.Total = value.Int()
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+		x.AiTokens = value.Int()
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+		x.Inferences = int32(value.Int())
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
+		x.ActualInferencesCost = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46025,40 +46058,48 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountAllParticipantsResponse.total":
-		panic(fmt.Errorf("field total of message inference.inference.QueryCountAllParticipantsResponse is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+		panic(fmt.Errorf("field ai_tokens of message inference.inference.QueryInferencesAndTokensStatsResponse is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+		panic(fmt.Errorf("field inferences of message inference.inference.QueryInferencesAndTokensStatsResponse is not mutable"))
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
+		panic(fmt.Errorf("field actual_inferences_cost of message inference.inference.QueryInferencesAndTokensStatsResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCountAllParticipantsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountAllParticipantsResponse.total":
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.ai_tokens":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.inferences":
+		return protoreflect.ValueOfInt32(int32(0))
+	case "inference.inference.QueryInferencesAndTokensStatsResponse.actual_inferences_cost":
 		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryInferencesAndTokensStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryInferencesAndTokensStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCountAllParticipantsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountAllParticipantsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryInferencesAndTokensStatsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -46066,7 +46107,7 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCountAllParticipantsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -46077,7 +46118,7 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountAllParticipantsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -46089,7 +46130,7 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCountAllParticipantsResponse) IsValid() bool {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -46099,9 +46140,9 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryInferencesAndTokensStatsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -46113,8 +46154,14 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if x.Total != 0 {
-			n += 1 + runtime.Sov(uint64(x.Total))
+		if x.AiTokens != 0 {
+			n += 1 + runtime.Sov(uint64(x.AiTokens))
+		}
+		if x.Inferences != 0 {
+			n += 1 + runtime.Sov(uint64(x.Inferences))
+		}
+		if x.ActualInferencesCost != 0 {
+			n += 1 + runtime.Sov(uint64(x.ActualInferencesCost))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -46126,7 +46173,7 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -46145,8 +46192,18 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Total != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Total))
+		if x.ActualInferencesCost != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ActualInferencesCost))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.Inferences != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Inferences))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.AiTokens != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.AiTokens))
 			i--
 			dAtA[i] = 0x8
 		}
@@ -46161,7 +46218,7 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
+		x := input.Message.Interface().(*QueryInferencesAndTokensStatsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -46193,17 +46250,17 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
 				}
-				x.Total = 0
+				x.AiTokens = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -46213,21 +46270,59 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Total |= int64(b&0x7F) << shift
+					x.AiTokens |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
 				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				x.Inferences = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Inferences |= int32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-				if (iNdEx + skippy) > l {
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActualInferencesCost", wireType)
+				}
+				x.ActualInferencesCost = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ActualInferencesCost |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
 				if !options.DiscardUnknown {
@@ -46254,23 +46349,23 @@ func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *proto
 }
 
 var (
-	md_QueryDebugStatsRequest protoreflect.MessageDescriptor
+	md_QueryCountAllParticipantsRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryDebugStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsRequest")
+	md_QueryCountAllParticipantsRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountAllParticipantsRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryDebugStatsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCountAllParticipantsRequest)(nil)
 
-type fastReflection_QueryDebugStatsRequest QueryDebugStatsRequest
+type fastReflection_QueryCountAllParticipantsRequest QueryCountAllParticipantsRequest
 
-func (x *QueryDebugStatsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsRequest)(x)
+func (x *QueryCountAllParticipantsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCountAllParticipantsRequest)(x)
 }
 
-func (x *QueryDebugStatsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryCountAllParticipantsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[97]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -46282,43 +46377,43 @@ func (x *QueryDebugStatsRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryDebugStatsRequest_messageType fastReflection_QueryDebugStatsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryDebugStatsRequest_messageType{}
+var _fastReflection_QueryCountAllParticipantsRequest_messageType fastReflection_QueryCountAllParticipantsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountAllParticipantsRequest_messageType{}
 
-type fastReflection_QueryDebugStatsRequest_messageType struct{}
+type fastReflection_QueryCountAllParticipantsRequest_messageType struct{}
 
-func (x fastReflection_QueryDebugStatsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsRequest)(nil)
+func (x fastReflection_QueryCountAllParticipantsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCountAllParticipantsRequest)(nil)
 }
-func (x fastReflection_QueryDebugStatsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsRequest)
+func (x fastReflection_QueryCountAllParticipantsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCountAllParticipantsRequest)
 }
-func (x fastReflection_QueryDebugStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsRequest
+func (x fastReflection_QueryCountAllParticipantsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountAllParticipantsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryDebugStatsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsRequest
+func (x *fastReflection_QueryCountAllParticipantsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountAllParticipantsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryDebugStatsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryDebugStatsRequest_messageType
+func (x *fastReflection_QueryCountAllParticipantsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCountAllParticipantsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryDebugStatsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsRequest)
+func (x *fastReflection_QueryCountAllParticipantsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryCountAllParticipantsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryDebugStatsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryDebugStatsRequest)(x)
+func (x *fastReflection_QueryCountAllParticipantsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryCountAllParticipantsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -46326,7 +46421,7 @@ func (x *fastReflection_QueryDebugStatsRequest) Interface() protoreflect.ProtoMe
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryDebugStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryCountAllParticipantsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -46340,13 +46435,13 @@ func (x *fastReflection_QueryDebugStatsRequest) Range(f func(protoreflect.FieldD
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryDebugStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCountAllParticipantsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46356,13 +46451,13 @@ func (x *fastReflection_QueryDebugStatsRequest) Has(fd protoreflect.FieldDescrip
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCountAllParticipantsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46372,13 +46467,13 @@ func (x *fastReflection_QueryDebugStatsRequest) Clear(fd protoreflect.FieldDescr
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryDebugStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountAllParticipantsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -46392,13 +46487,13 @@ func (x *fastReflection_QueryDebugStatsRequest) Get(descriptor protoreflect.Fiel
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCountAllParticipantsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46412,36 +46507,36 @@ func (x *fastReflection_QueryDebugStatsRequest) Set(fd protoreflect.FieldDescrip
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountAllParticipantsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryDebugStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountAllParticipantsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryDebugStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCountAllParticipantsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountAllParticipantsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -46449,7 +46544,7 @@ func (x *fastReflection_QueryDebugStatsRequest) WhichOneof(d protoreflect.OneofD
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryDebugStatsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCountAllParticipantsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -46460,7 +46555,7 @@ func (x *fastReflection_QueryDebugStatsRequest) GetUnknown() protoreflect.RawFie
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCountAllParticipantsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -46472,7 +46567,7 @@ func (x *fastReflection_QueryDebugStatsRequest) SetUnknown(fields protoreflect.R
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryDebugStatsRequest) IsValid() bool {
+func (x *fastReflection_QueryCountAllParticipantsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -46482,9 +46577,9 @@ func (x *fastReflection_QueryDebugStatsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryDebugStatsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCountAllParticipantsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryDebugStatsRequest)
+		x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -46506,7 +46601,7 @@ func (x *fastReflection_QueryDebugStatsRequest) ProtoMethods() *protoiface.Metho
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsRequest)
+		x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -46536,7 +46631,7 @@ func (x *fastReflection_QueryDebugStatsRequest) ProtoMethods() *protoiface.Metho
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsRequest)
+		x := input.Message.Interface().(*QueryCountAllParticipantsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -46568,10 +46663,10 @@ func (x *fastReflection_QueryDebugStatsRequest) ProtoMethods() *protoiface.Metho
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -46609,130 +46704,26 @@ func (x *fastReflection_QueryDebugStatsRequest) ProtoMethods() *protoiface.Metho
 	}
 }
 
-var _ protoreflect.List = (*_QueryDebugStatsResponse_1_list)(nil)
-
-type _QueryDebugStatsResponse_1_list struct {
-	list *[]*QueryDebugStatsResponse_TemporaryTimeStat
-}
-
-func (x *_QueryDebugStatsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryDebugStatsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryDebugStatsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryDebugStatsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(QueryDebugStatsResponse_TemporaryTimeStat)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryDebugStatsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(QueryDebugStatsResponse_TemporaryTimeStat)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var _ protoreflect.List = (*_QueryDebugStatsResponse_2_list)(nil)
-
-type _QueryDebugStatsResponse_2_list struct {
-	list *[]*QueryDebugStatsResponse_TemporaryEpochStat
-}
-
-func (x *_QueryDebugStatsResponse_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryDebugStatsResponse_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryDebugStatsResponse_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryDebugStatsResponse_2_list) AppendMutable() protoreflect.Value {
-	v := new(QueryDebugStatsResponse_TemporaryEpochStat)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_2_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryDebugStatsResponse_2_list) NewElement() protoreflect.Value {
-	v := new(QueryDebugStatsResponse_TemporaryEpochStat)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_2_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryDebugStatsResponse                protoreflect.MessageDescriptor
-	fd_QueryDebugStatsResponse_stats_by_time  protoreflect.FieldDescriptor
-	fd_QueryDebugStatsResponse_stats_by_epoch protoreflect.FieldDescriptor
+	md_QueryCountAllParticipantsResponse       protoreflect.MessageDescriptor
+	fd_QueryCountAllParticipantsResponse_total protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryDebugStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsResponse")
-	fd_QueryDebugStatsResponse_stats_by_time = md_QueryDebugStatsResponse.Fields().ByName("stats_by_time")
-	fd_QueryDebugStatsResponse_stats_by_epoch = md_QueryDebugStatsResponse.Fields().ByName("stats_by_epoch")
+	md_QueryCountAllParticipantsResponse = File_inference_inference_query_proto.Messages().ByName("QueryCountAllParticipantsResponse")
+	fd_QueryCountAllParticipantsResponse_total = md_QueryCountAllParticipantsResponse.Fields().ByName("total")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCountAllParticipantsResponse)(nil)
 
-type fastReflection_QueryDebugStatsResponse QueryDebugStatsResponse
+type fastReflection_QueryCountAllParticipantsResponse QueryCountAllParticipantsResponse
 
-func (x *QueryDebugStatsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsResponse)(x)
+func (x *QueryCountAllParticipantsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCountAllParticipantsResponse)(x)
 }
 
-func (x *QueryDebugStatsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryCountAllParticipantsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[98]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -46744,43 +46735,43 @@ func (x *QueryDebugStatsResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryDebugStatsResponse_messageType fastReflection_QueryDebugStatsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_messageType{}
+var _fastReflection_QueryCountAllParticipantsResponse_messageType fastReflection_QueryCountAllParticipantsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountAllParticipantsResponse_messageType{}
 
-type fastReflection_QueryDebugStatsResponse_messageType struct{}
+type fastReflection_QueryCountAllParticipantsResponse_messageType struct{}
 
-func (x fastReflection_QueryDebugStatsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsResponse)(nil)
+func (x fastReflection_QueryCountAllParticipantsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCountAllParticipantsResponse)(nil)
 }
-func (x fastReflection_QueryDebugStatsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsResponse)
+func (x fastReflection_QueryCountAllParticipantsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCountAllParticipantsResponse)
 }
-func (x fastReflection_QueryDebugStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsResponse
+func (x fastReflection_QueryCountAllParticipantsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountAllParticipantsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryDebugStatsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsResponse
+func (x *fastReflection_QueryCountAllParticipantsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountAllParticipantsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryDebugStatsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryDebugStatsResponse_messageType
+func (x *fastReflection_QueryCountAllParticipantsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCountAllParticipantsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryDebugStatsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsResponse)
+func (x *fastReflection_QueryCountAllParticipantsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryCountAllParticipantsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryDebugStatsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryDebugStatsResponse)(x)
+func (x *fastReflection_QueryCountAllParticipantsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryCountAllParticipantsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -46788,16 +46779,10 @@ func (x *fastReflection_QueryDebugStatsResponse) Interface() protoreflect.ProtoM
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryDebugStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.StatsByTime) != 0 {
-		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_1_list{list: &x.StatsByTime})
-		if !f(fd_QueryDebugStatsResponse_stats_by_time, value) {
-			return
-		}
-	}
-	if len(x.StatsByEpoch) != 0 {
-		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_2_list{list: &x.StatsByEpoch})
-		if !f(fd_QueryDebugStatsResponse_stats_by_epoch, value) {
+func (x *fastReflection_QueryCountAllParticipantsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Total != int64(0) {
+		value := protoreflect.ValueOfInt64(x.Total)
+		if !f(fd_QueryCountAllParticipantsResponse_total, value) {
 			return
 		}
 	}
@@ -46814,17 +46799,15 @@ func (x *fastReflection_QueryDebugStatsResponse) Range(f func(protoreflect.Field
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryDebugStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCountAllParticipantsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
-		return len(x.StatsByTime) != 0
-	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
-		return len(x.StatsByEpoch) != 0
+	case "inference.inference.QueryCountAllParticipantsResponse.total":
+		return x.Total != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46834,17 +46817,15 @@ func (x *fastReflection_QueryDebugStatsResponse) Has(fd protoreflect.FieldDescri
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCountAllParticipantsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
-		x.StatsByTime = nil
-	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
-		x.StatsByEpoch = nil
+	case "inference.inference.QueryCountAllParticipantsResponse.total":
+		x.Total = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46854,25 +46835,16 @@ func (x *fastReflection_QueryDebugStatsResponse) Clear(fd protoreflect.FieldDesc
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryDebugStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountAllParticipantsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
-		if len(x.StatsByTime) == 0 {
-			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_1_list{})
-		}
-		listValue := &_QueryDebugStatsResponse_1_list{list: &x.StatsByTime}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
-		if len(x.StatsByEpoch) == 0 {
-			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_2_list{})
-		}
-		listValue := &_QueryDebugStatsResponse_2_list{list: &x.StatsByEpoch}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryCountAllParticipantsResponse.total":
+		value := x.Total
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -46886,21 +46858,15 @@ func (x *fastReflection_QueryDebugStatsResponse) Get(descriptor protoreflect.Fie
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCountAllParticipantsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
-		lv := value.List()
-		clv := lv.(*_QueryDebugStatsResponse_1_list)
-		x.StatsByTime = *clv.list
-	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
-		lv := value.List()
-		clv := lv.(*_QueryDebugStatsResponse_2_list)
-		x.StatsByEpoch = *clv.list
+	case "inference.inference.QueryCountAllParticipantsResponse.total":
+		x.Total = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -46914,54 +46880,40 @@ func (x *fastReflection_QueryDebugStatsResponse) Set(fd protoreflect.FieldDescri
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountAllParticipantsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
-		if x.StatsByTime == nil {
-			x.StatsByTime = []*QueryDebugStatsResponse_TemporaryTimeStat{}
-		}
-		value := &_QueryDebugStatsResponse_1_list{list: &x.StatsByTime}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
-		if x.StatsByEpoch == nil {
-			x.StatsByEpoch = []*QueryDebugStatsResponse_TemporaryEpochStat{}
-		}
-		value := &_QueryDebugStatsResponse_2_list{list: &x.StatsByEpoch}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryCountAllParticipantsResponse.total":
+		panic(fmt.Errorf("field total of message inference.inference.QueryCountAllParticipantsResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryDebugStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountAllParticipantsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
-		list := []*QueryDebugStatsResponse_TemporaryTimeStat{}
-		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_1_list{list: &list})
-	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
-		list := []*QueryDebugStatsResponse_TemporaryEpochStat{}
-		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_2_list{list: &list})
+	case "inference.inference.QueryCountAllParticipantsResponse.total":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountAllParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountAllParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryDebugStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCountAllParticipantsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountAllParticipantsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -46969,7 +46921,7 @@ func (x *fastReflection_QueryDebugStatsResponse) WhichOneof(d protoreflect.Oneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryDebugStatsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCountAllParticipantsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -46980,7 +46932,7 @@ func (x *fastReflection_QueryDebugStatsResponse) GetUnknown() protoreflect.RawFi
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCountAllParticipantsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -46992,7 +46944,7 @@ func (x *fastReflection_QueryDebugStatsResponse) SetUnknown(fields protoreflect.
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryDebugStatsResponse) IsValid() bool {
+func (x *fastReflection_QueryCountAllParticipantsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -47002,9 +46954,9 @@ func (x *fastReflection_QueryDebugStatsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCountAllParticipantsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryDebugStatsResponse)
+		x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -47016,17 +46968,8 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 		var n int
 		var l int
 		_ = l
-		if len(x.StatsByTime) > 0 {
-			for _, e := range x.StatsByTime {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if len(x.StatsByEpoch) > 0 {
-			for _, e := range x.StatsByEpoch {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Total != 0 {
+			n += 1 + runtime.Sov(uint64(x.Total))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -47038,7 +46981,7 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsResponse)
+		x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -47057,37 +47000,10 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.StatsByEpoch) > 0 {
-			for iNdEx := len(x.StatsByEpoch) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.StatsByEpoch[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x12
-			}
-		}
-		if len(x.StatsByTime) > 0 {
-			for iNdEx := len(x.StatsByTime) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.StatsByTime[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if x.Total != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Total))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -47100,7 +47016,7 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsResponse)
+		x := input.Message.Interface().(*QueryCountAllParticipantsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -47132,17 +47048,17 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountAllParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StatsByTime", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
 				}
-				var msglen int
+				x.Total = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -47152,74 +47068,25 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Total |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				if postIndex > l {
+				if (iNdEx + skippy) > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.StatsByTime = append(x.StatsByTime, &QueryDebugStatsResponse_TemporaryTimeStat{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StatsByTime[len(x.StatsByTime)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StatsByEpoch", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.StatsByEpoch = append(x.StatsByEpoch, &QueryDebugStatsResponse_TemporaryEpochStat{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StatsByEpoch[len(x.StatsByEpoch)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if (iNdEx + skippy) > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if !options.DiscardUnknown {
-					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 				}
 				iNdEx += skippy
 			}
@@ -47241,80 +47108,25 @@ func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Meth
 	}
 }
 
-var _ protoreflect.List = (*_QueryDebugStatsResponse_TemporaryTimeStat_2_list)(nil)
-
-type _QueryDebugStatsResponse_TemporaryTimeStat_2_list struct {
-	list *[]*DeveloperStatsByTime
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) AppendMutable() protoreflect.Value {
-	v := new(DeveloperStatsByTime)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) NewElement() protoreflect.Value {
-	v := new(DeveloperStatsByTime)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryDebugStatsResponse_TemporaryTimeStat           protoreflect.MessageDescriptor
-	fd_QueryDebugStatsResponse_TemporaryTimeStat_developer protoreflect.FieldDescriptor
-	fd_QueryDebugStatsResponse_TemporaryTimeStat_stats     protoreflect.FieldDescriptor
+	md_QueryDebugStatsRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryDebugStatsResponse_TemporaryTimeStat = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsResponse").Messages().ByName("TemporaryTimeStat")
-	fd_QueryDebugStatsResponse_TemporaryTimeStat_developer = md_QueryDebugStatsResponse_TemporaryTimeStat.Fields().ByName("developer")
-	fd_QueryDebugStatsResponse_TemporaryTimeStat_stats = md_QueryDebugStatsResponse_TemporaryTimeStat.Fields().ByName("stats")
+	md_QueryDebugStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsRequest)(nil)
 
-type fastReflection_QueryDebugStatsResponse_TemporaryTimeStat QueryDebugStatsResponse_TemporaryTimeStat
+type fastReflection_QueryDebugStatsRequest QueryDebugStatsRequest
 
-func (x *QueryDebugStatsResponse_TemporaryTimeStat) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(x)
+func (x *QueryDebugStatsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsRequest)(x)
 }
 
-func (x *QueryDebugStatsResponse_TemporaryTimeStat) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[164]
+func (x *QueryDebugStatsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[99]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -47325,43 +47137,43 @@ func (x *QueryDebugStatsResponse_TemporaryTimeStat) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType
-var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType{}
+var _fastReflection_QueryDebugStatsRequest_messageType fastReflection_QueryDebugStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsRequest_messageType{}
 
-type fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType struct{}
+type fastReflection_QueryDebugStatsRequest_messageType struct{}
 
-func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(nil)
+func (x fastReflection_QueryDebugStatsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsRequest)(nil)
 }
-func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)
+func (x fastReflection_QueryDebugStatsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsRequest)
 }
-func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsResponse_TemporaryTimeStat
+func (x fastReflection_QueryDebugStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsResponse_TemporaryTimeStat
+func (x *fastReflection_QueryDebugStatsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Type() protoreflect.MessageType {
-	return _fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType
+func (x *fastReflection_QueryDebugStatsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDebugStatsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)
+func (x *fastReflection_QueryDebugStatsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Interface() protoreflect.ProtoMessage {
-	return (*QueryDebugStatsResponse_TemporaryTimeStat)(x)
+func (x *fastReflection_QueryDebugStatsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryDebugStatsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -47369,19 +47181,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Developer != "" {
-		value := protoreflect.ValueOfString(x.Developer)
-		if !f(fd_QueryDebugStatsResponse_TemporaryTimeStat_developer, value) {
-			return
-		}
-	}
-	if len(x.Stats) != 0 {
-		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &x.Stats})
-		if !f(fd_QueryDebugStatsResponse_TemporaryTimeStat_stats, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryDebugStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -47395,17 +47195,13 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryDebugStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
-		return x.Developer != ""
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
-		return len(x.Stats) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -47415,17 +47211,13 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryDebugStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
-		x.Developer = ""
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
-		x.Stats = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -47435,22 +47227,13 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
-		value := x.Developer
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
-		if len(x.Stats) == 0 {
-			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryTimeStat_2_list{})
-		}
-		listValue := &_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &x.Stats}
-		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -47464,19 +47247,13 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryDebugStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
-		x.Developer = value.Interface().(string)
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
-		lv := value.List()
-		clv := lv.(*_QueryDebugStatsResponse_TemporaryTimeStat_2_list)
-		x.Stats = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -47490,49 +47267,36 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
-		if x.Stats == nil {
-			x.Stats = []*DeveloperStatsByTime{}
-		}
-		value := &_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &x.Stats}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
-		panic(fmt.Errorf("field developer of message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
-		list := []*DeveloperStatsByTime{}
-		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryDebugStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsResponse.TemporaryTimeStat", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -47540,7 +47304,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryDebugStatsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -47551,7 +47315,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryDebugStatsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -47563,7 +47327,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) IsValid() bool {
+func (x *fastReflection_QueryDebugStatsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -47573,9 +47337,9 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryDebugStatsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
+		x := input.Message.Interface().(*QueryDebugStatsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -47587,16 +47351,6 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		l = len(x.Developer)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.Stats) > 0 {
-			for _, e := range x.Stats {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -47607,7 +47361,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
+		x := input.Message.Interface().(*QueryDebugStatsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -47626,29 +47380,6 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Stats) > 0 {
-			for iNdEx := len(x.Stats) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Stats[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x12
-			}
-		}
-		if len(x.Developer) > 0 {
-			i -= len(x.Developer)
-			copy(dAtA[i:], x.Developer)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Developer)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -47660,7 +47391,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
+		x := input.Message.Interface().(*QueryDebugStatsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -47692,78 +47423,12 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryTimeStat: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryTimeStat: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Developer = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Stats = append(x.Stats, &DeveloperStatsByTime{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats[len(x.Stats)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -47799,80 +47464,131 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods(
 	}
 }
 
-var _ protoreflect.List = (*_QueryDebugStatsResponse_TemporaryEpochStat_2_list)(nil)
+var _ protoreflect.List = (*_QueryDebugStatsResponse_1_list)(nil)
 
-type _QueryDebugStatsResponse_TemporaryEpochStat_2_list struct {
-	list *[]*DeveloperStatsByEpoch
+type _QueryDebugStatsResponse_1_list struct {
+	list *[]*QueryDebugStatsResponse_TemporaryTimeStat
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Len() int {
+func (x *_QueryDebugStatsResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Get(i int) protoreflect.Value {
+func (x *_QueryDebugStatsResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryDebugStatsResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByEpoch)
+	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Append(value protoreflect.Value) {
+func (x *_QueryDebugStatsResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByEpoch)
+	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) AppendMutable() protoreflect.Value {
-	v := new(DeveloperStatsByEpoch)
+func (x *_QueryDebugStatsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(QueryDebugStatsResponse_TemporaryTimeStat)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Truncate(n int) {
+func (x *_QueryDebugStatsResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) NewElement() protoreflect.Value {
-	v := new(DeveloperStatsByEpoch)
+func (x *_QueryDebugStatsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(QueryDebugStatsResponse_TemporaryTimeStat)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) IsValid() bool {
+func (x *_QueryDebugStatsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_QueryDebugStatsResponse_2_list)(nil)
+
+type _QueryDebugStatsResponse_2_list struct {
+	list *[]*QueryDebugStatsResponse_TemporaryEpochStat
+}
+
+func (x *_QueryDebugStatsResponse_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryDebugStatsResponse_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryDebugStatsResponse_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryDebugStatsResponse_2_list) AppendMutable() protoreflect.Value {
+	v := new(QueryDebugStatsResponse_TemporaryEpochStat)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryDebugStatsResponse_2_list) NewElement() protoreflect.Value {
+	v := new(QueryDebugStatsResponse_TemporaryEpochStat)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_2_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryDebugStatsResponse_TemporaryEpochStat           protoreflect.MessageDescriptor
-	fd_QueryDebugStatsResponse_TemporaryEpochStat_developer protoreflect.FieldDescriptor
-	fd_QueryDebugStatsResponse_TemporaryEpochStat_stats     protoreflect.FieldDescriptor
+	md_QueryDebugStatsResponse                protoreflect.MessageDescriptor
+	fd_QueryDebugStatsResponse_stats_by_time  protoreflect.FieldDescriptor
+	fd_QueryDebugStatsResponse_stats_by_epoch protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryDebugStatsResponse_TemporaryEpochStat = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsResponse").Messages().ByName("TemporaryEpochStat")
-	fd_QueryDebugStatsResponse_TemporaryEpochStat_developer = md_QueryDebugStatsResponse_TemporaryEpochStat.Fields().ByName("developer")
-	fd_QueryDebugStatsResponse_TemporaryEpochStat_stats = md_QueryDebugStatsResponse_TemporaryEpochStat.Fields().ByName("stats")
+	md_QueryDebugStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsResponse")
+	fd_QueryDebugStatsResponse_stats_by_time = md_QueryDebugStatsResponse.Fields().ByName("stats_by_time")
+	fd_QueryDebugStatsResponse_stats_by_epoch = md_QueryDebugStatsResponse.Fields().ByName("stats_by_epoch")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse)(nil)
 
-type fastReflection_QueryDebugStatsResponse_TemporaryEpochStat QueryDebugStatsResponse_TemporaryEpochStat
+type fastReflection_QueryDebugStatsResponse QueryDebugStatsResponse
 
-func (x *QueryDebugStatsResponse_TemporaryEpochStat) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(x)
+func (x *QueryDebugStatsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsResponse)(x)
 }
 
-func (x *QueryDebugStatsResponse_TemporaryEpochStat) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[165]
+func (x *QueryDebugStatsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[100]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -47883,43 +47599,43 @@ func (x *QueryDebugStatsResponse_TemporaryEpochStat) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType
-var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType{}
+var _fastReflection_QueryDebugStatsResponse_messageType fastReflection_QueryDebugStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_messageType{}
 
-type fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType struct{}
+type fastReflection_QueryDebugStatsResponse_messageType struct{}
 
-func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(nil)
+func (x fastReflection_QueryDebugStatsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsResponse)(nil)
 }
-func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)
+func (x fastReflection_QueryDebugStatsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsResponse)
 }
-func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsResponse_TemporaryEpochStat
+func (x fastReflection_QueryDebugStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryDebugStatsResponse_TemporaryEpochStat
+func (x *fastReflection_QueryDebugStatsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Type() protoreflect.MessageType {
-	return _fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType
+func (x *fastReflection_QueryDebugStatsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDebugStatsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) New() protoreflect.Message {
-	return new(fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)
+func (x *fastReflection_QueryDebugStatsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Interface() protoreflect.ProtoMessage {
-	return (*QueryDebugStatsResponse_TemporaryEpochStat)(x)
+func (x *fastReflection_QueryDebugStatsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryDebugStatsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -47927,16 +47643,16 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Developer != "" {
-		value := protoreflect.ValueOfString(x.Developer)
-		if !f(fd_QueryDebugStatsResponse_TemporaryEpochStat_developer, value) {
+func (x *fastReflection_QueryDebugStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.StatsByTime) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_1_list{list: &x.StatsByTime})
+		if !f(fd_QueryDebugStatsResponse_stats_by_time, value) {
 			return
 		}
 	}
-	if len(x.Stats) != 0 {
-		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats})
-		if !f(fd_QueryDebugStatsResponse_TemporaryEpochStat_stats, value) {
+	if len(x.StatsByEpoch) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_2_list{list: &x.StatsByEpoch})
+		if !f(fd_QueryDebugStatsResponse_stats_by_epoch, value) {
 			return
 		}
 	}
@@ -47953,17 +47669,17 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryDebugStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
-		return x.Developer != ""
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
-		return len(x.Stats) != 0
+	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
+		return len(x.StatsByTime) != 0
+	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
+		return len(x.StatsByEpoch) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -47973,17 +47689,17 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryDebugStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
-		x.Developer = ""
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
-		x.Stats = nil
+	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
+		x.StatsByTime = nil
+	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
+		x.StatsByEpoch = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -47993,22 +47709,25 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
-		value := x.Developer
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
-		if len(x.Stats) == 0 {
-			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{})
+	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
+		if len(x.StatsByTime) == 0 {
+			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_1_list{})
 		}
-		listValue := &_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats}
+		listValue := &_QueryDebugStatsResponse_1_list{list: &x.StatsByTime}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
+		if len(x.StatsByEpoch) == 0 {
+			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_2_list{})
+		}
+		listValue := &_QueryDebugStatsResponse_2_list{list: &x.StatsByEpoch}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -48022,19 +47741,21 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryDebugStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
-		x.Developer = value.Interface().(string)
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
 		lv := value.List()
-		clv := lv.(*_QueryDebugStatsResponse_TemporaryEpochStat_2_list)
-		x.Stats = *clv.list
+		clv := lv.(*_QueryDebugStatsResponse_1_list)
+		x.StatsByTime = *clv.list
+	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
+		lv := value.List()
+		clv := lv.(*_QueryDebugStatsResponse_2_list)
+		x.StatsByEpoch = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48048,49 +47769,54 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
-		if x.Stats == nil {
-			x.Stats = []*DeveloperStatsByEpoch{}
+	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
+		if x.StatsByTime == nil {
+			x.StatsByTime = []*QueryDebugStatsResponse_TemporaryTimeStat{}
 		}
-		value := &_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats}
+		value := &_QueryDebugStatsResponse_1_list{list: &x.StatsByTime}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
+		if x.StatsByEpoch == nil {
+			x.StatsByEpoch = []*QueryDebugStatsResponse_TemporaryEpochStat{}
+		}
+		value := &_QueryDebugStatsResponse_2_list{list: &x.StatsByEpoch}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
-		panic(fmt.Errorf("field developer of message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
-		list := []*DeveloperStatsByEpoch{}
-		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &list})
+	case "inference.inference.QueryDebugStatsResponse.stats_by_time":
+		list := []*QueryDebugStatsResponse_TemporaryTimeStat{}
+		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_1_list{list: &list})
+	case "inference.inference.QueryDebugStatsResponse.stats_by_epoch":
+		list := []*QueryDebugStatsResponse_TemporaryEpochStat{}
+		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryDebugStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsResponse.TemporaryEpochStat", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -48098,7 +47824,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryDebugStatsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -48109,7 +47835,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryDebugStatsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -48121,7 +47847,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) IsValid() bool {
+func (x *fastReflection_QueryDebugStatsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -48131,9 +47857,9 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryDebugStatsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+		x := input.Message.Interface().(*QueryDebugStatsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48145,12 +47871,14 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 		var n int
 		var l int
 		_ = l
-		l = len(x.Developer)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.StatsByTime) > 0 {
+			for _, e := range x.StatsByTime {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
-		if len(x.Stats) > 0 {
-			for _, e := range x.Stats {
+		if len(x.StatsByEpoch) > 0 {
+			for _, e := range x.StatsByEpoch {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -48165,7 +47893,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+		x := input.Message.Interface().(*QueryDebugStatsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48184,9 +47912,9 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Stats) > 0 {
-			for iNdEx := len(x.Stats) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Stats[iNdEx])
+		if len(x.StatsByEpoch) > 0 {
+			for iNdEx := len(x.StatsByEpoch) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.StatsByEpoch[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48200,12 +47928,21 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 				dAtA[i] = 0x12
 			}
 		}
-		if len(x.Developer) > 0 {
-			i -= len(x.Developer)
-			copy(dAtA[i:], x.Developer)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Developer)))
-			i--
-			dAtA[i] = 0xa
+		if len(x.StatsByTime) > 0 {
+			for iNdEx := len(x.StatsByTime) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.StatsByTime[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -48218,7 +47955,7 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
+		x := input.Message.Interface().(*QueryDebugStatsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48250,17 +47987,17 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryEpochStat: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryEpochStat: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StatsByTime", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -48270,27 +48007,29 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Developer = string(dAtA[iNdEx:postIndex])
+				x.StatsByTime = append(x.StatsByTime, &QueryDebugStatsResponse_TemporaryTimeStat{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StatsByTime[len(x.StatsByTime)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StatsByEpoch", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -48317,8 +48056,8 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Stats = append(x.Stats, &DeveloperStatsByEpoch{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats[len(x.Stats)-1]); err != nil {
+				x.StatsByEpoch = append(x.StatsByEpoch, &QueryDebugStatsResponse_TemporaryEpochStat{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StatsByEpoch[len(x.StatsByEpoch)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -48357,25 +48096,80 @@ func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods
 	}
 }
 
+var _ protoreflect.List = (*_QueryDebugStatsResponse_TemporaryTimeStat_2_list)(nil)
+
+type _QueryDebugStatsResponse_TemporaryTimeStat_2_list struct {
+	list *[]*DeveloperStatsByTime
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByTime)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) AppendMutable() protoreflect.Value {
+	v := new(DeveloperStatsByTime)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) NewElement() protoreflect.Value {
+	v := new(DeveloperStatsByTime)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryTimeStat_2_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetMinimumValidationAverageRequest protoreflect.MessageDescriptor
+	md_QueryDebugStatsResponse_TemporaryTimeStat           protoreflect.MessageDescriptor
+	fd_QueryDebugStatsResponse_TemporaryTimeStat_developer protoreflect.FieldDescriptor
+	fd_QueryDebugStatsResponse_TemporaryTimeStat_stats     protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetMinimumValidationAverageRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetMinimumValidationAverageRequest")
+	md_QueryDebugStatsResponse_TemporaryTimeStat = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsResponse").Messages().ByName("TemporaryTimeStat")
+	fd_QueryDebugStatsResponse_TemporaryTimeStat_developer = md_QueryDebugStatsResponse_TemporaryTimeStat.Fields().ByName("developer")
+	fd_QueryDebugStatsResponse_TemporaryTimeStat_stats = md_QueryDebugStatsResponse_TemporaryTimeStat.Fields().ByName("stats")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetMinimumValidationAverageRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(nil)
 
-type fastReflection_QueryGetMinimumValidationAverageRequest QueryGetMinimumValidationAverageRequest
+type fastReflection_QueryDebugStatsResponse_TemporaryTimeStat QueryDebugStatsResponse_TemporaryTimeStat
 
-func (x *QueryGetMinimumValidationAverageRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetMinimumValidationAverageRequest)(x)
+func (x *QueryDebugStatsResponse_TemporaryTimeStat) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(x)
 }
 
-func (x *QueryGetMinimumValidationAverageRequest) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[99]
+func (x *QueryDebugStatsResponse_TemporaryTimeStat) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[182]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -48386,43 +48180,43 @@ func (x *QueryGetMinimumValidationAverageRequest) slowProtoReflect() protoreflec
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetMinimumValidationAverageRequest_messageType fastReflection_QueryGetMinimumValidationAverageRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetMinimumValidationAverageRequest_messageType{}
+var _fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType{}
 
-type fastReflection_QueryGetMinimumValidationAverageRequest_messageType struct{}
+type fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType struct{}
 
-func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetMinimumValidationAverageRequest)(nil)
+func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)(nil)
 }
-func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMinimumValidationAverageRequest)
+func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)
 }
-func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMinimumValidationAverageRequest
+func (x fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsResponse_TemporaryTimeStat
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMinimumValidationAverageRequest
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsResponse_TemporaryTimeStat
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetMinimumValidationAverageRequest_messageType
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDebugStatsResponse_TemporaryTimeStat_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMinimumValidationAverageRequest)
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsResponse_TemporaryTimeStat)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetMinimumValidationAverageRequest)(x)
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Interface() protoreflect.ProtoMessage {
+	return (*QueryDebugStatsResponse_TemporaryTimeStat)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -48430,7 +48224,19 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Developer != "" {
+		value := protoreflect.ValueOfString(x.Developer)
+		if !f(fd_QueryDebugStatsResponse_TemporaryTimeStat_developer, value) {
+			return
+		}
+	}
+	if len(x.Stats) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &x.Stats})
+		if !f(fd_QueryDebugStatsResponse_TemporaryTimeStat_stats, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -48444,13 +48250,17 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
+		return x.Developer != ""
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
+		return len(x.Stats) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48460,13 +48270,17 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
+		x.Developer = ""
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
+		x.Stats = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48476,13 +48290,22 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
+		value := x.Developer
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
+		if len(x.Stats) == 0 {
+			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryTimeStat_2_list{})
+		}
+		listValue := &_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &x.Stats}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -48496,13 +48319,19 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
+		x.Developer = value.Interface().(string)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
+		lv := value.List()
+		clv := lv.(*_QueryDebugStatsResponse_TemporaryTimeStat_2_list)
+		x.Stats = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48516,36 +48345,49 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
+		if x.Stats == nil {
+			x.Stats = []*DeveloperStatsByTime{}
+		}
+		value := &_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &x.Stats}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
+		panic(fmt.Errorf("field developer of message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.developer":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats":
+		list := []*DeveloperStatsByTime{}
+		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryTimeStat_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryTimeStat does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMinimumValidationAverageRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsResponse.TemporaryTimeStat", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -48553,7 +48395,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -48564,7 +48406,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -48576,7 +48418,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) IsValid() bool {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) IsValid() bool {
 	return x != nil
 }
 
@@ -48586,9 +48428,9 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryTimeStat) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
+		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48600,6 +48442,16 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods()
 		var n int
 		var l int
 		_ = l
+		l = len(x.Developer)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Stats) > 0 {
+			for _, e := range x.Stats {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -48610,7 +48462,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
+		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48629,6 +48481,29 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.Stats) > 0 {
+			for iNdEx := len(x.Stats) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Stats[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if len(x.Developer) > 0 {
+			i -= len(x.Developer)
+			copy(dAtA[i:], x.Developer)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Developer)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -48640,7 +48515,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
+		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryTimeStat)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -48672,12 +48547,78 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryTimeStat: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryTimeStat: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Developer = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Stats = append(x.Stats, &DeveloperStatsByTime{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats[len(x.Stats)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -48713,31 +48654,80 @@ func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods()
 	}
 }
 
-var (
-	md_QueryGetMinimumValidationAverageResponse                            protoreflect.MessageDescriptor
-	fd_QueryGetMinimumValidationAverageResponse_traffic_basis              protoreflect.FieldDescriptor
-	fd_QueryGetMinimumValidationAverageResponse_minimum_validation_average protoreflect.FieldDescriptor
-	fd_QueryGetMinimumValidationAverageResponse_block_height               protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_QueryDebugStatsResponse_TemporaryEpochStat_2_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryGetMinimumValidationAverageResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetMinimumValidationAverageResponse")
-	fd_QueryGetMinimumValidationAverageResponse_traffic_basis = md_QueryGetMinimumValidationAverageResponse.Fields().ByName("traffic_basis")
-	fd_QueryGetMinimumValidationAverageResponse_minimum_validation_average = md_QueryGetMinimumValidationAverageResponse.Fields().ByName("minimum_validation_average")
-	fd_QueryGetMinimumValidationAverageResponse_block_height = md_QueryGetMinimumValidationAverageResponse.Fields().ByName("block_height")
+type _QueryDebugStatsResponse_TemporaryEpochStat_2_list struct {
+	list *[]*DeveloperStatsByEpoch
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetMinimumValidationAverageResponse)(nil)
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-type fastReflection_QueryGetMinimumValidationAverageResponse QueryGetMinimumValidationAverageResponse
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
 
-func (x *QueryGetMinimumValidationAverageResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetMinimumValidationAverageResponse)(x)
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByEpoch)
+	(*x.list)[i] = concreteValue
 }
 
-func (x *QueryGetMinimumValidationAverageResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[100]
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DeveloperStatsByEpoch)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) AppendMutable() protoreflect.Value {
+	v := new(DeveloperStatsByEpoch)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) NewElement() protoreflect.Value {
+	v := new(DeveloperStatsByEpoch)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryDebugStatsResponse_TemporaryEpochStat_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryDebugStatsResponse_TemporaryEpochStat           protoreflect.MessageDescriptor
+	fd_QueryDebugStatsResponse_TemporaryEpochStat_developer protoreflect.FieldDescriptor
+	fd_QueryDebugStatsResponse_TemporaryEpochStat_stats     protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryDebugStatsResponse_TemporaryEpochStat = File_inference_inference_query_proto.Messages().ByName("QueryDebugStatsResponse").Messages().ByName("TemporaryEpochStat")
+	fd_QueryDebugStatsResponse_TemporaryEpochStat_developer = md_QueryDebugStatsResponse_TemporaryEpochStat.Fields().ByName("developer")
+	fd_QueryDebugStatsResponse_TemporaryEpochStat_stats = md_QueryDebugStatsResponse_TemporaryEpochStat.Fields().ByName("stats")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(nil)
+
+type fastReflection_QueryDebugStatsResponse_TemporaryEpochStat QueryDebugStatsResponse_TemporaryEpochStat
+
+func (x *QueryDebugStatsResponse_TemporaryEpochStat) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(x)
+}
+
+func (x *QueryDebugStatsResponse_TemporaryEpochStat) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[183]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -48748,43 +48738,43 @@ func (x *QueryGetMinimumValidationAverageResponse) slowProtoReflect() protorefle
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetMinimumValidationAverageResponse_messageType fastReflection_QueryGetMinimumValidationAverageResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetMinimumValidationAverageResponse_messageType{}
+var _fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType
+var _ protoreflect.MessageType = fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType{}
 
-type fastReflection_QueryGetMinimumValidationAverageResponse_messageType struct{}
+type fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType struct{}
 
-func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetMinimumValidationAverageResponse)(nil)
+func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)(nil)
 }
-func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMinimumValidationAverageResponse)
+func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)
 }
-func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMinimumValidationAverageResponse
+func (x fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsResponse_TemporaryEpochStat
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMinimumValidationAverageResponse
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryDebugStatsResponse_TemporaryEpochStat
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetMinimumValidationAverageResponse_messageType
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Type() protoreflect.MessageType {
+	return _fastReflection_QueryDebugStatsResponse_TemporaryEpochStat_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMinimumValidationAverageResponse)
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) New() protoreflect.Message {
+	return new(fastReflection_QueryDebugStatsResponse_TemporaryEpochStat)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetMinimumValidationAverageResponse)(x)
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Interface() protoreflect.ProtoMessage {
+	return (*QueryDebugStatsResponse_TemporaryEpochStat)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -48792,22 +48782,16 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Interface() pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.TrafficBasis != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.TrafficBasis)
-		if !f(fd_QueryGetMinimumValidationAverageResponse_traffic_basis, value) {
-			return
-		}
-	}
-	if x.MinimumValidationAverage != "" {
-		value := protoreflect.ValueOfString(x.MinimumValidationAverage)
-		if !f(fd_QueryGetMinimumValidationAverageResponse_minimum_validation_average, value) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Developer != "" {
+		value := protoreflect.ValueOfString(x.Developer)
+		if !f(fd_QueryDebugStatsResponse_TemporaryEpochStat_developer, value) {
 			return
 		}
 	}
-	if x.BlockHeight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.BlockHeight)
-		if !f(fd_QueryGetMinimumValidationAverageResponse_block_height, value) {
+	if len(x.Stats) != 0 {
+		value := protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats})
+		if !f(fd_QueryDebugStatsResponse_TemporaryEpochStat_stats, value) {
 			return
 		}
 	}
@@ -48824,19 +48808,17 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Range(f func(p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
-		return x.TrafficBasis != uint64(0)
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
-		return x.MinimumValidationAverage != ""
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
-		return x.BlockHeight != uint64(0)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
+		return x.Developer != ""
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+		return len(x.Stats) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48846,19 +48828,17 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Has(fd protore
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
-		x.TrafficBasis = uint64(0)
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
-		x.MinimumValidationAverage = ""
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
-		x.BlockHeight = uint64(0)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
+		x.Developer = ""
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+		x.Stats = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48868,22 +48848,22 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Clear(fd proto
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
-		value := x.TrafficBasis
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
-		value := x.MinimumValidationAverage
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
+		value := x.Developer
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+		if len(x.Stats) == 0 {
+			return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{})
+		}
+		listValue := &_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -48897,19 +48877,19 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
-		x.TrafficBasis = value.Uint()
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
-		x.MinimumValidationAverage = value.Interface().(string)
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
-		x.BlockHeight = value.Uint()
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
+		x.Developer = value.Interface().(string)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+		lv := value.List()
+		clv := lv.(*_QueryDebugStatsResponse_TemporaryEpochStat_2_list)
+		x.Stats = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -48923,48 +48903,49 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Set(fd protore
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
-		panic(fmt.Errorf("field traffic_basis of message inference.inference.QueryGetMinimumValidationAverageResponse is not mutable"))
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
-		panic(fmt.Errorf("field minimum_validation_average of message inference.inference.QueryGetMinimumValidationAverageResponse is not mutable"))
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryGetMinimumValidationAverageResponse is not mutable"))
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+		if x.Stats == nil {
+			x.Stats = []*DeveloperStatsByEpoch{}
+		}
+		value := &_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &x.Stats}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
+		panic(fmt.Errorf("field developer of message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.developer":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats":
+		list := []*DeveloperStatsByEpoch{}
+		return protoreflect.ValueOfList(&_QueryDebugStatsResponse_TemporaryEpochStat_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryDebugStatsResponse.TemporaryEpochStat does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMinimumValidationAverageResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryDebugStatsResponse.TemporaryEpochStat", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -48972,7 +48953,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) WhichOneof(d p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -48983,7 +48964,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) GetUnknown() p
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -48995,7 +48976,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) SetUnknown(fie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) IsValid() bool {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) IsValid() bool {
 	return x != nil
 }
 
@@ -49005,9 +48986,9 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryDebugStatsResponse_TemporaryEpochStat) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
+		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49019,15 +49000,15 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 		var n int
 		var l int
 		_ = l
-		if x.TrafficBasis != 0 {
-			n += 1 + runtime.Sov(uint64(x.TrafficBasis))
-		}
-		l = len(x.MinimumValidationAverage)
+		l = len(x.Developer)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if len(x.Stats) > 0 {
+			for _, e := range x.Stats {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -49039,7 +49020,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
+		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49058,22 +49039,28 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
-			i--
-			dAtA[i] = 0x18
-		}
-		if len(x.MinimumValidationAverage) > 0 {
-			i -= len(x.MinimumValidationAverage)
-			copy(dAtA[i:], x.MinimumValidationAverage)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MinimumValidationAverage)))
-			i--
-			dAtA[i] = 0x12
+		if len(x.Stats) > 0 {
+			for iNdEx := len(x.Stats) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Stats[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
 		}
-		if x.TrafficBasis != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.TrafficBasis))
+		if len(x.Developer) > 0 {
+			i -= len(x.Developer)
+			copy(dAtA[i:], x.Developer)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Developer)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -49086,7 +49073,7 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
+		x := input.Message.Interface().(*QueryDebugStatsResponse_TemporaryEpochStat)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49118,34 +49105,15 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryEpochStat: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryDebugStatsResponse_TemporaryEpochStat: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TrafficBasis", wireType)
-				}
-				x.TrafficBasis = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.TrafficBasis |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinimumValidationAverage", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -49173,13 +49141,13 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.MinimumValidationAverage = string(dAtA[iNdEx:postIndex])
+				x.Developer = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
 				}
-				x.BlockHeight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -49189,11 +49157,26 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Stats = append(x.Stats, &DeveloperStatsByEpoch{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats[len(x.Stats)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -49230,25 +49213,23 @@ func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods()
 }
 
 var (
-	md_QueryGetPartialUpgradeRequest        protoreflect.MessageDescriptor
-	fd_QueryGetPartialUpgradeRequest_height protoreflect.FieldDescriptor
+	md_QueryGetMinimumValidationAverageRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetPartialUpgradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetPartialUpgradeRequest")
-	fd_QueryGetPartialUpgradeRequest_height = md_QueryGetPartialUpgradeRequest.Fields().ByName("height")
+	md_QueryGetMinimumValidationAverageRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetMinimumValidationAverageRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetPartialUpgradeRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetMinimumValidationAverageRequest)(nil)
 
-type fastReflection_QueryGetPartialUpgradeRequest QueryGetPartialUpgradeRequest
+type fastReflection_QueryGetMinimumValidationAverageRequest QueryGetMinimumValidationAverageRequest
 
-func (x *QueryGetPartialUpgradeRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetPartialUpgradeRequest)(x)
+func (x *QueryGetMinimumValidationAverageRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetMinimumValidationAverageRequest)(x)
 }
 
-func (x *QueryGetPartialUpgradeRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetMinimumValidationAverageRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[101]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -49260,43 +49241,43 @@ func (x *QueryGetPartialUpgradeRequest) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetPartialUpgradeRequest_messageType fastReflection_QueryGetPartialUpgradeRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetPartialUpgradeRequest_messageType{}
+var _fastReflection_QueryGetMinimumValidationAverageRequest_messageType fastReflection_QueryGetMinimumValidationAverageRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMinimumValidationAverageRequest_messageType{}
 
-type fastReflection_QueryGetPartialUpgradeRequest_messageType struct{}
+type fastReflection_QueryGetMinimumValidationAverageRequest_messageType struct{}
 
-func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetPartialUpgradeRequest)(nil)
+func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetMinimumValidationAverageRequest)(nil)
 }
-func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetPartialUpgradeRequest)
+func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMinimumValidationAverageRequest)
 }
-func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetPartialUpgradeRequest
+func (x fastReflection_QueryGetMinimumValidationAverageRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMinimumValidationAverageRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetPartialUpgradeRequest
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMinimumValidationAverageRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetPartialUpgradeRequest_messageType
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetMinimumValidationAverageRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetPartialUpgradeRequest)
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMinimumValidationAverageRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetPartialUpgradeRequest)(x)
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetMinimumValidationAverageRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -49304,13 +49285,7 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Height != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Height)
-		if !f(fd_QueryGetPartialUpgradeRequest_height, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -49324,15 +49299,13 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeRequest.height":
-		return x.Height != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -49342,15 +49315,13 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeRequest.height":
-		x.Height = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -49360,16 +49331,13 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeRequest.height":
-		value := x.Height
-		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -49383,15 +49351,13 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeRequest.height":
-		x.Height = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -49405,40 +49371,36 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeRequest.height":
-		panic(fmt.Errorf("field height of message inference.inference.QueryGetPartialUpgradeRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeRequest.height":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetPartialUpgradeRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMinimumValidationAverageRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -49446,7 +49408,7 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -49457,7 +49419,7 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -49469,7 +49431,7 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) IsValid() bool {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -49479,9 +49441,9 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetMinimumValidationAverageRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
+		x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49493,9 +49455,6 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if x.Height != 0 {
-			n += 1 + runtime.Sov(uint64(x.Height))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -49506,7 +49465,7 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
+		x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49525,11 +49484,6 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Height != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Height))
-			i--
-			dAtA[i] = 0x8
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -49541,7 +49495,7 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
+		x := input.Message.Interface().(*QueryGetMinimumValidationAverageRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49573,31 +49527,12 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
-				}
-				x.Height = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Height |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -49634,25 +49569,29 @@ func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryGetPartialUpgradeResponse                protoreflect.MessageDescriptor
-	fd_QueryGetPartialUpgradeResponse_partialUpgrade protoreflect.FieldDescriptor
+	md_QueryGetMinimumValidationAverageResponse                            protoreflect.MessageDescriptor
+	fd_QueryGetMinimumValidationAverageResponse_traffic_basis              protoreflect.FieldDescriptor
+	fd_QueryGetMinimumValidationAverageResponse_minimum_validation_average protoreflect.FieldDescriptor
+	fd_QueryGetMinimumValidationAverageResponse_block_height               protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetPartialUpgradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetPartialUpgradeResponse")
-	fd_QueryGetPartialUpgradeResponse_partialUpgrade = md_QueryGetPartialUpgradeResponse.Fields().ByName("partialUpgrade")
+	md_QueryGetMinimumValidationAverageResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetMinimumValidationAverageResponse")
+	fd_QueryGetMinimumValidationAverageResponse_traffic_basis = md_QueryGetMinimumValidationAverageResponse.Fields().ByName("traffic_basis")
+	fd_QueryGetMinimumValidationAverageResponse_minimum_validation_average = md_QueryGetMinimumValidationAverageResponse.Fields().ByName("minimum_validation_average")
+	fd_QueryGetMinimumValidationAverageResponse_block_height = md_QueryGetMinimumValidationAverageResponse.Fields().ByName("block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetPartialUpgradeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetMinimumValidationAverageResponse)(nil)
 
-type fastReflection_QueryGetPartialUpgradeResponse QueryGetPartialUpgradeResponse
+type fastReflection_QueryGetMinimumValidationAverageResponse QueryGetMinimumValidationAverageResponse
 
-func (x *QueryGetPartialUpgradeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetPartialUpgradeResponse)(x)
+func (x *QueryGetMinimumValidationAverageResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetMinimumValidationAverageResponse)(x)
 }
 
-func (x *QueryGetPartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetMinimumValidationAverageResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[102]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -49664,43 +49603,43 @@ func (x *QueryGetPartialUpgradeResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetPartialUpgradeResponse_messageType fastReflection_QueryGetPartialUpgradeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetPartialUpgradeResponse_messageType{}
+var _fastReflection_QueryGetMinimumValidationAverageResponse_messageType fastReflection_QueryGetMinimumValidationAverageResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMinimumValidationAverageResponse_messageType{}
 
-type fastReflection_QueryGetPartialUpgradeResponse_messageType struct{}
+type fastReflection_QueryGetMinimumValidationAverageResponse_messageType struct{}
 
-func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetPartialUpgradeResponse)(nil)
+func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetMinimumValidationAverageResponse)(nil)
 }
-func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetPartialUpgradeResponse)
+func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMinimumValidationAverageResponse)
 }
-func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetPartialUpgradeResponse
+func (x fastReflection_QueryGetMinimumValidationAverageResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMinimumValidationAverageResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetPartialUpgradeResponse
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMinimumValidationAverageResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetPartialUpgradeResponse_messageType
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetMinimumValidationAverageResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetPartialUpgradeResponse)
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMinimumValidationAverageResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetPartialUpgradeResponse)(x)
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetMinimumValidationAverageResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -49708,10 +49647,22 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) Interface() protoreflect
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.PartialUpgrade != nil {
-		value := protoreflect.ValueOfMessage(x.PartialUpgrade.ProtoReflect())
-		if !f(fd_QueryGetPartialUpgradeResponse_partialUpgrade, value) {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.TrafficBasis != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.TrafficBasis)
+		if !f(fd_QueryGetMinimumValidationAverageResponse_traffic_basis, value) {
+			return
+		}
+	}
+	if x.MinimumValidationAverage != "" {
+		value := protoreflect.ValueOfString(x.MinimumValidationAverage)
+		if !f(fd_QueryGetMinimumValidationAverageResponse_minimum_validation_average, value) {
+			return
+		}
+	}
+	if x.BlockHeight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.BlockHeight)
+		if !f(fd_QueryGetMinimumValidationAverageResponse_block_height, value) {
 			return
 		}
 	}
@@ -49728,15 +49679,19 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) Range(f func(protoreflec
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
-		return x.PartialUpgrade != nil
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
+		return x.TrafficBasis != uint64(0)
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+		return x.MinimumValidationAverage != ""
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
+		return x.BlockHeight != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -49746,15 +49701,19 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) Has(fd protoreflect.Fiel
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
-		x.PartialUpgrade = nil
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
+		x.TrafficBasis = uint64(0)
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+		x.MinimumValidationAverage = ""
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
+		x.BlockHeight = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -49764,16 +49723,22 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) Clear(fd protoreflect.Fi
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
-		value := x.PartialUpgrade
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
+		value := x.TrafficBasis
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+		value := x.MinimumValidationAverage
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -49787,15 +49752,19 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) Get(descriptor protorefl
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
-		x.PartialUpgrade = value.Message().Interface().(*PartialUpgrade)
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
+		x.TrafficBasis = value.Uint()
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+		x.MinimumValidationAverage = value.Interface().(string)
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
+		x.BlockHeight = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -49809,44 +49778,48 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) Set(fd protoreflect.Fiel
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
-		if x.PartialUpgrade == nil {
-			x.PartialUpgrade = new(PartialUpgrade)
-		}
-		return protoreflect.ValueOfMessage(x.PartialUpgrade.ProtoReflect())
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
+		panic(fmt.Errorf("field traffic_basis of message inference.inference.QueryGetMinimumValidationAverageResponse is not mutable"))
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+		panic(fmt.Errorf("field minimum_validation_average of message inference.inference.QueryGetMinimumValidationAverageResponse is not mutable"))
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryGetMinimumValidationAverageResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
-		m := new(PartialUpgrade)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.traffic_basis":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.minimum_validation_average":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryGetMinimumValidationAverageResponse.block_height":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMinimumValidationAverageResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMinimumValidationAverageResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetPartialUpgradeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMinimumValidationAverageResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -49854,7 +49827,7 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) WhichOneof(d protoreflec
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -49865,7 +49838,7 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) GetUnknown() protoreflec
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -49877,7 +49850,7 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) SetUnknown(fields protor
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) IsValid() bool {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -49887,9 +49860,9 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetMinimumValidationAverageResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
+		x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49901,10 +49874,16 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 		var n int
 		var l int
 		_ = l
-		if x.PartialUpgrade != nil {
-			l = options.Size(x.PartialUpgrade)
+		if x.TrafficBasis != 0 {
+			n += 1 + runtime.Sov(uint64(x.TrafficBasis))
+		}
+		l = len(x.MinimumValidationAverage)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -49915,7 +49894,7 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
+		x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49934,19 +49913,22 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.PartialUpgrade != nil {
-			encoded, err := options.Marshal(x.PartialUpgrade)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x18
+		}
+		if len(x.MinimumValidationAverage) > 0 {
+			i -= len(x.MinimumValidationAverage)
+			copy(dAtA[i:], x.MinimumValidationAverage)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MinimumValidationAverage)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.TrafficBasis != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.TrafficBasis))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -49959,7 +49941,7 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
+		x := input.Message.Interface().(*QueryGetMinimumValidationAverageResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -49991,17 +49973,36 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TrafficBasis", wireType)
+				}
+				x.TrafficBasis = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.TrafficBasis |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PartialUpgrade", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MinimumValidationAverage", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -50011,28 +50012,43 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.PartialUpgrade == nil {
-					x.PartialUpgrade = &PartialUpgrade{}
+				x.MinimumValidationAverage = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialUpgrade); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.BlockHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.BlockHeight |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -50069,25 +50085,25 @@ func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoifa
 }
 
 var (
-	md_QueryAllPartialUpgradeRequest            protoreflect.MessageDescriptor
-	fd_QueryAllPartialUpgradeRequest_pagination protoreflect.FieldDescriptor
+	md_QueryGetPartialUpgradeRequest        protoreflect.MessageDescriptor
+	fd_QueryGetPartialUpgradeRequest_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllPartialUpgradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllPartialUpgradeRequest")
-	fd_QueryAllPartialUpgradeRequest_pagination = md_QueryAllPartialUpgradeRequest.Fields().ByName("pagination")
+	md_QueryGetPartialUpgradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetPartialUpgradeRequest")
+	fd_QueryGetPartialUpgradeRequest_height = md_QueryGetPartialUpgradeRequest.Fields().ByName("height")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllPartialUpgradeRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetPartialUpgradeRequest)(nil)
 
-type fastReflection_QueryAllPartialUpgradeRequest QueryAllPartialUpgradeRequest
+type fastReflection_QueryGetPartialUpgradeRequest QueryGetPartialUpgradeRequest
 
-func (x *QueryAllPartialUpgradeRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllPartialUpgradeRequest)(x)
+func (x *QueryGetPartialUpgradeRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetPartialUpgradeRequest)(x)
 }
 
-func (x *QueryAllPartialUpgradeRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetPartialUpgradeRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[103]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -50099,43 +50115,43 @@ func (x *QueryAllPartialUpgradeRequest) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllPartialUpgradeRequest_messageType fastReflection_QueryAllPartialUpgradeRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllPartialUpgradeRequest_messageType{}
+var _fastReflection_QueryGetPartialUpgradeRequest_messageType fastReflection_QueryGetPartialUpgradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetPartialUpgradeRequest_messageType{}
 
-type fastReflection_QueryAllPartialUpgradeRequest_messageType struct{}
+type fastReflection_QueryGetPartialUpgradeRequest_messageType struct{}
 
-func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllPartialUpgradeRequest)(nil)
+func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetPartialUpgradeRequest)(nil)
 }
-func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPartialUpgradeRequest)
+func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetPartialUpgradeRequest)
 }
-func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPartialUpgradeRequest
+func (x fastReflection_QueryGetPartialUpgradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetPartialUpgradeRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPartialUpgradeRequest
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetPartialUpgradeRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllPartialUpgradeRequest_messageType
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetPartialUpgradeRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPartialUpgradeRequest)
+func (x *fastReflection_QueryGetPartialUpgradeRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetPartialUpgradeRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllPartialUpgradeRequest)(x)
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetPartialUpgradeRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -50143,10 +50159,10 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllPartialUpgradeRequest_pagination, value) {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Height != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Height)
+		if !f(fd_QueryGetPartialUpgradeRequest_height, value) {
 			return
 		}
 	}
@@ -50163,15 +50179,15 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetPartialUpgradeRequest.height":
+		return x.Height != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -50181,15 +50197,15 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryGetPartialUpgradeRequest.height":
+		x.Height = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -50199,16 +50215,16 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetPartialUpgradeRequest.height":
+		value := x.Height
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -50222,15 +50238,15 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryGetPartialUpgradeRequest.height":
+		x.Height = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -50244,44 +50260,40 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryGetPartialUpgradeRequest.height":
+		panic(fmt.Errorf("field height of message inference.inference.QueryGetPartialUpgradeRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetPartialUpgradeRequest.height":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPartialUpgradeRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetPartialUpgradeRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -50289,7 +50301,7 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -50300,7 +50312,7 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -50312,7 +50324,7 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) IsValid() bool {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -50322,9 +50334,9 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetPartialUpgradeRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
+		x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50336,9 +50348,8 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Height != 0 {
+			n += 1 + runtime.Sov(uint64(x.Height))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -50350,7 +50361,7 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
+		x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50369,19 +50380,10 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.Height != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Height))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -50394,7 +50396,7 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
+		x := input.Message.Interface().(*QueryGetPartialUpgradeRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50426,17 +50428,17 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
 				}
-				var msglen int
+				x.Height = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -50446,28 +50448,11 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Height |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -50503,127 +50488,74 @@ func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoifac
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllPartialUpgradeResponse_1_list)(nil)
-
-type _QueryAllPartialUpgradeResponse_1_list struct {
-	list *[]*PartialUpgrade
-}
-
-func (x *_QueryAllPartialUpgradeResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
+var (
+	md_QueryGetPartialUpgradeResponse                protoreflect.MessageDescriptor
+	fd_QueryGetPartialUpgradeResponse_partialUpgrade protoreflect.FieldDescriptor
+)
 
-func (x *_QueryAllPartialUpgradeResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetPartialUpgradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetPartialUpgradeResponse")
+	fd_QueryGetPartialUpgradeResponse_partialUpgrade = md_QueryGetPartialUpgradeResponse.Fields().ByName("partialUpgrade")
 }
 
-func (x *_QueryAllPartialUpgradeResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PartialUpgrade)
-	(*x.list)[i] = concreteValue
-}
+var _ protoreflect.Message = (*fastReflection_QueryGetPartialUpgradeResponse)(nil)
 
-func (x *_QueryAllPartialUpgradeResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PartialUpgrade)
-	*x.list = append(*x.list, concreteValue)
-}
+type fastReflection_QueryGetPartialUpgradeResponse QueryGetPartialUpgradeResponse
 
-func (x *_QueryAllPartialUpgradeResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(PartialUpgrade)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
+func (x *QueryGetPartialUpgradeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetPartialUpgradeResponse)(x)
 }
 
-func (x *_QueryAllPartialUpgradeResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
+func (x *QueryGetPartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[104]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
-	*x.list = (*x.list)[:n]
+	return mi.MessageOf(x)
 }
 
-func (x *_QueryAllPartialUpgradeResponse_1_list) NewElement() protoreflect.Value {
-	v := new(PartialUpgrade)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryAllPartialUpgradeResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
-var (
-	md_QueryAllPartialUpgradeResponse                protoreflect.MessageDescriptor
-	fd_QueryAllPartialUpgradeResponse_partialUpgrade protoreflect.FieldDescriptor
-	fd_QueryAllPartialUpgradeResponse_pagination     protoreflect.FieldDescriptor
-)
-
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryAllPartialUpgradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllPartialUpgradeResponse")
-	fd_QueryAllPartialUpgradeResponse_partialUpgrade = md_QueryAllPartialUpgradeResponse.Fields().ByName("partialUpgrade")
-	fd_QueryAllPartialUpgradeResponse_pagination = md_QueryAllPartialUpgradeResponse.Fields().ByName("pagination")
-}
-
-var _ protoreflect.Message = (*fastReflection_QueryAllPartialUpgradeResponse)(nil)
-
-type fastReflection_QueryAllPartialUpgradeResponse QueryAllPartialUpgradeResponse
-
-func (x *QueryAllPartialUpgradeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllPartialUpgradeResponse)(x)
-}
-
-func (x *QueryAllPartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[104]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-var _fastReflection_QueryAllPartialUpgradeResponse_messageType fastReflection_QueryAllPartialUpgradeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllPartialUpgradeResponse_messageType{}
+var _fastReflection_QueryGetPartialUpgradeResponse_messageType fastReflection_QueryGetPartialUpgradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetPartialUpgradeResponse_messageType{}
 
-type fastReflection_QueryAllPartialUpgradeResponse_messageType struct{}
+type fastReflection_QueryGetPartialUpgradeResponse_messageType struct{}
 
-func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllPartialUpgradeResponse)(nil)
+func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetPartialUpgradeResponse)(nil)
 }
-func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPartialUpgradeResponse)
+func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetPartialUpgradeResponse)
 }
-func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPartialUpgradeResponse
+func (x fastReflection_QueryGetPartialUpgradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetPartialUpgradeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllPartialUpgradeResponse
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetPartialUpgradeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllPartialUpgradeResponse_messageType
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetPartialUpgradeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllPartialUpgradeResponse)
+func (x *fastReflection_QueryGetPartialUpgradeResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetPartialUpgradeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllPartialUpgradeResponse)(x)
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetPartialUpgradeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -50631,16 +50563,10 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) Interface() protoreflect
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.PartialUpgrade) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllPartialUpgradeResponse_1_list{list: &x.PartialUpgrade})
-		if !f(fd_QueryAllPartialUpgradeResponse_partialUpgrade, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllPartialUpgradeResponse_pagination, value) {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.PartialUpgrade != nil {
+		value := protoreflect.ValueOfMessage(x.PartialUpgrade.ProtoReflect())
+		if !f(fd_QueryGetPartialUpgradeResponse_partialUpgrade, value) {
 			return
 		}
 	}
@@ -50657,17 +50583,15 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) Range(f func(protoreflec
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
-		return len(x.PartialUpgrade) != 0
-	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
+		return x.PartialUpgrade != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -50677,17 +50601,15 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) Has(fd protoreflect.Fiel
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
 		x.PartialUpgrade = nil
-	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -50697,22 +50619,16 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) Clear(fd protoreflect.Fi
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
-		if len(x.PartialUpgrade) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllPartialUpgradeResponse_1_list{})
-		}
-		listValue := &_QueryAllPartialUpgradeResponse_1_list{list: &x.PartialUpgrade}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
+		value := x.PartialUpgrade
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -50726,19 +50642,15 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) Get(descriptor protorefl
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
-		lv := value.List()
-		clv := lv.(*_QueryAllPartialUpgradeResponse_1_list)
-		x.PartialUpgrade = *clv.list
-	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
+		x.PartialUpgrade = value.Message().Interface().(*PartialUpgrade)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -50752,53 +50664,44 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) Set(fd protoreflect.Fiel
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
 		if x.PartialUpgrade == nil {
-			x.PartialUpgrade = []*PartialUpgrade{}
-		}
-		value := &_QueryAllPartialUpgradeResponse_1_list{list: &x.PartialUpgrade}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
+			x.PartialUpgrade = new(PartialUpgrade)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.PartialUpgrade.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
-		list := []*PartialUpgrade{}
-		return protoreflect.ValueOfList(&_QueryAllPartialUpgradeResponse_1_list{list: &list})
-	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
-		m := new(v1beta1.PageResponse)
+	case "inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade":
+		m := new(PartialUpgrade)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPartialUpgradeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetPartialUpgradeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -50806,7 +50709,7 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) WhichOneof(d protoreflec
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -50817,7 +50720,7 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) GetUnknown() protoreflec
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -50829,7 +50732,7 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) SetUnknown(fields protor
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) IsValid() bool {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -50839,9 +50742,9 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetPartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
+		x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50853,14 +50756,8 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 		var n int
 		var l int
 		_ = l
-		if len(x.PartialUpgrade) > 0 {
-			for _, e := range x.PartialUpgrade {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.PartialUpgrade != nil {
+			l = options.Size(x.PartialUpgrade)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -50873,7 +50770,7 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
+		x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50892,8 +50789,8 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.PartialUpgrade != nil {
+			encoded, err := options.Marshal(x.PartialUpgrade)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50904,23 +50801,7 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.PartialUpgrade) > 0 {
-			for iNdEx := len(x.PartialUpgrade) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.PartialUpgrade[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -50933,7 +50814,7 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
+		x := input.Message.Interface().(*QueryGetPartialUpgradeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -50965,10 +50846,10 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -51000,44 +50881,10 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.PartialUpgrade = append(x.PartialUpgrade, &PartialUpgrade{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialUpgrade[len(x.PartialUpgrade)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
+				if x.PartialUpgrade == nil {
+					x.PartialUpgrade = &PartialUpgrade{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialUpgrade); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -51077,29 +50924,25 @@ func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoifa
 }
 
 var (
-	md_QueryGetBridgeTransactionRequest               protoreflect.MessageDescriptor
-	fd_QueryGetBridgeTransactionRequest_origin_chain  protoreflect.FieldDescriptor
-	fd_QueryGetBridgeTransactionRequest_block_number  protoreflect.FieldDescriptor
-	fd_QueryGetBridgeTransactionRequest_receipt_index protoreflect.FieldDescriptor
+	md_QueryAllPartialUpgradeRequest            protoreflect.MessageDescriptor
+	fd_QueryAllPartialUpgradeRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetBridgeTransactionRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetBridgeTransactionRequest")
-	fd_QueryGetBridgeTransactionRequest_origin_chain = md_QueryGetBridgeTransactionRequest.Fields().ByName("origin_chain")
-	fd_QueryGetBridgeTransactionRequest_block_number = md_QueryGetBridgeTransactionRequest.Fields().ByName("block_number")
-	fd_QueryGetBridgeTransactionRequest_receipt_index = md_QueryGetBridgeTransactionRequest.Fields().ByName("receipt_index")
+	md_QueryAllPartialUpgradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllPartialUpgradeRequest")
+	fd_QueryAllPartialUpgradeRequest_pagination = md_QueryAllPartialUpgradeRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetBridgeTransactionRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllPartialUpgradeRequest)(nil)
 
-type fastReflection_QueryGetBridgeTransactionRequest QueryGetBridgeTransactionRequest
+type fastReflection_QueryAllPartialUpgradeRequest QueryAllPartialUpgradeRequest
 
-func (x *QueryGetBridgeTransactionRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetBridgeTransactionRequest)(x)
+func (x *QueryAllPartialUpgradeRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllPartialUpgradeRequest)(x)
 }
 
-func (x *QueryGetBridgeTransactionRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllPartialUpgradeRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[105]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -51111,43 +50954,43 @@ func (x *QueryGetBridgeTransactionRequest) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetBridgeTransactionRequest_messageType fastReflection_QueryGetBridgeTransactionRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetBridgeTransactionRequest_messageType{}
+var _fastReflection_QueryAllPartialUpgradeRequest_messageType fastReflection_QueryAllPartialUpgradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllPartialUpgradeRequest_messageType{}
 
-type fastReflection_QueryGetBridgeTransactionRequest_messageType struct{}
+type fastReflection_QueryAllPartialUpgradeRequest_messageType struct{}
 
-func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetBridgeTransactionRequest)(nil)
+func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllPartialUpgradeRequest)(nil)
 }
-func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetBridgeTransactionRequest)
+func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPartialUpgradeRequest)
 }
-func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetBridgeTransactionRequest
+func (x fastReflection_QueryAllPartialUpgradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPartialUpgradeRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetBridgeTransactionRequest
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPartialUpgradeRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetBridgeTransactionRequest_messageType
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllPartialUpgradeRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetBridgeTransactionRequest)
+func (x *fastReflection_QueryAllPartialUpgradeRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPartialUpgradeRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetBridgeTransactionRequest)(x)
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllPartialUpgradeRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -51155,22 +50998,10 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.OriginChain != "" {
-		value := protoreflect.ValueOfString(x.OriginChain)
-		if !f(fd_QueryGetBridgeTransactionRequest_origin_chain, value) {
-			return
-		}
-	}
-	if x.BlockNumber != "" {
-		value := protoreflect.ValueOfString(x.BlockNumber)
-		if !f(fd_QueryGetBridgeTransactionRequest_block_number, value) {
-			return
-		}
-	}
-	if x.ReceiptIndex != "" {
-		value := protoreflect.ValueOfString(x.ReceiptIndex)
-		if !f(fd_QueryGetBridgeTransactionRequest_receipt_index, value) {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllPartialUpgradeRequest_pagination, value) {
 			return
 		}
 	}
@@ -51187,19 +51018,15 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
-		return x.OriginChain != ""
-	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
-		return x.BlockNumber != ""
-	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
-		return x.ReceiptIndex != ""
+	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -51209,19 +51036,15 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
-		x.OriginChain = ""
-	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
-		x.BlockNumber = ""
-	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
-		x.ReceiptIndex = ""
+	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -51231,22 +51054,16 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
-		value := x.OriginChain
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
-		value := x.BlockNumber
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
-		value := x.ReceiptIndex
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -51260,19 +51077,15 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
-		x.OriginChain = value.Interface().(string)
-	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
-		x.BlockNumber = value.Interface().(string)
-	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
-		x.ReceiptIndex = value.Interface().(string)
+	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -51286,48 +51099,44 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
-		panic(fmt.Errorf("field origin_chain of message inference.inference.QueryGetBridgeTransactionRequest is not mutable"))
-	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
-		panic(fmt.Errorf("field block_number of message inference.inference.QueryGetBridgeTransactionRequest is not mutable"))
-	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
-		panic(fmt.Errorf("field receipt_index of message inference.inference.QueryGetBridgeTransactionRequest is not mutable"))
+	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllPartialUpgradeRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetBridgeTransactionRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPartialUpgradeRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -51335,7 +51144,7 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -51346,7 +51155,7 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -51358,7 +51167,7 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) IsValid() bool {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -51368,9 +51177,9 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllPartialUpgradeRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
+		x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -51382,16 +51191,8 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
-		l = len(x.OriginChain)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.BlockNumber)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.ReceiptIndex)
-		if l > 0 {
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -51404,7 +51205,7 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
+		x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -51423,24 +51224,17 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ReceiptIndex) > 0 {
-			i -= len(x.ReceiptIndex)
-			copy(dAtA[i:], x.ReceiptIndex)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptIndex)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.BlockNumber) > 0 {
-			i -= len(x.BlockNumber)
-			copy(dAtA[i:], x.BlockNumber)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlockNumber)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.OriginChain) > 0 {
-			i -= len(x.OriginChain)
-			copy(dAtA[i:], x.OriginChain)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OriginChain)))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -51455,7 +51249,7 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
+		x := input.Message.Interface().(*QueryAllPartialUpgradeRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -51487,17 +51281,17 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OriginChain", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -51507,87 +51301,27 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.OriginChain = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.BlockNumber = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptIndex", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
 				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				x.ReceiptIndex = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -51624,77 +51358,79 @@ func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoi
 	}
 }
 
-var _ protoreflect.List = (*_QueryGetBridgeTransactionResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryAllPartialUpgradeResponse_1_list)(nil)
 
-type _QueryGetBridgeTransactionResponse_1_list struct {
-	list *[]*BridgeTransaction
+type _QueryAllPartialUpgradeResponse_1_list struct {
+	list *[]*PartialUpgrade
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) Len() int {
+func (x *_QueryAllPartialUpgradeResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryAllPartialUpgradeResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryAllPartialUpgradeResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+	concreteValue := valueUnwrapped.Interface().(*PartialUpgrade)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryAllPartialUpgradeResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+	concreteValue := valueUnwrapped.Interface().(*PartialUpgrade)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(BridgeTransaction)
+func (x *_QueryAllPartialUpgradeResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(PartialUpgrade)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) Truncate(n int) {
+func (x *_QueryAllPartialUpgradeResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) NewElement() protoreflect.Value {
-	v := new(BridgeTransaction)
+func (x *_QueryAllPartialUpgradeResponse_1_list) NewElement() protoreflect.Value {
+	v := new(PartialUpgrade)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryGetBridgeTransactionResponse_1_list) IsValid() bool {
+func (x *_QueryAllPartialUpgradeResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryGetBridgeTransactionResponse                    protoreflect.MessageDescriptor
-	fd_QueryGetBridgeTransactionResponse_bridgeTransactions protoreflect.FieldDescriptor
+	md_QueryAllPartialUpgradeResponse                protoreflect.MessageDescriptor
+	fd_QueryAllPartialUpgradeResponse_partialUpgrade protoreflect.FieldDescriptor
+	fd_QueryAllPartialUpgradeResponse_pagination     protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetBridgeTransactionResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetBridgeTransactionResponse")
-	fd_QueryGetBridgeTransactionResponse_bridgeTransactions = md_QueryGetBridgeTransactionResponse.Fields().ByName("bridgeTransactions")
+	md_QueryAllPartialUpgradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllPartialUpgradeResponse")
+	fd_QueryAllPartialUpgradeResponse_partialUpgrade = md_QueryAllPartialUpgradeResponse.Fields().ByName("partialUpgrade")
+	fd_QueryAllPartialUpgradeResponse_pagination = md_QueryAllPartialUpgradeResponse.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetBridgeTransactionResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllPartialUpgradeResponse)(nil)
 
-type fastReflection_QueryGetBridgeTransactionResponse QueryGetBridgeTransactionResponse
+type fastReflection_QueryAllPartialUpgradeResponse QueryAllPartialUpgradeResponse
 
-func (x *QueryGetBridgeTransactionResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetBridgeTransactionResponse)(x)
+func (x *QueryAllPartialUpgradeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllPartialUpgradeResponse)(x)
 }
 
-func (x *QueryGetBridgeTransactionResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllPartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[106]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -51706,43 +51442,43 @@ func (x *QueryGetBridgeTransactionResponse) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetBridgeTransactionResponse_messageType fastReflection_QueryGetBridgeTransactionResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetBridgeTransactionResponse_messageType{}
+var _fastReflection_QueryAllPartialUpgradeResponse_messageType fastReflection_QueryAllPartialUpgradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllPartialUpgradeResponse_messageType{}
 
-type fastReflection_QueryGetBridgeTransactionResponse_messageType struct{}
+type fastReflection_QueryAllPartialUpgradeResponse_messageType struct{}
 
-func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetBridgeTransactionResponse)(nil)
+func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllPartialUpgradeResponse)(nil)
 }
-func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetBridgeTransactionResponse)
+func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPartialUpgradeResponse)
 }
-func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetBridgeTransactionResponse
+func (x fastReflection_QueryAllPartialUpgradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPartialUpgradeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetBridgeTransactionResponse
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllPartialUpgradeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetBridgeTransactionResponse_messageType
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllPartialUpgradeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetBridgeTransactionResponse)
+func (x *fastReflection_QueryAllPartialUpgradeResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllPartialUpgradeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetBridgeTransactionResponse)(x)
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllPartialUpgradeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -51750,10 +51486,16 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.BridgeTransactions) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions})
-		if !f(fd_QueryGetBridgeTransactionResponse_bridgeTransactions, value) {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.PartialUpgrade) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllPartialUpgradeResponse_1_list{list: &x.PartialUpgrade})
+		if !f(fd_QueryAllPartialUpgradeResponse_partialUpgrade, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllPartialUpgradeResponse_pagination, value) {
 			return
 		}
 	}
@@ -51770,15 +51512,17 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
-		return len(x.BridgeTransactions) != 0
+	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+		return len(x.PartialUpgrade) != 0
+	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -51788,15 +51532,17 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
-		x.BridgeTransactions = nil
+	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+		x.PartialUpgrade = nil
+	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -51806,19 +51552,22 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
-		if len(x.BridgeTransactions) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{})
+	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+		if len(x.PartialUpgrade) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllPartialUpgradeResponse_1_list{})
 		}
-		listValue := &_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions}
+		listValue := &_QueryAllPartialUpgradeResponse_1_list{list: &x.PartialUpgrade}
 		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -51832,17 +51581,19 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
+	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
 		lv := value.List()
-		clv := lv.(*_QueryGetBridgeTransactionResponse_1_list)
-		x.BridgeTransactions = *clv.list
+		clv := lv.(*_QueryAllPartialUpgradeResponse_1_list)
+		x.PartialUpgrade = *clv.list
+	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -51856,45 +51607,53 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
-		if x.BridgeTransactions == nil {
-			x.BridgeTransactions = []*BridgeTransaction{}
+	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+		if x.PartialUpgrade == nil {
+			x.PartialUpgrade = []*PartialUpgrade{}
 		}
-		value := &_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions}
+		value := &_QueryAllPartialUpgradeResponse_1_list{list: &x.PartialUpgrade}
 		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
-		list := []*BridgeTransaction{}
-		return protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{list: &list})
+	case "inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade":
+		list := []*PartialUpgrade{}
+		return protoreflect.ValueOfList(&_QueryAllPartialUpgradeResponse_1_list{list: &list})
+	case "inference.inference.QueryAllPartialUpgradeResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllPartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllPartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetBridgeTransactionResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllPartialUpgradeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -51902,7 +51661,7 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -51913,7 +51672,7 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -51925,7 +51684,7 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) IsValid() bool {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -51935,9 +51694,9 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllPartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
+		x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -51949,12 +51708,16 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if len(x.BridgeTransactions) > 0 {
-			for _, e := range x.BridgeTransactions {
+		if len(x.PartialUpgrade) > 0 {
+			for _, e := range x.PartialUpgrade {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
 		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -51965,7 +51728,7 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
+		x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -51984,9 +51747,23 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.BridgeTransactions) > 0 {
-			for iNdEx := len(x.BridgeTransactions) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.BridgeTransactions[iNdEx])
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.PartialUpgrade) > 0 {
+			for iNdEx := len(x.PartialUpgrade) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.PartialUpgrade[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52011,7 +51788,7 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
+		x := input.Message.Interface().(*QueryAllPartialUpgradeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52043,15 +51820,15 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BridgeTransactions", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PartialUpgrade", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -52078,8 +51855,44 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.BridgeTransactions = append(x.BridgeTransactions, &BridgeTransaction{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.BridgeTransactions[len(x.BridgeTransactions)-1]); err != nil {
+				x.PartialUpgrade = append(x.PartialUpgrade, &PartialUpgrade{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.PartialUpgrade[len(x.PartialUpgrade)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -52119,25 +51932,29 @@ func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *proto
 }
 
 var (
-	md_QueryAllBridgeTransactionsRequest            protoreflect.MessageDescriptor
-	fd_QueryAllBridgeTransactionsRequest_pagination protoreflect.FieldDescriptor
+	md_QueryGetBridgeTransactionRequest               protoreflect.MessageDescriptor
+	fd_QueryGetBridgeTransactionRequest_origin_chain  protoreflect.FieldDescriptor
+	fd_QueryGetBridgeTransactionRequest_block_number  protoreflect.FieldDescriptor
+	fd_QueryGetBridgeTransactionRequest_receipt_index protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllBridgeTransactionsRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllBridgeTransactionsRequest")
-	fd_QueryAllBridgeTransactionsRequest_pagination = md_QueryAllBridgeTransactionsRequest.Fields().ByName("pagination")
+	md_QueryGetBridgeTransactionRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetBridgeTransactionRequest")
+	fd_QueryGetBridgeTransactionRequest_origin_chain = md_QueryGetBridgeTransactionRequest.Fields().ByName("origin_chain")
+	fd_QueryGetBridgeTransactionRequest_block_number = md_QueryGetBridgeTransactionRequest.Fields().ByName("block_number")
+	fd_QueryGetBridgeTransactionRequest_receipt_index = md_QueryGetBridgeTransactionRequest.Fields().ByName("receipt_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllBridgeTransactionsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetBridgeTransactionRequest)(nil)
 
-type fastReflection_QueryAllBridgeTransactionsRequest QueryAllBridgeTransactionsRequest
+type fastReflection_QueryGetBridgeTransactionRequest QueryGetBridgeTransactionRequest
 
-func (x *QueryAllBridgeTransactionsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllBridgeTransactionsRequest)(x)
+func (x *QueryGetBridgeTransactionRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetBridgeTransactionRequest)(x)
 }
 
-func (x *QueryAllBridgeTransactionsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetBridgeTransactionRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[107]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -52149,43 +51966,43 @@ func (x *QueryAllBridgeTransactionsRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllBridgeTransactionsRequest_messageType fastReflection_QueryAllBridgeTransactionsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllBridgeTransactionsRequest_messageType{}
+var _fastReflection_QueryGetBridgeTransactionRequest_messageType fastReflection_QueryGetBridgeTransactionRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetBridgeTransactionRequest_messageType{}
 
-type fastReflection_QueryAllBridgeTransactionsRequest_messageType struct{}
+type fastReflection_QueryGetBridgeTransactionRequest_messageType struct{}
 
-func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllBridgeTransactionsRequest)(nil)
+func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetBridgeTransactionRequest)(nil)
 }
-func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllBridgeTransactionsRequest)
+func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetBridgeTransactionRequest)
 }
-func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllBridgeTransactionsRequest
+func (x fastReflection_QueryGetBridgeTransactionRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetBridgeTransactionRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllBridgeTransactionsRequest
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetBridgeTransactionRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllBridgeTransactionsRequest_messageType
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetBridgeTransactionRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryAllBridgeTransactionsRequest)
+func (x *fastReflection_QueryGetBridgeTransactionRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetBridgeTransactionRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllBridgeTransactionsRequest)(x)
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetBridgeTransactionRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -52193,10 +52010,22 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllBridgeTransactionsRequest_pagination, value) {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.OriginChain != "" {
+		value := protoreflect.ValueOfString(x.OriginChain)
+		if !f(fd_QueryGetBridgeTransactionRequest_origin_chain, value) {
+			return
+		}
+	}
+	if x.BlockNumber != "" {
+		value := protoreflect.ValueOfString(x.BlockNumber)
+		if !f(fd_QueryGetBridgeTransactionRequest_block_number, value) {
+			return
+		}
+	}
+	if x.ReceiptIndex != "" {
+		value := protoreflect.ValueOfString(x.ReceiptIndex)
+		if !f(fd_QueryGetBridgeTransactionRequest_receipt_index, value) {
 			return
 		}
 	}
@@ -52213,15 +52042,19 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
+		return x.OriginChain != ""
+	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
+		return x.BlockNumber != ""
+	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
+		return x.ReceiptIndex != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -52231,15 +52064,19 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
+		x.OriginChain = ""
+	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
+		x.BlockNumber = ""
+	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
+		x.ReceiptIndex = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -52249,16 +52086,22 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
+		value := x.OriginChain
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
+		value := x.BlockNumber
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
+		value := x.ReceiptIndex
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -52272,15 +52115,19 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
+		x.OriginChain = value.Interface().(string)
+	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
+		x.BlockNumber = value.Interface().(string)
+	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
+		x.ReceiptIndex = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -52294,44 +52141,48 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
+		panic(fmt.Errorf("field origin_chain of message inference.inference.QueryGetBridgeTransactionRequest is not mutable"))
+	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
+		panic(fmt.Errorf("field block_number of message inference.inference.QueryGetBridgeTransactionRequest is not mutable"))
+	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
+		panic(fmt.Errorf("field receipt_index of message inference.inference.QueryGetBridgeTransactionRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
-		m := new(v1beta1.PageRequest)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetBridgeTransactionRequest.origin_chain":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryGetBridgeTransactionRequest.block_number":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryGetBridgeTransactionRequest.receipt_index":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllBridgeTransactionsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetBridgeTransactionRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -52339,7 +52190,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -52350,7 +52201,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -52362,7 +52213,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) IsValid() bool {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -52372,9 +52223,9 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetBridgeTransactionRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
+		x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52386,8 +52237,16 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		l = len(x.OriginChain)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.BlockNumber)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ReceiptIndex)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -52400,7 +52259,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
+		x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52419,17 +52278,24 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if len(x.ReceiptIndex) > 0 {
+			i -= len(x.ReceiptIndex)
+			copy(dAtA[i:], x.ReceiptIndex)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptIndex)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.BlockNumber) > 0 {
+			i -= len(x.BlockNumber)
+			copy(dAtA[i:], x.BlockNumber)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlockNumber)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.OriginChain) > 0 {
+			i -= len(x.OriginChain)
+			copy(dAtA[i:], x.OriginChain)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OriginChain)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -52444,7 +52310,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
+		x := input.Message.Interface().(*QueryGetBridgeTransactionRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52476,17 +52342,17 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OriginChain", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -52496,27 +52362,87 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
+				x.OriginChain = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.BlockNumber = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptIndex", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ReceiptIndex = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -52553,79 +52479,77 @@ func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *proto
 	}
 }
 
-var _ protoreflect.List = (*_QueryAllBridgeTransactionsResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryGetBridgeTransactionResponse_1_list)(nil)
 
-type _QueryAllBridgeTransactionsResponse_1_list struct {
+type _QueryGetBridgeTransactionResponse_1_list struct {
 	list *[]*BridgeTransaction
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) Len() int {
+func (x *_QueryGetBridgeTransactionResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryGetBridgeTransactionResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryGetBridgeTransactionResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
 	concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryGetBridgeTransactionResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
 	concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) AppendMutable() protoreflect.Value {
+func (x *_QueryGetBridgeTransactionResponse_1_list) AppendMutable() protoreflect.Value {
 	v := new(BridgeTransaction)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) Truncate(n int) {
+func (x *_QueryGetBridgeTransactionResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) NewElement() protoreflect.Value {
+func (x *_QueryGetBridgeTransactionResponse_1_list) NewElement() protoreflect.Value {
 	v := new(BridgeTransaction)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryAllBridgeTransactionsResponse_1_list) IsValid() bool {
+func (x *_QueryGetBridgeTransactionResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryAllBridgeTransactionsResponse                    protoreflect.MessageDescriptor
-	fd_QueryAllBridgeTransactionsResponse_bridgeTransactions protoreflect.FieldDescriptor
-	fd_QueryAllBridgeTransactionsResponse_pagination         protoreflect.FieldDescriptor
+	md_QueryGetBridgeTransactionResponse                    protoreflect.MessageDescriptor
+	fd_QueryGetBridgeTransactionResponse_bridgeTransactions protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryAllBridgeTransactionsResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllBridgeTransactionsResponse")
-	fd_QueryAllBridgeTransactionsResponse_bridgeTransactions = md_QueryAllBridgeTransactionsResponse.Fields().ByName("bridgeTransactions")
-	fd_QueryAllBridgeTransactionsResponse_pagination = md_QueryAllBridgeTransactionsResponse.Fields().ByName("pagination")
+	md_QueryGetBridgeTransactionResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetBridgeTransactionResponse")
+	fd_QueryGetBridgeTransactionResponse_bridgeTransactions = md_QueryGetBridgeTransactionResponse.Fields().ByName("bridgeTransactions")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryAllBridgeTransactionsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetBridgeTransactionResponse)(nil)
 
-type fastReflection_QueryAllBridgeTransactionsResponse QueryAllBridgeTransactionsResponse
+type fastReflection_QueryGetBridgeTransactionResponse QueryGetBridgeTransactionResponse
 
-func (x *QueryAllBridgeTransactionsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryAllBridgeTransactionsResponse)(x)
+func (x *QueryGetBridgeTransactionResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetBridgeTransactionResponse)(x)
 }
 
-func (x *QueryAllBridgeTransactionsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetBridgeTransactionResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[108]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -52637,43 +52561,43 @@ func (x *QueryAllBridgeTransactionsResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryAllBridgeTransactionsResponse_messageType fastReflection_QueryAllBridgeTransactionsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryAllBridgeTransactionsResponse_messageType{}
+var _fastReflection_QueryGetBridgeTransactionResponse_messageType fastReflection_QueryGetBridgeTransactionResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetBridgeTransactionResponse_messageType{}
 
-type fastReflection_QueryAllBridgeTransactionsResponse_messageType struct{}
+type fastReflection_QueryGetBridgeTransactionResponse_messageType struct{}
 
-func (x fastReflection_QueryAllBridgeTransactionsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryAllBridgeTransactionsResponse)(nil)
+func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetBridgeTransactionResponse)(nil)
 }
-func (x fastReflection_QueryAllBridgeTransactionsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryAllBridgeTransactionsResponse)
+func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetBridgeTransactionResponse)
 }
-func (x fastReflection_QueryAllBridgeTransactionsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllBridgeTransactionsResponse
+func (x fastReflection_QueryGetBridgeTransactionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetBridgeTransactionResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryAllBridgeTransactionsResponse
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetBridgeTransactionResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryAllBridgeTransactionsResponse_messageType
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetBridgeTransactionResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryAllBridgeTransactionsResponse)
+func (x *fastReflection_QueryGetBridgeTransactionResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetBridgeTransactionResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryAllBridgeTransactionsResponse)(x)
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetBridgeTransactionResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -52681,16 +52605,10 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if len(x.BridgeTransactions) != 0 {
-		value := protoreflect.ValueOfList(&_QueryAllBridgeTransactionsResponse_1_list{list: &x.BridgeTransactions})
-		if !f(fd_QueryAllBridgeTransactionsResponse_bridgeTransactions, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryAllBridgeTransactionsResponse_pagination, value) {
+		value := protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions})
+		if !f(fd_QueryGetBridgeTransactionResponse_bridgeTransactions, value) {
 			return
 		}
 	}
@@ -52707,17 +52625,15 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
 		return len(x.BridgeTransactions) != 0
-	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
-		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -52727,17 +52643,15 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
 		x.BridgeTransactions = nil
-	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
-		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -52747,22 +52661,19 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
 		if len(x.BridgeTransactions) == 0 {
-			return protoreflect.ValueOfList(&_QueryAllBridgeTransactionsResponse_1_list{})
+			return protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{})
 		}
-		listValue := &_QueryAllBridgeTransactionsResponse_1_list{list: &x.BridgeTransactions}
+		listValue := &_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions}
 		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -52776,19 +52687,17 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
 		lv := value.List()
-		clv := lv.(*_QueryAllBridgeTransactionsResponse_1_list)
+		clv := lv.(*_QueryGetBridgeTransactionResponse_1_list)
 		x.BridgeTransactions = *clv.list
-	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -52802,53 +52711,45 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
 		if x.BridgeTransactions == nil {
 			x.BridgeTransactions = []*BridgeTransaction{}
 		}
-		value := &_QueryAllBridgeTransactionsResponse_1_list{list: &x.BridgeTransactions}
+		value := &_QueryGetBridgeTransactionResponse_1_list{list: &x.BridgeTransactions}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+	case "inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions":
 		list := []*BridgeTransaction{}
-		return protoreflect.ValueOfList(&_QueryAllBridgeTransactionsResponse_1_list{list: &list})
-	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
-		m := new(v1beta1.PageResponse)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+		return protoreflect.ValueOfList(&_QueryGetBridgeTransactionResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetBridgeTransactionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetBridgeTransactionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllBridgeTransactionsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetBridgeTransactionResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -52856,7 +52757,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -52867,7 +52768,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -52879,7 +52780,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) IsValid() bool {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -52889,9 +52790,9 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetBridgeTransactionResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
+		x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52909,10 +52810,6 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
 		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -52923,7 +52820,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
+		x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -52942,20 +52839,6 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0x12
-		}
 		if len(x.BridgeTransactions) > 0 {
 			for iNdEx := len(x.BridgeTransactions) - 1; iNdEx >= 0; iNdEx-- {
 				encoded, err := options.Marshal(x.BridgeTransactions[iNdEx])
@@ -52983,7 +52866,7 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
+		x := input.Message.Interface().(*QueryGetBridgeTransactionResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -53015,10 +52898,10 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetBridgeTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -53055,42 +52938,6 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -53127,33 +52974,25 @@ func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *prot
 }
 
 var (
-	md_WrappedTokenBalance                   protoreflect.MessageDescriptor
-	fd_WrappedTokenBalance_token_info        protoreflect.FieldDescriptor
-	fd_WrappedTokenBalance_symbol            protoreflect.FieldDescriptor
-	fd_WrappedTokenBalance_balance           protoreflect.FieldDescriptor
-	fd_WrappedTokenBalance_decimals          protoreflect.FieldDescriptor
-	fd_WrappedTokenBalance_formatted_balance protoreflect.FieldDescriptor
+	md_QueryAllBridgeTransactionsRequest            protoreflect.MessageDescriptor
+	fd_QueryAllBridgeTransactionsRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_WrappedTokenBalance = File_inference_inference_query_proto.Messages().ByName("WrappedTokenBalance")
-	fd_WrappedTokenBalance_token_info = md_WrappedTokenBalance.Fields().ByName("token_info")
-	fd_WrappedTokenBalance_symbol = md_WrappedTokenBalance.Fields().ByName("symbol")
-	fd_WrappedTokenBalance_balance = md_WrappedTokenBalance.Fields().ByName("balance")
-	fd_WrappedTokenBalance_decimals = md_WrappedTokenBalance.Fields().ByName("decimals")
-	fd_WrappedTokenBalance_formatted_balance = md_WrappedTokenBalance.Fields().ByName("formatted_balance")
+	md_QueryAllBridgeTransactionsRequest = File_inference_inference_query_proto.Messages().ByName("QueryAllBridgeTransactionsRequest")
+	fd_QueryAllBridgeTransactionsRequest_pagination = md_QueryAllBridgeTransactionsRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_WrappedTokenBalance)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryAllBridgeTransactionsRequest)(nil)
 
-type fastReflection_WrappedTokenBalance WrappedTokenBalance
+type fastReflection_QueryAllBridgeTransactionsRequest QueryAllBridgeTransactionsRequest
 
-func (x *WrappedTokenBalance) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_WrappedTokenBalance)(x)
+func (x *QueryAllBridgeTransactionsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllBridgeTransactionsRequest)(x)
 }
 
-func (x *WrappedTokenBalance) slowProtoReflect() protoreflect.Message {
+func (x *QueryAllBridgeTransactionsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[109]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -53165,43 +53004,43 @@ func (x *WrappedTokenBalance) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_WrappedTokenBalance_messageType fastReflection_WrappedTokenBalance_messageType
-var _ protoreflect.MessageType = fastReflection_WrappedTokenBalance_messageType{}
+var _fastReflection_QueryAllBridgeTransactionsRequest_messageType fastReflection_QueryAllBridgeTransactionsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllBridgeTransactionsRequest_messageType{}
 
-type fastReflection_WrappedTokenBalance_messageType struct{}
+type fastReflection_QueryAllBridgeTransactionsRequest_messageType struct{}
 
-func (x fastReflection_WrappedTokenBalance_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_WrappedTokenBalance)(nil)
+func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllBridgeTransactionsRequest)(nil)
 }
-func (x fastReflection_WrappedTokenBalance_messageType) New() protoreflect.Message {
-	return new(fastReflection_WrappedTokenBalance)
+func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllBridgeTransactionsRequest)
 }
-func (x fastReflection_WrappedTokenBalance_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_WrappedTokenBalance
+func (x fastReflection_QueryAllBridgeTransactionsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllBridgeTransactionsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_WrappedTokenBalance) Descriptor() protoreflect.MessageDescriptor {
-	return md_WrappedTokenBalance
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllBridgeTransactionsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_WrappedTokenBalance) Type() protoreflect.MessageType {
-	return _fastReflection_WrappedTokenBalance_messageType
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllBridgeTransactionsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_WrappedTokenBalance) New() protoreflect.Message {
-	return new(fastReflection_WrappedTokenBalance)
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryAllBridgeTransactionsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_WrappedTokenBalance) Interface() protoreflect.ProtoMessage {
-	return (*WrappedTokenBalance)(x)
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllBridgeTransactionsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -53209,34 +53048,10 @@ func (x *fastReflection_WrappedTokenBalance) Interface() protoreflect.ProtoMessa
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_WrappedTokenBalance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.TokenInfo != nil {
-		value := protoreflect.ValueOfMessage(x.TokenInfo.ProtoReflect())
-		if !f(fd_WrappedTokenBalance_token_info, value) {
-			return
-		}
-	}
-	if x.Symbol != "" {
-		value := protoreflect.ValueOfString(x.Symbol)
-		if !f(fd_WrappedTokenBalance_symbol, value) {
-			return
-		}
-	}
-	if x.Balance != "" {
-		value := protoreflect.ValueOfString(x.Balance)
-		if !f(fd_WrappedTokenBalance_balance, value) {
-			return
-		}
-	}
-	if x.Decimals != "" {
-		value := protoreflect.ValueOfString(x.Decimals)
-		if !f(fd_WrappedTokenBalance_decimals, value) {
-			return
-		}
-	}
-	if x.FormattedBalance != "" {
-		value := protoreflect.ValueOfString(x.FormattedBalance)
-		if !f(fd_WrappedTokenBalance_formatted_balance, value) {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllBridgeTransactionsRequest_pagination, value) {
 			return
 		}
 	}
@@ -53253,23 +53068,15 @@ func (x *fastReflection_WrappedTokenBalance) Range(f func(protoreflect.FieldDesc
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_WrappedTokenBalance) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.WrappedTokenBalance.token_info":
-		return x.TokenInfo != nil
-	case "inference.inference.WrappedTokenBalance.symbol":
-		return x.Symbol != ""
-	case "inference.inference.WrappedTokenBalance.balance":
-		return x.Balance != ""
-	case "inference.inference.WrappedTokenBalance.decimals":
-		return x.Decimals != ""
-	case "inference.inference.WrappedTokenBalance.formatted_balance":
-		return x.FormattedBalance != ""
+	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -53279,23 +53086,15 @@ func (x *fastReflection_WrappedTokenBalance) Has(fd protoreflect.FieldDescriptor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_WrappedTokenBalance) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.WrappedTokenBalance.token_info":
-		x.TokenInfo = nil
-	case "inference.inference.WrappedTokenBalance.symbol":
-		x.Symbol = ""
-	case "inference.inference.WrappedTokenBalance.balance":
-		x.Balance = ""
-	case "inference.inference.WrappedTokenBalance.decimals":
-		x.Decimals = ""
-	case "inference.inference.WrappedTokenBalance.formatted_balance":
-		x.FormattedBalance = ""
+	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -53305,28 +53104,16 @@ func (x *fastReflection_WrappedTokenBalance) Clear(fd protoreflect.FieldDescript
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_WrappedTokenBalance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.WrappedTokenBalance.token_info":
-		value := x.TokenInfo
+	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+		value := x.Pagination
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.WrappedTokenBalance.symbol":
-		value := x.Symbol
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.WrappedTokenBalance.balance":
-		value := x.Balance
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.WrappedTokenBalance.decimals":
-		value := x.Decimals
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.WrappedTokenBalance.formatted_balance":
-		value := x.FormattedBalance
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -53340,23 +53127,15 @@ func (x *fastReflection_WrappedTokenBalance) Get(descriptor protoreflect.FieldDe
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_WrappedTokenBalance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.WrappedTokenBalance.token_info":
-		x.TokenInfo = value.Message().Interface().(*BridgeWrappedTokenContract)
-	case "inference.inference.WrappedTokenBalance.symbol":
-		x.Symbol = value.Interface().(string)
-	case "inference.inference.WrappedTokenBalance.balance":
-		x.Balance = value.Interface().(string)
-	case "inference.inference.WrappedTokenBalance.decimals":
-		x.Decimals = value.Interface().(string)
-	case "inference.inference.WrappedTokenBalance.formatted_balance":
-		x.FormattedBalance = value.Interface().(string)
+	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -53370,60 +53149,44 @@ func (x *fastReflection_WrappedTokenBalance) Set(fd protoreflect.FieldDescriptor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_WrappedTokenBalance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.WrappedTokenBalance.token_info":
-		if x.TokenInfo == nil {
-			x.TokenInfo = new(BridgeWrappedTokenContract)
+	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
 		}
-		return protoreflect.ValueOfMessage(x.TokenInfo.ProtoReflect())
-	case "inference.inference.WrappedTokenBalance.symbol":
-		panic(fmt.Errorf("field symbol of message inference.inference.WrappedTokenBalance is not mutable"))
-	case "inference.inference.WrappedTokenBalance.balance":
-		panic(fmt.Errorf("field balance of message inference.inference.WrappedTokenBalance is not mutable"))
-	case "inference.inference.WrappedTokenBalance.decimals":
-		panic(fmt.Errorf("field decimals of message inference.inference.WrappedTokenBalance is not mutable"))
-	case "inference.inference.WrappedTokenBalance.formatted_balance":
-		panic(fmt.Errorf("field formatted_balance of message inference.inference.WrappedTokenBalance is not mutable"))
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_WrappedTokenBalance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.WrappedTokenBalance.token_info":
-		m := new(BridgeWrappedTokenContract)
+	case "inference.inference.QueryAllBridgeTransactionsRequest.pagination":
+		m := new(v1beta1.PageRequest)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.WrappedTokenBalance.symbol":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.WrappedTokenBalance.balance":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.WrappedTokenBalance.decimals":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.WrappedTokenBalance.formatted_balance":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_WrappedTokenBalance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.WrappedTokenBalance", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllBridgeTransactionsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -53431,7 +53194,7 @@ func (x *fastReflection_WrappedTokenBalance) WhichOneof(d protoreflect.OneofDesc
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_WrappedTokenBalance) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -53442,7 +53205,7 @@ func (x *fastReflection_WrappedTokenBalance) GetUnknown() protoreflect.RawFields
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_WrappedTokenBalance) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -53454,7 +53217,7 @@ func (x *fastReflection_WrappedTokenBalance) SetUnknown(fields protoreflect.RawF
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_WrappedTokenBalance) IsValid() bool {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -53464,9 +53227,9 @@ func (x *fastReflection_WrappedTokenBalance) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllBridgeTransactionsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*WrappedTokenBalance)
+		x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -53478,24 +53241,8 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 		var n int
 		var l int
 		_ = l
-		if x.TokenInfo != nil {
-			l = options.Size(x.TokenInfo)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.Symbol)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.Balance)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.Decimals)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.FormattedBalance)
-		if l > 0 {
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -53508,7 +53255,7 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*WrappedTokenBalance)
+		x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -53527,36 +53274,8 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.FormattedBalance) > 0 {
-			i -= len(x.FormattedBalance)
-			copy(dAtA[i:], x.FormattedBalance)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.FormattedBalance)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.Decimals) > 0 {
-			i -= len(x.Decimals)
-			copy(dAtA[i:], x.Decimals)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Decimals)))
-			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.Balance) > 0 {
-			i -= len(x.Balance)
-			copy(dAtA[i:], x.Balance)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Balance)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.Symbol) > 0 {
-			i -= len(x.Symbol)
-			copy(dAtA[i:], x.Symbol)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Symbol)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if x.TokenInfo != nil {
-			encoded, err := options.Marshal(x.TokenInfo)
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -53580,7 +53299,7 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*WrappedTokenBalance)
+		x := input.Message.Interface().(*QueryAllBridgeTransactionsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -53612,15 +53331,15 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: WrappedTokenBalance: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: WrappedTokenBalance: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TokenInfo", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -53647,141 +53366,13 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.TokenInfo == nil {
-					x.TokenInfo = &BridgeWrappedTokenContract{}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenInfo); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Symbol = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Balance = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Decimals = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FormattedBalance", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.FormattedBalance = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -53817,74 +53408,127 @@ func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods
 	}
 }
 
-var (
-	md_QueryWrappedTokenBalancesRequest         protoreflect.MessageDescriptor
-	fd_QueryWrappedTokenBalancesRequest_address protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_QueryAllBridgeTransactionsResponse_1_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryWrappedTokenBalancesRequest = File_inference_inference_query_proto.Messages().ByName("QueryWrappedTokenBalancesRequest")
-	fd_QueryWrappedTokenBalancesRequest_address = md_QueryWrappedTokenBalancesRequest.Fields().ByName("address")
+type _QueryAllBridgeTransactionsResponse_1_list struct {
+	list *[]*BridgeTransaction
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryWrappedTokenBalancesRequest)(nil)
-
-type fastReflection_QueryWrappedTokenBalancesRequest QueryWrappedTokenBalancesRequest
-
-func (x *QueryWrappedTokenBalancesRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryWrappedTokenBalancesRequest)(x)
+func (x *_QueryAllBridgeTransactionsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
 }
 
-func (x *QueryWrappedTokenBalancesRequest) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[110]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
+func (x *_QueryAllBridgeTransactionsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-var _fastReflection_QueryWrappedTokenBalancesRequest_messageType fastReflection_QueryWrappedTokenBalancesRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryWrappedTokenBalancesRequest_messageType{}
+func (x *_QueryAllBridgeTransactionsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+	(*x.list)[i] = concreteValue
+}
 
-type fastReflection_QueryWrappedTokenBalancesRequest_messageType struct{}
+func (x *_QueryAllBridgeTransactionsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*BridgeTransaction)
+	*x.list = append(*x.list, concreteValue)
+}
 
-func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryWrappedTokenBalancesRequest)(nil)
+func (x *_QueryAllBridgeTransactionsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(BridgeTransaction)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
-func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryWrappedTokenBalancesRequest)
+
+func (x *_QueryAllBridgeTransactionsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
 }
-func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryWrappedTokenBalancesRequest
+
+func (x *_QueryAllBridgeTransactionsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(BridgeTransaction)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryAllBridgeTransactionsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryAllBridgeTransactionsResponse                    protoreflect.MessageDescriptor
+	fd_QueryAllBridgeTransactionsResponse_bridgeTransactions protoreflect.FieldDescriptor
+	fd_QueryAllBridgeTransactionsResponse_pagination         protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryAllBridgeTransactionsResponse = File_inference_inference_query_proto.Messages().ByName("QueryAllBridgeTransactionsResponse")
+	fd_QueryAllBridgeTransactionsResponse_bridgeTransactions = md_QueryAllBridgeTransactionsResponse.Fields().ByName("bridgeTransactions")
+	fd_QueryAllBridgeTransactionsResponse_pagination = md_QueryAllBridgeTransactionsResponse.Fields().ByName("pagination")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryAllBridgeTransactionsResponse)(nil)
+
+type fastReflection_QueryAllBridgeTransactionsResponse QueryAllBridgeTransactionsResponse
+
+func (x *QueryAllBridgeTransactionsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryAllBridgeTransactionsResponse)(x)
+}
+
+func (x *QueryAllBridgeTransactionsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[110]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryAllBridgeTransactionsResponse_messageType fastReflection_QueryAllBridgeTransactionsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryAllBridgeTransactionsResponse_messageType{}
+
+type fastReflection_QueryAllBridgeTransactionsResponse_messageType struct{}
+
+func (x fastReflection_QueryAllBridgeTransactionsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryAllBridgeTransactionsResponse)(nil)
+}
+func (x fastReflection_QueryAllBridgeTransactionsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryAllBridgeTransactionsResponse)
+}
+func (x fastReflection_QueryAllBridgeTransactionsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllBridgeTransactionsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryWrappedTokenBalancesRequest
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryAllBridgeTransactionsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryWrappedTokenBalancesRequest_messageType
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryAllBridgeTransactionsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryWrappedTokenBalancesRequest)
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryAllBridgeTransactionsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryWrappedTokenBalancesRequest)(x)
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryAllBridgeTransactionsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -53892,10 +53536,16 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Address != "" {
-		value := protoreflect.ValueOfString(x.Address)
-		if !f(fd_QueryWrappedTokenBalancesRequest_address, value) {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.BridgeTransactions) != 0 {
+		value := protoreflect.ValueOfList(&_QueryAllBridgeTransactionsResponse_1_list{list: &x.BridgeTransactions})
+		if !f(fd_QueryAllBridgeTransactionsResponse_bridgeTransactions, value) {
+			return
+		}
+	}
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryAllBridgeTransactionsResponse_pagination, value) {
 			return
 		}
 	}
@@ -53912,15 +53562,17 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
-		return x.Address != ""
+	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+		return len(x.BridgeTransactions) != 0
+	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -53930,15 +53582,17 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
-		x.Address = ""
+	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+		x.BridgeTransactions = nil
+	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -53948,16 +53602,22 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
-		value := x.Address
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+		if len(x.BridgeTransactions) == 0 {
+			return protoreflect.ValueOfList(&_QueryAllBridgeTransactionsResponse_1_list{})
+		}
+		listValue := &_QueryAllBridgeTransactionsResponse_1_list{list: &x.BridgeTransactions}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -53971,15 +53631,19 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
-		x.Address = value.Interface().(string)
+	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+		lv := value.List()
+		clv := lv.(*_QueryAllBridgeTransactionsResponse_1_list)
+		x.BridgeTransactions = *clv.list
+	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -53993,40 +53657,53 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
-		panic(fmt.Errorf("field address of message inference.inference.QueryWrappedTokenBalancesRequest is not mutable"))
+	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+		if x.BridgeTransactions == nil {
+			x.BridgeTransactions = []*BridgeTransaction{}
+		}
+		value := &_QueryAllBridgeTransactionsResponse_1_list{list: &x.BridgeTransactions}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions":
+		list := []*BridgeTransaction{}
+		return protoreflect.ValueOfList(&_QueryAllBridgeTransactionsResponse_1_list{list: &list})
+	case "inference.inference.QueryAllBridgeTransactionsResponse.pagination":
+		m := new(v1beta1.PageResponse)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryAllBridgeTransactionsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryAllBridgeTransactionsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryWrappedTokenBalancesRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryAllBridgeTransactionsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -54034,7 +53711,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -54045,7 +53722,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -54057,7 +53734,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) IsValid() bool {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -54067,9 +53744,9 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryAllBridgeTransactionsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
+		x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54081,8 +53758,14 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
-		l = len(x.Address)
-		if l > 0 {
+		if len(x.BridgeTransactions) > 0 {
+			for _, e := range x.BridgeTransactions {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -54095,7 +53778,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
+		x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54114,12 +53797,35 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Address) > 0 {
-			i -= len(x.Address)
-			copy(dAtA[i:], x.Address)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if len(x.BridgeTransactions) > 0 {
+			for iNdEx := len(x.BridgeTransactions) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.BridgeTransactions[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -54132,7 +53838,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
+		x := input.Message.Interface().(*QueryAllBridgeTransactionsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54164,17 +53870,17 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BridgeTransactions", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -54184,23 +53890,61 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Address = string(dAtA[iNdEx:postIndex])
+				x.BridgeTransactions = append(x.BridgeTransactions, &BridgeTransaction{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.BridgeTransactions[len(x.BridgeTransactions)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -54237,77 +53981,34 @@ func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoi
 	}
 }
 
-var _ protoreflect.List = (*_QueryWrappedTokenBalancesResponse_1_list)(nil)
-
-type _QueryWrappedTokenBalancesResponse_1_list struct {
-	list *[]*WrappedTokenBalance
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*WrappedTokenBalance)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*WrappedTokenBalance)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(WrappedTokenBalance)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) NewElement() protoreflect.Value {
-	v := new(WrappedTokenBalance)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryWrappedTokenBalancesResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryWrappedTokenBalancesResponse          protoreflect.MessageDescriptor
-	fd_QueryWrappedTokenBalancesResponse_balances protoreflect.FieldDescriptor
+	md_WrappedTokenBalance                   protoreflect.MessageDescriptor
+	fd_WrappedTokenBalance_token_info        protoreflect.FieldDescriptor
+	fd_WrappedTokenBalance_symbol            protoreflect.FieldDescriptor
+	fd_WrappedTokenBalance_balance           protoreflect.FieldDescriptor
+	fd_WrappedTokenBalance_decimals          protoreflect.FieldDescriptor
+	fd_WrappedTokenBalance_formatted_balance protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryWrappedTokenBalancesResponse = File_inference_inference_query_proto.Messages().ByName("QueryWrappedTokenBalancesResponse")
-	fd_QueryWrappedTokenBalancesResponse_balances = md_QueryWrappedTokenBalancesResponse.Fields().ByName("balances")
+	md_WrappedTokenBalance = File_inference_inference_query_proto.Messages().ByName("WrappedTokenBalance")
+	fd_WrappedTokenBalance_token_info = md_WrappedTokenBalance.Fields().ByName("token_info")
+	fd_WrappedTokenBalance_symbol = md_WrappedTokenBalance.Fields().ByName("symbol")
+	fd_WrappedTokenBalance_balance = md_WrappedTokenBalance.Fields().ByName("balance")
+	fd_WrappedTokenBalance_decimals = md_WrappedTokenBalance.Fields().ByName("decimals")
+	fd_WrappedTokenBalance_formatted_balance = md_WrappedTokenBalance.Fields().ByName("formatted_balance")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryWrappedTokenBalancesResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_WrappedTokenBalance)(nil)
 
-type fastReflection_QueryWrappedTokenBalancesResponse QueryWrappedTokenBalancesResponse
+type fastReflection_WrappedTokenBalance WrappedTokenBalance
 
-func (x *QueryWrappedTokenBalancesResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryWrappedTokenBalancesResponse)(x)
+func (x *WrappedTokenBalance) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_WrappedTokenBalance)(x)
 }
 
-func (x *QueryWrappedTokenBalancesResponse) slowProtoReflect() protoreflect.Message {
+func (x *WrappedTokenBalance) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[111]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -54319,43 +54020,43 @@ func (x *QueryWrappedTokenBalancesResponse) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryWrappedTokenBalancesResponse_messageType fastReflection_QueryWrappedTokenBalancesResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryWrappedTokenBalancesResponse_messageType{}
+var _fastReflection_WrappedTokenBalance_messageType fastReflection_WrappedTokenBalance_messageType
+var _ protoreflect.MessageType = fastReflection_WrappedTokenBalance_messageType{}
 
-type fastReflection_QueryWrappedTokenBalancesResponse_messageType struct{}
+type fastReflection_WrappedTokenBalance_messageType struct{}
 
-func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryWrappedTokenBalancesResponse)(nil)
+func (x fastReflection_WrappedTokenBalance_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_WrappedTokenBalance)(nil)
 }
-func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryWrappedTokenBalancesResponse)
+func (x fastReflection_WrappedTokenBalance_messageType) New() protoreflect.Message {
+	return new(fastReflection_WrappedTokenBalance)
 }
-func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryWrappedTokenBalancesResponse
+func (x fastReflection_WrappedTokenBalance_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_WrappedTokenBalance
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryWrappedTokenBalancesResponse
+func (x *fastReflection_WrappedTokenBalance) Descriptor() protoreflect.MessageDescriptor {
+	return md_WrappedTokenBalance
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryWrappedTokenBalancesResponse_messageType
+func (x *fastReflection_WrappedTokenBalance) Type() protoreflect.MessageType {
+	return _fastReflection_WrappedTokenBalance_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryWrappedTokenBalancesResponse)
+func (x *fastReflection_WrappedTokenBalance) New() protoreflect.Message {
+	return new(fastReflection_WrappedTokenBalance)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryWrappedTokenBalancesResponse)(x)
+func (x *fastReflection_WrappedTokenBalance) Interface() protoreflect.ProtoMessage {
+	return (*WrappedTokenBalance)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -54363,10 +54064,34 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Balances) != 0 {
-		value := protoreflect.ValueOfList(&_QueryWrappedTokenBalancesResponse_1_list{list: &x.Balances})
-		if !f(fd_QueryWrappedTokenBalancesResponse_balances, value) {
+func (x *fastReflection_WrappedTokenBalance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.TokenInfo != nil {
+		value := protoreflect.ValueOfMessage(x.TokenInfo.ProtoReflect())
+		if !f(fd_WrappedTokenBalance_token_info, value) {
+			return
+		}
+	}
+	if x.Symbol != "" {
+		value := protoreflect.ValueOfString(x.Symbol)
+		if !f(fd_WrappedTokenBalance_symbol, value) {
+			return
+		}
+	}
+	if x.Balance != "" {
+		value := protoreflect.ValueOfString(x.Balance)
+		if !f(fd_WrappedTokenBalance_balance, value) {
+			return
+		}
+	}
+	if x.Decimals != "" {
+		value := protoreflect.ValueOfString(x.Decimals)
+		if !f(fd_WrappedTokenBalance_decimals, value) {
+			return
+		}
+	}
+	if x.FormattedBalance != "" {
+		value := protoreflect.ValueOfString(x.FormattedBalance)
+		if !f(fd_WrappedTokenBalance_formatted_balance, value) {
 			return
 		}
 	}
@@ -54383,15 +54108,23 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_WrappedTokenBalance) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
-		return len(x.Balances) != 0
+	case "inference.inference.WrappedTokenBalance.token_info":
+		return x.TokenInfo != nil
+	case "inference.inference.WrappedTokenBalance.symbol":
+		return x.Symbol != ""
+	case "inference.inference.WrappedTokenBalance.balance":
+		return x.Balance != ""
+	case "inference.inference.WrappedTokenBalance.decimals":
+		return x.Decimals != ""
+	case "inference.inference.WrappedTokenBalance.formatted_balance":
+		return x.FormattedBalance != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -54401,15 +54134,23 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_WrappedTokenBalance) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
-		x.Balances = nil
+	case "inference.inference.WrappedTokenBalance.token_info":
+		x.TokenInfo = nil
+	case "inference.inference.WrappedTokenBalance.symbol":
+		x.Symbol = ""
+	case "inference.inference.WrappedTokenBalance.balance":
+		x.Balance = ""
+	case "inference.inference.WrappedTokenBalance.decimals":
+		x.Decimals = ""
+	case "inference.inference.WrappedTokenBalance.formatted_balance":
+		x.FormattedBalance = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -54419,19 +54160,28 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_WrappedTokenBalance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
-		if len(x.Balances) == 0 {
-			return protoreflect.ValueOfList(&_QueryWrappedTokenBalancesResponse_1_list{})
-		}
-		listValue := &_QueryWrappedTokenBalancesResponse_1_list{list: &x.Balances}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.WrappedTokenBalance.token_info":
+		value := x.TokenInfo
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.WrappedTokenBalance.symbol":
+		value := x.Symbol
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.WrappedTokenBalance.balance":
+		value := x.Balance
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.WrappedTokenBalance.decimals":
+		value := x.Decimals
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.WrappedTokenBalance.formatted_balance":
+		value := x.FormattedBalance
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -54445,17 +54195,23 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_WrappedTokenBalance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
-		lv := value.List()
-		clv := lv.(*_QueryWrappedTokenBalancesResponse_1_list)
-		x.Balances = *clv.list
+	case "inference.inference.WrappedTokenBalance.token_info":
+		x.TokenInfo = value.Message().Interface().(*BridgeWrappedTokenContract)
+	case "inference.inference.WrappedTokenBalance.symbol":
+		x.Symbol = value.Interface().(string)
+	case "inference.inference.WrappedTokenBalance.balance":
+		x.Balance = value.Interface().(string)
+	case "inference.inference.WrappedTokenBalance.decimals":
+		x.Decimals = value.Interface().(string)
+	case "inference.inference.WrappedTokenBalance.formatted_balance":
+		x.FormattedBalance = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -54469,45 +54225,60 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_WrappedTokenBalance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
-		if x.Balances == nil {
-			x.Balances = []*WrappedTokenBalance{}
+	case "inference.inference.WrappedTokenBalance.token_info":
+		if x.TokenInfo == nil {
+			x.TokenInfo = new(BridgeWrappedTokenContract)
 		}
-		value := &_QueryWrappedTokenBalancesResponse_1_list{list: &x.Balances}
-		return protoreflect.ValueOfList(value)
+		return protoreflect.ValueOfMessage(x.TokenInfo.ProtoReflect())
+	case "inference.inference.WrappedTokenBalance.symbol":
+		panic(fmt.Errorf("field symbol of message inference.inference.WrappedTokenBalance is not mutable"))
+	case "inference.inference.WrappedTokenBalance.balance":
+		panic(fmt.Errorf("field balance of message inference.inference.WrappedTokenBalance is not mutable"))
+	case "inference.inference.WrappedTokenBalance.decimals":
+		panic(fmt.Errorf("field decimals of message inference.inference.WrappedTokenBalance is not mutable"))
+	case "inference.inference.WrappedTokenBalance.formatted_balance":
+		panic(fmt.Errorf("field formatted_balance of message inference.inference.WrappedTokenBalance is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_WrappedTokenBalance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
-		list := []*WrappedTokenBalance{}
-		return protoreflect.ValueOfList(&_QueryWrappedTokenBalancesResponse_1_list{list: &list})
+	case "inference.inference.WrappedTokenBalance.token_info":
+		m := new(BridgeWrappedTokenContract)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.WrappedTokenBalance.symbol":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.WrappedTokenBalance.balance":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.WrappedTokenBalance.decimals":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.WrappedTokenBalance.formatted_balance":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.WrappedTokenBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.WrappedTokenBalance does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_WrappedTokenBalance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryWrappedTokenBalancesResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.WrappedTokenBalance", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -54515,7 +54286,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_WrappedTokenBalance) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -54526,7 +54297,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_WrappedTokenBalance) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -54538,7 +54309,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) IsValid() bool {
+func (x *fastReflection_WrappedTokenBalance) IsValid() bool {
 	return x != nil
 }
 
@@ -54548,9 +54319,9 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_WrappedTokenBalance) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
+		x := input.Message.Interface().(*WrappedTokenBalance)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54562,11 +54333,25 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if len(x.Balances) > 0 {
-			for _, e := range x.Balances {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.TokenInfo != nil {
+			l = options.Size(x.TokenInfo)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Symbol)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Balance)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Decimals)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.FormattedBalance)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -54578,7 +54363,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
+		x := input.Message.Interface().(*WrappedTokenBalance)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54597,21 +54382,47 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Balances) > 0 {
-			for iNdEx := len(x.Balances) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Balances[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
+		if len(x.FormattedBalance) > 0 {
+			i -= len(x.FormattedBalance)
+			copy(dAtA[i:], x.FormattedBalance)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.FormattedBalance)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.Decimals) > 0 {
+			i -= len(x.Decimals)
+			copy(dAtA[i:], x.Decimals)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Decimals)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.Balance) > 0 {
+			i -= len(x.Balance)
+			copy(dAtA[i:], x.Balance)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Balance)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.Symbol) > 0 {
+			i -= len(x.Symbol)
+			copy(dAtA[i:], x.Symbol)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Symbol)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.TokenInfo != nil {
+			encoded, err := options.Marshal(x.TokenInfo)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
 			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -54624,7 +54435,7 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
+		x := input.Message.Interface().(*WrappedTokenBalance)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54656,15 +54467,15 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: WrappedTokenBalance: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: WrappedTokenBalance: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TokenInfo", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -54691,11 +54502,141 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Balances = append(x.Balances, &WrappedTokenBalance{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Balances[len(x.Balances)-1]); err != nil {
+				if x.TokenInfo == nil {
+					x.TokenInfo = &BridgeWrappedTokenContract{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.TokenInfo); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Symbol = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Balance = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Decimals = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field FormattedBalance", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.FormattedBalance = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -54732,25 +54673,25 @@ func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *proto
 }
 
 var (
-	md_QueryBridgeAddressesByChainRequest          protoreflect.MessageDescriptor
-	fd_QueryBridgeAddressesByChainRequest_chain_id protoreflect.FieldDescriptor
+	md_QueryWrappedTokenBalancesRequest         protoreflect.MessageDescriptor
+	fd_QueryWrappedTokenBalancesRequest_address protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryBridgeAddressesByChainRequest = File_inference_inference_query_proto.Messages().ByName("QueryBridgeAddressesByChainRequest")
-	fd_QueryBridgeAddressesByChainRequest_chain_id = md_QueryBridgeAddressesByChainRequest.Fields().ByName("chain_id")
+	md_QueryWrappedTokenBalancesRequest = File_inference_inference_query_proto.Messages().ByName("QueryWrappedTokenBalancesRequest")
+	fd_QueryWrappedTokenBalancesRequest_address = md_QueryWrappedTokenBalancesRequest.Fields().ByName("address")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryBridgeAddressesByChainRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryWrappedTokenBalancesRequest)(nil)
 
-type fastReflection_QueryBridgeAddressesByChainRequest QueryBridgeAddressesByChainRequest
+type fastReflection_QueryWrappedTokenBalancesRequest QueryWrappedTokenBalancesRequest
 
-func (x *QueryBridgeAddressesByChainRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryBridgeAddressesByChainRequest)(x)
+func (x *QueryWrappedTokenBalancesRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryWrappedTokenBalancesRequest)(x)
 }
 
-func (x *QueryBridgeAddressesByChainRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryWrappedTokenBalancesRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[112]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -54762,43 +54703,43 @@ func (x *QueryBridgeAddressesByChainRequest) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryBridgeAddressesByChainRequest_messageType fastReflection_QueryBridgeAddressesByChainRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryBridgeAddressesByChainRequest_messageType{}
+var _fastReflection_QueryWrappedTokenBalancesRequest_messageType fastReflection_QueryWrappedTokenBalancesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryWrappedTokenBalancesRequest_messageType{}
 
-type fastReflection_QueryBridgeAddressesByChainRequest_messageType struct{}
+type fastReflection_QueryWrappedTokenBalancesRequest_messageType struct{}
 
-func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryBridgeAddressesByChainRequest)(nil)
+func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryWrappedTokenBalancesRequest)(nil)
 }
-func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryBridgeAddressesByChainRequest)
+func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryWrappedTokenBalancesRequest)
 }
-func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryBridgeAddressesByChainRequest
+func (x fastReflection_QueryWrappedTokenBalancesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryWrappedTokenBalancesRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryBridgeAddressesByChainRequest
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryWrappedTokenBalancesRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryBridgeAddressesByChainRequest_messageType
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryWrappedTokenBalancesRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryBridgeAddressesByChainRequest)
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryWrappedTokenBalancesRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryBridgeAddressesByChainRequest)(x)
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryWrappedTokenBalancesRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -54806,10 +54747,10 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ChainId != "" {
-		value := protoreflect.ValueOfString(x.ChainId)
-		if !f(fd_QueryBridgeAddressesByChainRequest_chain_id, value) {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Address != "" {
+		value := protoreflect.ValueOfString(x.Address)
+		if !f(fd_QueryWrappedTokenBalancesRequest_address, value) {
 			return
 		}
 	}
@@ -54826,15 +54767,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
-		return x.ChainId != ""
+	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+		return x.Address != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -54844,15 +54785,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
-		x.ChainId = ""
+	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+		x.Address = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -54862,16 +54803,16 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
-		value := x.ChainId
+	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+		value := x.Address
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -54885,15 +54826,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
-		x.ChainId = value.Interface().(string)
+	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+		x.Address = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -54907,40 +54848,40 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
-		panic(fmt.Errorf("field chain_id of message inference.inference.QueryBridgeAddressesByChainRequest is not mutable"))
+	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
+		panic(fmt.Errorf("field address of message inference.inference.QueryWrappedTokenBalancesRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+	case "inference.inference.QueryWrappedTokenBalancesRequest.address":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryBridgeAddressesByChainRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryWrappedTokenBalancesRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -54948,7 +54889,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -54959,7 +54900,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -54971,7 +54912,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) IsValid() bool {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -54981,9 +54922,9 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryWrappedTokenBalancesRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
+		x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -54995,7 +54936,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		l = len(x.ChainId)
+		l = len(x.Address)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -55009,7 +54950,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
+		x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55028,10 +54969,10 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ChainId) > 0 {
-			i -= len(x.ChainId)
-			copy(dAtA[i:], x.ChainId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+		if len(x.Address) > 0 {
+			i -= len(x.Address)
+			copy(dAtA[i:], x.Address)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -55046,7 +54987,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
+		x := input.Message.Interface().(*QueryWrappedTokenBalancesRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55078,15 +55019,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -55114,7 +55055,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ChainId = string(dAtA[iNdEx:postIndex])
+				x.Address = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -55151,77 +55092,77 @@ func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *prot
 	}
 }
 
-var _ protoreflect.List = (*_QueryBridgeAddressesByChainResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryWrappedTokenBalancesResponse_1_list)(nil)
 
-type _QueryBridgeAddressesByChainResponse_1_list struct {
-	list *[]*BridgeContractAddress
+type _QueryWrappedTokenBalancesResponse_1_list struct {
+	list *[]*WrappedTokenBalance
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) Len() int {
+func (x *_QueryWrappedTokenBalancesResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryWrappedTokenBalancesResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryWrappedTokenBalancesResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*BridgeContractAddress)
+	concreteValue := valueUnwrapped.Interface().(*WrappedTokenBalance)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryWrappedTokenBalancesResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*BridgeContractAddress)
+	concreteValue := valueUnwrapped.Interface().(*WrappedTokenBalance)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(BridgeContractAddress)
+func (x *_QueryWrappedTokenBalancesResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(WrappedTokenBalance)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) Truncate(n int) {
+func (x *_QueryWrappedTokenBalancesResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) NewElement() protoreflect.Value {
-	v := new(BridgeContractAddress)
+func (x *_QueryWrappedTokenBalancesResponse_1_list) NewElement() protoreflect.Value {
+	v := new(WrappedTokenBalance)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryBridgeAddressesByChainResponse_1_list) IsValid() bool {
+func (x *_QueryWrappedTokenBalancesResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryBridgeAddressesByChainResponse           protoreflect.MessageDescriptor
-	fd_QueryBridgeAddressesByChainResponse_addresses protoreflect.FieldDescriptor
+	md_QueryWrappedTokenBalancesResponse          protoreflect.MessageDescriptor
+	fd_QueryWrappedTokenBalancesResponse_balances protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryBridgeAddressesByChainResponse = File_inference_inference_query_proto.Messages().ByName("QueryBridgeAddressesByChainResponse")
-	fd_QueryBridgeAddressesByChainResponse_addresses = md_QueryBridgeAddressesByChainResponse.Fields().ByName("addresses")
+	md_QueryWrappedTokenBalancesResponse = File_inference_inference_query_proto.Messages().ByName("QueryWrappedTokenBalancesResponse")
+	fd_QueryWrappedTokenBalancesResponse_balances = md_QueryWrappedTokenBalancesResponse.Fields().ByName("balances")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryBridgeAddressesByChainResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryWrappedTokenBalancesResponse)(nil)
 
-type fastReflection_QueryBridgeAddressesByChainResponse QueryBridgeAddressesByChainResponse
+type fastReflection_QueryWrappedTokenBalancesResponse QueryWrappedTokenBalancesResponse
 
-func (x *QueryBridgeAddressesByChainResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryBridgeAddressesByChainResponse)(x)
+func (x *QueryWrappedTokenBalancesResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryWrappedTokenBalancesResponse)(x)
 }
 
-func (x *QueryBridgeAddressesByChainResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryWrappedTokenBalancesResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[113]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -55233,43 +55174,43 @@ func (x *QueryBridgeAddressesByChainResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryBridgeAddressesByChainResponse_messageType fastReflection_QueryBridgeAddressesByChainResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryBridgeAddressesByChainResponse_messageType{}
+var _fastReflection_QueryWrappedTokenBalancesResponse_messageType fastReflection_QueryWrappedTokenBalancesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryWrappedTokenBalancesResponse_messageType{}
 
-type fastReflection_QueryBridgeAddressesByChainResponse_messageType struct{}
+type fastReflection_QueryWrappedTokenBalancesResponse_messageType struct{}
 
-func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryBridgeAddressesByChainResponse)(nil)
+func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryWrappedTokenBalancesResponse)(nil)
 }
-func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryBridgeAddressesByChainResponse)
+func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryWrappedTokenBalancesResponse)
 }
-func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryBridgeAddressesByChainResponse
+func (x fastReflection_QueryWrappedTokenBalancesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryWrappedTokenBalancesResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryBridgeAddressesByChainResponse
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryWrappedTokenBalancesResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryBridgeAddressesByChainResponse_messageType
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryWrappedTokenBalancesResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryBridgeAddressesByChainResponse)
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryWrappedTokenBalancesResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryBridgeAddressesByChainResponse)(x)
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryWrappedTokenBalancesResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -55277,10 +55218,10 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Addresses) != 0 {
-		value := protoreflect.ValueOfList(&_QueryBridgeAddressesByChainResponse_1_list{list: &x.Addresses})
-		if !f(fd_QueryBridgeAddressesByChainResponse_addresses, value) {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Balances) != 0 {
+		value := protoreflect.ValueOfList(&_QueryWrappedTokenBalancesResponse_1_list{list: &x.Balances})
+		if !f(fd_QueryWrappedTokenBalancesResponse_balances, value) {
 			return
 		}
 	}
@@ -55297,15 +55238,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
-		return len(x.Addresses) != 0
+	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+		return len(x.Balances) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -55315,15 +55256,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
-		x.Addresses = nil
+	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+		x.Balances = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -55333,19 +55274,19 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
-		if len(x.Addresses) == 0 {
-			return protoreflect.ValueOfList(&_QueryBridgeAddressesByChainResponse_1_list{})
+	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+		if len(x.Balances) == 0 {
+			return protoreflect.ValueOfList(&_QueryWrappedTokenBalancesResponse_1_list{})
 		}
-		listValue := &_QueryBridgeAddressesByChainResponse_1_list{list: &x.Addresses}
+		listValue := &_QueryWrappedTokenBalancesResponse_1_list{list: &x.Balances}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -55359,17 +55300,17 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
 		lv := value.List()
-		clv := lv.(*_QueryBridgeAddressesByChainResponse_1_list)
-		x.Addresses = *clv.list
+		clv := lv.(*_QueryWrappedTokenBalancesResponse_1_list)
+		x.Balances = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -55383,45 +55324,45 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
-		if x.Addresses == nil {
-			x.Addresses = []*BridgeContractAddress{}
+	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+		if x.Balances == nil {
+			x.Balances = []*WrappedTokenBalance{}
 		}
-		value := &_QueryBridgeAddressesByChainResponse_1_list{list: &x.Addresses}
+		value := &_QueryWrappedTokenBalancesResponse_1_list{list: &x.Balances}
 		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
-		list := []*BridgeContractAddress{}
-		return protoreflect.ValueOfList(&_QueryBridgeAddressesByChainResponse_1_list{list: &list})
+	case "inference.inference.QueryWrappedTokenBalancesResponse.balances":
+		list := []*WrappedTokenBalance{}
+		return protoreflect.ValueOfList(&_QueryWrappedTokenBalancesResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryWrappedTokenBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryWrappedTokenBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryBridgeAddressesByChainResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryWrappedTokenBalancesResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -55429,7 +55370,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -55440,7 +55381,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -55452,7 +55393,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) IsValid() bool {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -55462,9 +55403,9 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryWrappedTokenBalancesResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
+		x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55476,8 +55417,8 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 		var n int
 		var l int
 		_ = l
-		if len(x.Addresses) > 0 {
-			for _, e := range x.Addresses {
+		if len(x.Balances) > 0 {
+			for _, e := range x.Balances {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -55492,7 +55433,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
+		x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55511,9 +55452,9 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Addresses) > 0 {
-			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Addresses[iNdEx])
+		if len(x.Balances) > 0 {
+			for iNdEx := len(x.Balances) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Balances[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55538,7 +55479,7 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
+		x := input.Message.Interface().(*QueryWrappedTokenBalancesResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55570,15 +55511,15 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -55605,8 +55546,8 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Addresses = append(x.Addresses, &BridgeContractAddress{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Addresses[len(x.Addresses)-1]); err != nil {
+				x.Balances = append(x.Balances, &WrappedTokenBalance{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Balances[len(x.Balances)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -55646,25 +55587,25 @@ func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *pro
 }
 
 var (
-	md_QueryValidateWrappedTokenForTradeRequest                  protoreflect.MessageDescriptor
-	fd_QueryValidateWrappedTokenForTradeRequest_contract_address protoreflect.FieldDescriptor
+	md_QueryBridgeAddressesByChainRequest          protoreflect.MessageDescriptor
+	fd_QueryBridgeAddressesByChainRequest_chain_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryValidateWrappedTokenForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryValidateWrappedTokenForTradeRequest")
-	fd_QueryValidateWrappedTokenForTradeRequest_contract_address = md_QueryValidateWrappedTokenForTradeRequest.Fields().ByName("contract_address")
+	md_QueryBridgeAddressesByChainRequest = File_inference_inference_query_proto.Messages().ByName("QueryBridgeAddressesByChainRequest")
+	fd_QueryBridgeAddressesByChainRequest_chain_id = md_QueryBridgeAddressesByChainRequest.Fields().ByName("chain_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryBridgeAddressesByChainRequest)(nil)
 
-type fastReflection_QueryValidateWrappedTokenForTradeRequest QueryValidateWrappedTokenForTradeRequest
+type fastReflection_QueryBridgeAddressesByChainRequest QueryBridgeAddressesByChainRequest
 
-func (x *QueryValidateWrappedTokenForTradeRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(x)
+func (x *QueryBridgeAddressesByChainRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryBridgeAddressesByChainRequest)(x)
 }
 
-func (x *QueryValidateWrappedTokenForTradeRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryBridgeAddressesByChainRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[114]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -55676,43 +55617,43 @@ func (x *QueryValidateWrappedTokenForTradeRequest) slowProtoReflect() protorefle
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType{}
+var _fastReflection_QueryBridgeAddressesByChainRequest_messageType fastReflection_QueryBridgeAddressesByChainRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryBridgeAddressesByChainRequest_messageType{}
 
-type fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType struct{}
+type fastReflection_QueryBridgeAddressesByChainRequest_messageType struct{}
 
-func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(nil)
+func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryBridgeAddressesByChainRequest)(nil)
 }
-func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateWrappedTokenForTradeRequest)
+func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryBridgeAddressesByChainRequest)
 }
-func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateWrappedTokenForTradeRequest
+func (x fastReflection_QueryBridgeAddressesByChainRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryBridgeAddressesByChainRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateWrappedTokenForTradeRequest
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryBridgeAddressesByChainRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryBridgeAddressesByChainRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateWrappedTokenForTradeRequest)
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryBridgeAddressesByChainRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryValidateWrappedTokenForTradeRequest)(x)
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryBridgeAddressesByChainRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -55720,10 +55661,10 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Interface() pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ContractAddress != "" {
-		value := protoreflect.ValueOfString(x.ContractAddress)
-		if !f(fd_QueryValidateWrappedTokenForTradeRequest_contract_address, value) {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ChainId != "" {
+		value := protoreflect.ValueOfString(x.ChainId)
+		if !f(fd_QueryBridgeAddressesByChainRequest_chain_id, value) {
 			return
 		}
 	}
@@ -55740,15 +55681,15 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Range(f func(p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
-		return x.ContractAddress != ""
+	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+		return x.ChainId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -55758,15 +55699,15 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Has(fd protore
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
-		x.ContractAddress = ""
+	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+		x.ChainId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -55776,16 +55717,16 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Clear(fd proto
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
-		value := x.ContractAddress
+	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+		value := x.ChainId
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -55799,15 +55740,15 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
-		x.ContractAddress = value.Interface().(string)
+	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+		x.ChainId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -55821,40 +55762,40 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Set(fd protore
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
-		panic(fmt.Errorf("field contract_address of message inference.inference.QueryValidateWrappedTokenForTradeRequest is not mutable"))
+	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
+		panic(fmt.Errorf("field chain_id of message inference.inference.QueryBridgeAddressesByChainRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+	case "inference.inference.QueryBridgeAddressesByChainRequest.chain_id":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateWrappedTokenForTradeRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryBridgeAddressesByChainRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -55862,7 +55803,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) WhichOneof(d p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -55873,7 +55814,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) GetUnknown() p
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -55885,7 +55826,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) SetUnknown(fie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) IsValid() bool {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -55895,9 +55836,9 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryBridgeAddressesByChainRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
+		x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55909,7 +55850,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 		var n int
 		var l int
 		_ = l
-		l = len(x.ContractAddress)
+		l = len(x.ChainId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -55923,7 +55864,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
+		x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55942,10 +55883,10 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ContractAddress) > 0 {
-			i -= len(x.ContractAddress)
-			copy(dAtA[i:], x.ContractAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+		if len(x.ChainId) > 0 {
+			i -= len(x.ChainId)
+			copy(dAtA[i:], x.ChainId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -55960,7 +55901,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
+		x := input.Message.Interface().(*QueryBridgeAddressesByChainRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -55992,15 +55933,15 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -56028,7 +55969,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ContractAddress = string(dAtA[iNdEx:postIndex])
+				x.ChainId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -56065,26 +56006,77 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods()
 	}
 }
 
+var _ protoreflect.List = (*_QueryBridgeAddressesByChainResponse_1_list)(nil)
+
+type _QueryBridgeAddressesByChainResponse_1_list struct {
+	list *[]*BridgeContractAddress
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*BridgeContractAddress)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*BridgeContractAddress)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(BridgeContractAddress)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) NewElement() protoreflect.Value {
+	v := new(BridgeContractAddress)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryBridgeAddressesByChainResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryValidateWrappedTokenForTradeResponse          protoreflect.MessageDescriptor
-	fd_QueryValidateWrappedTokenForTradeResponse_is_valid protoreflect.FieldDescriptor
+	md_QueryBridgeAddressesByChainResponse           protoreflect.MessageDescriptor
+	fd_QueryBridgeAddressesByChainResponse_addresses protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryValidateWrappedTokenForTradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryValidateWrappedTokenForTradeResponse")
-	fd_QueryValidateWrappedTokenForTradeResponse_is_valid = md_QueryValidateWrappedTokenForTradeResponse.Fields().ByName("is_valid")
+	md_QueryBridgeAddressesByChainResponse = File_inference_inference_query_proto.Messages().ByName("QueryBridgeAddressesByChainResponse")
+	fd_QueryBridgeAddressesByChainResponse_addresses = md_QueryBridgeAddressesByChainResponse.Fields().ByName("addresses")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryBridgeAddressesByChainResponse)(nil)
 
-type fastReflection_QueryValidateWrappedTokenForTradeResponse QueryValidateWrappedTokenForTradeResponse
+type fastReflection_QueryBridgeAddressesByChainResponse QueryBridgeAddressesByChainResponse
 
-func (x *QueryValidateWrappedTokenForTradeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(x)
+func (x *QueryBridgeAddressesByChainResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryBridgeAddressesByChainResponse)(x)
 }
 
-func (x *QueryValidateWrappedTokenForTradeResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryBridgeAddressesByChainResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[115]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -56096,43 +56088,43 @@ func (x *QueryValidateWrappedTokenForTradeResponse) slowProtoReflect() protorefl
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType{}
+var _fastReflection_QueryBridgeAddressesByChainResponse_messageType fastReflection_QueryBridgeAddressesByChainResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryBridgeAddressesByChainResponse_messageType{}
 
-type fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType struct{}
+type fastReflection_QueryBridgeAddressesByChainResponse_messageType struct{}
 
-func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(nil)
+func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryBridgeAddressesByChainResponse)(nil)
 }
-func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateWrappedTokenForTradeResponse)
+func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryBridgeAddressesByChainResponse)
 }
-func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateWrappedTokenForTradeResponse
+func (x fastReflection_QueryBridgeAddressesByChainResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryBridgeAddressesByChainResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateWrappedTokenForTradeResponse
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryBridgeAddressesByChainResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryBridgeAddressesByChainResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateWrappedTokenForTradeResponse)
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryBridgeAddressesByChainResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryValidateWrappedTokenForTradeResponse)(x)
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryBridgeAddressesByChainResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -56140,10 +56132,10 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Interface() p
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.IsValid_ != false {
-		value := protoreflect.ValueOfBool(x.IsValid_)
-		if !f(fd_QueryValidateWrappedTokenForTradeResponse_is_valid, value) {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Addresses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryBridgeAddressesByChainResponse_1_list{list: &x.Addresses})
+		if !f(fd_QueryBridgeAddressesByChainResponse_addresses, value) {
 			return
 		}
 	}
@@ -56160,15 +56152,15 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Range(f func(
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
-		return x.IsValid_ != false
+	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+		return len(x.Addresses) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -56178,15 +56170,15 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Has(fd protor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
-		x.IsValid_ = false
+	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+		x.Addresses = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -56196,16 +56188,19 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Clear(fd prot
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
-		value := x.IsValid_
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+		if len(x.Addresses) == 0 {
+			return protoreflect.ValueOfList(&_QueryBridgeAddressesByChainResponse_1_list{})
+		}
+		listValue := &_QueryBridgeAddressesByChainResponse_1_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -56219,15 +56214,17 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Get(descripto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
-		x.IsValid_ = value.Bool()
+	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+		lv := value.List()
+		clv := lv.(*_QueryBridgeAddressesByChainResponse_1_list)
+		x.Addresses = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -56241,40 +56238,45 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Set(fd protor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
-		panic(fmt.Errorf("field is_valid of message inference.inference.QueryValidateWrappedTokenForTradeResponse is not mutable"))
+	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+		if x.Addresses == nil {
+			x.Addresses = []*BridgeContractAddress{}
+		}
+		value := &_QueryBridgeAddressesByChainResponse_1_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryBridgeAddressesByChainResponse.addresses":
+		list := []*BridgeContractAddress{}
+		return protoreflect.ValueOfList(&_QueryBridgeAddressesByChainResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryBridgeAddressesByChainResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryBridgeAddressesByChainResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateWrappedTokenForTradeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryBridgeAddressesByChainResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -56282,7 +56284,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -56293,7 +56295,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -56305,7 +56307,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) SetUnknown(fi
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) IsValid() bool {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -56315,9 +56317,9 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) IsValid() boo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryBridgeAddressesByChainResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
+		x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -56329,8 +56331,11 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 		var n int
 		var l int
 		_ = l
-		if x.IsValid_ {
-			n += 2
+		if len(x.Addresses) > 0 {
+			for _, e := range x.Addresses {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -56342,7 +56347,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
+		x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -56361,15 +56366,21 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.IsValid_ {
-			i--
-			if x.IsValid_ {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
+		if len(x.Addresses) > 0 {
+			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Addresses[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
 			}
-			i--
-			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -56382,7 +56393,7 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
+		x := input.Message.Interface().(*QueryBridgeAddressesByChainResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -56414,17 +56425,17 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IsValid_", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
 				}
-				var v int
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -56434,12 +56445,26 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.IsValid_ = bool(v != 0)
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Addresses = append(x.Addresses, &BridgeContractAddress{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Addresses[len(x.Addresses)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -56476,25 +56501,25 @@ func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods(
 }
 
 var (
-	md_QueryValidateIbcTokenForTradeRequest           protoreflect.MessageDescriptor
-	fd_QueryValidateIbcTokenForTradeRequest_ibc_denom protoreflect.FieldDescriptor
+	md_QueryValidateWrappedTokenForTradeRequest                  protoreflect.MessageDescriptor
+	fd_QueryValidateWrappedTokenForTradeRequest_contract_address protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryValidateIbcTokenForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryValidateIbcTokenForTradeRequest")
-	fd_QueryValidateIbcTokenForTradeRequest_ibc_denom = md_QueryValidateIbcTokenForTradeRequest.Fields().ByName("ibc_denom")
+	md_QueryValidateWrappedTokenForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryValidateWrappedTokenForTradeRequest")
+	fd_QueryValidateWrappedTokenForTradeRequest_contract_address = md_QueryValidateWrappedTokenForTradeRequest.Fields().ByName("contract_address")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryValidateIbcTokenForTradeRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(nil)
 
-type fastReflection_QueryValidateIbcTokenForTradeRequest QueryValidateIbcTokenForTradeRequest
+type fastReflection_QueryValidateWrappedTokenForTradeRequest QueryValidateWrappedTokenForTradeRequest
 
-func (x *QueryValidateIbcTokenForTradeRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryValidateIbcTokenForTradeRequest)(x)
+func (x *QueryValidateWrappedTokenForTradeRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(x)
 }
 
-func (x *QueryValidateIbcTokenForTradeRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryValidateWrappedTokenForTradeRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[116]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -56506,43 +56531,43 @@ func (x *QueryValidateIbcTokenForTradeRequest) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryValidateIbcTokenForTradeRequest_messageType fastReflection_QueryValidateIbcTokenForTradeRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryValidateIbcTokenForTradeRequest_messageType{}
+var _fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType{}
 
-type fastReflection_QueryValidateIbcTokenForTradeRequest_messageType struct{}
+type fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType struct{}
 
-func (x fastReflection_QueryValidateIbcTokenForTradeRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryValidateIbcTokenForTradeRequest)(nil)
+func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidateWrappedTokenForTradeRequest)(nil)
 }
-func (x fastReflection_QueryValidateIbcTokenForTradeRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateIbcTokenForTradeRequest)
+func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateWrappedTokenForTradeRequest)
 }
-func (x fastReflection_QueryValidateIbcTokenForTradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateIbcTokenForTradeRequest
+func (x fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateWrappedTokenForTradeRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateIbcTokenForTradeRequest
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateWrappedTokenForTradeRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryValidateIbcTokenForTradeRequest_messageType
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidateWrappedTokenForTradeRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateIbcTokenForTradeRequest)
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateWrappedTokenForTradeRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryValidateIbcTokenForTradeRequest)(x)
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidateWrappedTokenForTradeRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -56550,10 +56575,10 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.IbcDenom != "" {
-		value := protoreflect.ValueOfString(x.IbcDenom)
-		if !f(fd_QueryValidateIbcTokenForTradeRequest_ibc_denom, value) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ContractAddress != "" {
+		value := protoreflect.ValueOfString(x.ContractAddress)
+		if !f(fd_QueryValidateWrappedTokenForTradeRequest_contract_address, value) {
 			return
 		}
 	}
@@ -56570,15 +56595,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
-		return x.IbcDenom != ""
+	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+		return x.ContractAddress != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -56588,15 +56613,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
-		x.IbcDenom = ""
+	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+		x.ContractAddress = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -56606,16 +56631,16 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
-		value := x.IbcDenom
+	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+		value := x.ContractAddress
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -56629,15 +56654,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
-		x.IbcDenom = value.Interface().(string)
+	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+		x.ContractAddress = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -56651,40 +56676,40 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
-		panic(fmt.Errorf("field ibc_denom of message inference.inference.QueryValidateIbcTokenForTradeRequest is not mutable"))
+	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
+		panic(fmt.Errorf("field contract_address of message inference.inference.QueryValidateWrappedTokenForTradeRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+	case "inference.inference.QueryValidateWrappedTokenForTradeRequest.contract_address":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateIbcTokenForTradeRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateWrappedTokenForTradeRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -56692,7 +56717,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -56703,7 +56728,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -56715,7 +56740,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) IsValid() bool {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -56725,9 +56750,9 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeRequest)
+		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -56739,7 +56764,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 		var n int
 		var l int
 		_ = l
-		l = len(x.IbcDenom)
+		l = len(x.ContractAddress)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -56753,7 +56778,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeRequest)
+		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -56772,10 +56797,10 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.IbcDenom) > 0 {
-			i -= len(x.IbcDenom)
-			copy(dAtA[i:], x.IbcDenom)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.IbcDenom)))
+		if len(x.ContractAddress) > 0 {
+			i -= len(x.ContractAddress)
+			copy(dAtA[i:], x.ContractAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -56790,7 +56815,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeRequest)
+		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -56822,15 +56847,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -56858,7 +56883,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.IbcDenom = string(dAtA[iNdEx:postIndex])
+				x.ContractAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -56896,27 +56921,25 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *pr
 }
 
 var (
-	md_QueryValidateIbcTokenForTradeResponse          protoreflect.MessageDescriptor
-	fd_QueryValidateIbcTokenForTradeResponse_is_valid protoreflect.FieldDescriptor
-	fd_QueryValidateIbcTokenForTradeResponse_decimals protoreflect.FieldDescriptor
+	md_QueryValidateWrappedTokenForTradeResponse          protoreflect.MessageDescriptor
+	fd_QueryValidateWrappedTokenForTradeResponse_is_valid protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryValidateIbcTokenForTradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryValidateIbcTokenForTradeResponse")
-	fd_QueryValidateIbcTokenForTradeResponse_is_valid = md_QueryValidateIbcTokenForTradeResponse.Fields().ByName("is_valid")
-	fd_QueryValidateIbcTokenForTradeResponse_decimals = md_QueryValidateIbcTokenForTradeResponse.Fields().ByName("decimals")
+	md_QueryValidateWrappedTokenForTradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryValidateWrappedTokenForTradeResponse")
+	fd_QueryValidateWrappedTokenForTradeResponse_is_valid = md_QueryValidateWrappedTokenForTradeResponse.Fields().ByName("is_valid")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryValidateIbcTokenForTradeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(nil)
 
-type fastReflection_QueryValidateIbcTokenForTradeResponse QueryValidateIbcTokenForTradeResponse
+type fastReflection_QueryValidateWrappedTokenForTradeResponse QueryValidateWrappedTokenForTradeResponse
 
-func (x *QueryValidateIbcTokenForTradeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryValidateIbcTokenForTradeResponse)(x)
+func (x *QueryValidateWrappedTokenForTradeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(x)
 }
 
-func (x *QueryValidateIbcTokenForTradeResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryValidateWrappedTokenForTradeResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[117]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -56928,43 +56951,43 @@ func (x *QueryValidateIbcTokenForTradeResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryValidateIbcTokenForTradeResponse_messageType fastReflection_QueryValidateIbcTokenForTradeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryValidateIbcTokenForTradeResponse_messageType{}
+var _fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType{}
 
-type fastReflection_QueryValidateIbcTokenForTradeResponse_messageType struct{}
+type fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType struct{}
 
-func (x fastReflection_QueryValidateIbcTokenForTradeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryValidateIbcTokenForTradeResponse)(nil)
+func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidateWrappedTokenForTradeResponse)(nil)
 }
-func (x fastReflection_QueryValidateIbcTokenForTradeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateIbcTokenForTradeResponse)
+func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateWrappedTokenForTradeResponse)
 }
-func (x fastReflection_QueryValidateIbcTokenForTradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateIbcTokenForTradeResponse
+func (x fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateWrappedTokenForTradeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryValidateIbcTokenForTradeResponse
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateWrappedTokenForTradeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryValidateIbcTokenForTradeResponse_messageType
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidateWrappedTokenForTradeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryValidateIbcTokenForTradeResponse)
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateWrappedTokenForTradeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryValidateIbcTokenForTradeResponse)(x)
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidateWrappedTokenForTradeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -56972,16 +56995,10 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.IsValid_ != false {
 		value := protoreflect.ValueOfBool(x.IsValid_)
-		if !f(fd_QueryValidateIbcTokenForTradeResponse_is_valid, value) {
-			return
-		}
-	}
-	if x.Decimals != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Decimals)
-		if !f(fd_QueryValidateIbcTokenForTradeResponse_decimals, value) {
+		if !f(fd_QueryValidateWrappedTokenForTradeResponse_is_valid, value) {
 			return
 		}
 	}
@@ -56998,17 +57015,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
 		return x.IsValid_ != false
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
-		return x.Decimals != uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57018,17 +57033,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
 		x.IsValid_ = false
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
-		x.Decimals = uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57038,19 +57051,16 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
 		value := x.IsValid_
 		return protoreflect.ValueOfBool(value)
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
-		value := x.Decimals
-		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -57064,17 +57074,15 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
 		x.IsValid_ = value.Bool()
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
-		x.Decimals = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57088,44 +57096,40 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
-		panic(fmt.Errorf("field is_valid of message inference.inference.QueryValidateIbcTokenForTradeResponse is not mutable"))
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
-		panic(fmt.Errorf("field decimals of message inference.inference.QueryValidateIbcTokenForTradeResponse is not mutable"))
+	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
+		panic(fmt.Errorf("field is_valid of message inference.inference.QueryValidateWrappedTokenForTradeResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+	case "inference.inference.QueryValidateWrappedTokenForTradeResponse.is_valid":
 		return protoreflect.ValueOfBool(false)
-	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
-		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateWrappedTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateWrappedTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateIbcTokenForTradeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateWrappedTokenForTradeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -57133,7 +57137,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -57144,7 +57148,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -57156,7 +57160,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) IsValid() bool {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -57166,9 +57170,9 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryValidateWrappedTokenForTradeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeResponse)
+		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -57183,9 +57187,6 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 		if x.IsValid_ {
 			n += 2
 		}
-		if x.Decimals != 0 {
-			n += 1 + runtime.Sov(uint64(x.Decimals))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -57196,7 +57197,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeResponse)
+		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -57215,11 +57216,6 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Decimals != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
-			i--
-			dAtA[i] = 0x10
-		}
 		if x.IsValid_ {
 			i--
 			if x.IsValid_ {
@@ -57241,7 +57237,7 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeResponse)
+		x := input.Message.Interface().(*QueryValidateWrappedTokenForTradeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -57273,10 +57269,10 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -57299,25 +57295,6 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 					}
 				}
 				x.IsValid_ = bool(v != 0)
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
-				}
-				x.Decimals = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Decimals |= uint32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -57354,23 +57331,25 @@ func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *p
 }
 
 var (
-	md_QueryLiquidityPoolRequest protoreflect.MessageDescriptor
+	md_QueryValidateIbcTokenForTradeRequest           protoreflect.MessageDescriptor
+	fd_QueryValidateIbcTokenForTradeRequest_ibc_denom protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryLiquidityPoolRequest = File_inference_inference_query_proto.Messages().ByName("QueryLiquidityPoolRequest")
+	md_QueryValidateIbcTokenForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryValidateIbcTokenForTradeRequest")
+	fd_QueryValidateIbcTokenForTradeRequest_ibc_denom = md_QueryValidateIbcTokenForTradeRequest.Fields().ByName("ibc_denom")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryLiquidityPoolRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryValidateIbcTokenForTradeRequest)(nil)
 
-type fastReflection_QueryLiquidityPoolRequest QueryLiquidityPoolRequest
+type fastReflection_QueryValidateIbcTokenForTradeRequest QueryValidateIbcTokenForTradeRequest
 
-func (x *QueryLiquidityPoolRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryLiquidityPoolRequest)(x)
+func (x *QueryValidateIbcTokenForTradeRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidateIbcTokenForTradeRequest)(x)
 }
 
-func (x *QueryLiquidityPoolRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryValidateIbcTokenForTradeRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[118]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -57382,43 +57361,43 @@ func (x *QueryLiquidityPoolRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryLiquidityPoolRequest_messageType fastReflection_QueryLiquidityPoolRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryLiquidityPoolRequest_messageType{}
+var _fastReflection_QueryValidateIbcTokenForTradeRequest_messageType fastReflection_QueryValidateIbcTokenForTradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidateIbcTokenForTradeRequest_messageType{}
 
-type fastReflection_QueryLiquidityPoolRequest_messageType struct{}
+type fastReflection_QueryValidateIbcTokenForTradeRequest_messageType struct{}
 
-func (x fastReflection_QueryLiquidityPoolRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryLiquidityPoolRequest)(nil)
+func (x fastReflection_QueryValidateIbcTokenForTradeRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidateIbcTokenForTradeRequest)(nil)
 }
-func (x fastReflection_QueryLiquidityPoolRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryLiquidityPoolRequest)
+func (x fastReflection_QueryValidateIbcTokenForTradeRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateIbcTokenForTradeRequest)
 }
-func (x fastReflection_QueryLiquidityPoolRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryLiquidityPoolRequest
+func (x fastReflection_QueryValidateIbcTokenForTradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateIbcTokenForTradeRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryLiquidityPoolRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryLiquidityPoolRequest
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateIbcTokenForTradeRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryLiquidityPoolRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryLiquidityPoolRequest_messageType
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidateIbcTokenForTradeRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryLiquidityPoolRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryLiquidityPoolRequest)
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateIbcTokenForTradeRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryLiquidityPoolRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryLiquidityPoolRequest)(x)
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidateIbcTokenForTradeRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -57426,7 +57405,13 @@ func (x *fastReflection_QueryLiquidityPoolRequest) Interface() protoreflect.Prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryLiquidityPoolRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.IbcDenom != "" {
+		value := protoreflect.ValueOfString(x.IbcDenom)
+		if !f(fd_QueryValidateIbcTokenForTradeRequest_ibc_denom, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -57440,13 +57425,15 @@ func (x *fastReflection_QueryLiquidityPoolRequest) Range(f func(protoreflect.Fie
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryLiquidityPoolRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+		return x.IbcDenom != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57456,13 +57443,15 @@ func (x *fastReflection_QueryLiquidityPoolRequest) Has(fd protoreflect.FieldDesc
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+		x.IbcDenom = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57472,13 +57461,16 @@ func (x *fastReflection_QueryLiquidityPoolRequest) Clear(fd protoreflect.FieldDe
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryLiquidityPoolRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+		value := x.IbcDenom
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -57492,13 +57484,15 @@ func (x *fastReflection_QueryLiquidityPoolRequest) Get(descriptor protoreflect.F
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+		x.IbcDenom = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57512,36 +57506,40 @@ func (x *fastReflection_QueryLiquidityPoolRequest) Set(fd protoreflect.FieldDesc
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+		panic(fmt.Errorf("field ibc_denom of message inference.inference.QueryValidateIbcTokenForTradeRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryLiquidityPoolRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryValidateIbcTokenForTradeRequest.ibc_denom":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryLiquidityPoolRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryLiquidityPoolRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateIbcTokenForTradeRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -57549,7 +57547,7 @@ func (x *fastReflection_QueryLiquidityPoolRequest) WhichOneof(d protoreflect.One
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryLiquidityPoolRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -57560,7 +57558,7 @@ func (x *fastReflection_QueryLiquidityPoolRequest) GetUnknown() protoreflect.Raw
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -57572,7 +57570,7 @@ func (x *fastReflection_QueryLiquidityPoolRequest) SetUnknown(fields protoreflec
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryLiquidityPoolRequest) IsValid() bool {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -57582,9 +57580,9 @@ func (x *fastReflection_QueryLiquidityPoolRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryValidateIbcTokenForTradeRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryLiquidityPoolRequest)
+		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -57596,6 +57594,10 @@ func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Me
 		var n int
 		var l int
 		_ = l
+		l = len(x.IbcDenom)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -57606,7 +57608,7 @@ func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Me
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryLiquidityPoolRequest)
+		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -57625,6 +57627,13 @@ func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Me
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.IbcDenom) > 0 {
+			i -= len(x.IbcDenom)
+			copy(dAtA[i:], x.IbcDenom)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.IbcDenom)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -57636,7 +57645,7 @@ func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Me
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryLiquidityPoolRequest)
+		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -57668,12 +57677,44 @@ func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Me
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.IbcDenom = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -57710,29 +57751,27 @@ func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Me
 }
 
 var (
-	md_QueryLiquidityPoolResponse              protoreflect.MessageDescriptor
-	fd_QueryLiquidityPoolResponse_address      protoreflect.FieldDescriptor
-	fd_QueryLiquidityPoolResponse_codeId       protoreflect.FieldDescriptor
-	fd_QueryLiquidityPoolResponse_block_height protoreflect.FieldDescriptor
+	md_QueryValidateIbcTokenForTradeResponse          protoreflect.MessageDescriptor
+	fd_QueryValidateIbcTokenForTradeResponse_is_valid protoreflect.FieldDescriptor
+	fd_QueryValidateIbcTokenForTradeResponse_decimals protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryLiquidityPoolResponse = File_inference_inference_query_proto.Messages().ByName("QueryLiquidityPoolResponse")
-	fd_QueryLiquidityPoolResponse_address = md_QueryLiquidityPoolResponse.Fields().ByName("address")
-	fd_QueryLiquidityPoolResponse_codeId = md_QueryLiquidityPoolResponse.Fields().ByName("codeId")
-	fd_QueryLiquidityPoolResponse_block_height = md_QueryLiquidityPoolResponse.Fields().ByName("block_height")
+	md_QueryValidateIbcTokenForTradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryValidateIbcTokenForTradeResponse")
+	fd_QueryValidateIbcTokenForTradeResponse_is_valid = md_QueryValidateIbcTokenForTradeResponse.Fields().ByName("is_valid")
+	fd_QueryValidateIbcTokenForTradeResponse_decimals = md_QueryValidateIbcTokenForTradeResponse.Fields().ByName("decimals")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryLiquidityPoolResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryValidateIbcTokenForTradeResponse)(nil)
 
-type fastReflection_QueryLiquidityPoolResponse QueryLiquidityPoolResponse
+type fastReflection_QueryValidateIbcTokenForTradeResponse QueryValidateIbcTokenForTradeResponse
 
-func (x *QueryLiquidityPoolResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryLiquidityPoolResponse)(x)
+func (x *QueryValidateIbcTokenForTradeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryValidateIbcTokenForTradeResponse)(x)
 }
 
-func (x *QueryLiquidityPoolResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryValidateIbcTokenForTradeResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[119]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -57744,43 +57783,43 @@ func (x *QueryLiquidityPoolResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryLiquidityPoolResponse_messageType fastReflection_QueryLiquidityPoolResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryLiquidityPoolResponse_messageType{}
+var _fastReflection_QueryValidateIbcTokenForTradeResponse_messageType fastReflection_QueryValidateIbcTokenForTradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryValidateIbcTokenForTradeResponse_messageType{}
 
-type fastReflection_QueryLiquidityPoolResponse_messageType struct{}
+type fastReflection_QueryValidateIbcTokenForTradeResponse_messageType struct{}
 
-func (x fastReflection_QueryLiquidityPoolResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryLiquidityPoolResponse)(nil)
+func (x fastReflection_QueryValidateIbcTokenForTradeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryValidateIbcTokenForTradeResponse)(nil)
 }
-func (x fastReflection_QueryLiquidityPoolResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryLiquidityPoolResponse)
+func (x fastReflection_QueryValidateIbcTokenForTradeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateIbcTokenForTradeResponse)
 }
-func (x fastReflection_QueryLiquidityPoolResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryLiquidityPoolResponse
+func (x fastReflection_QueryValidateIbcTokenForTradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateIbcTokenForTradeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryLiquidityPoolResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryLiquidityPoolResponse
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryValidateIbcTokenForTradeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryLiquidityPoolResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryLiquidityPoolResponse_messageType
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryValidateIbcTokenForTradeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryLiquidityPoolResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryLiquidityPoolResponse)
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryValidateIbcTokenForTradeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryLiquidityPoolResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryLiquidityPoolResponse)(x)
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryValidateIbcTokenForTradeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -57788,22 +57827,16 @@ func (x *fastReflection_QueryLiquidityPoolResponse) Interface() protoreflect.Pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryLiquidityPoolResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Address != "" {
-		value := protoreflect.ValueOfString(x.Address)
-		if !f(fd_QueryLiquidityPoolResponse_address, value) {
-			return
-		}
-	}
-	if x.CodeId != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.CodeId)
-		if !f(fd_QueryLiquidityPoolResponse_codeId, value) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.IsValid_ != false {
+		value := protoreflect.ValueOfBool(x.IsValid_)
+		if !f(fd_QueryValidateIbcTokenForTradeResponse_is_valid, value) {
 			return
 		}
 	}
-	if x.BlockHeight != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.BlockHeight)
-		if !f(fd_QueryLiquidityPoolResponse_block_height, value) {
+	if x.Decimals != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Decimals)
+		if !f(fd_QueryValidateIbcTokenForTradeResponse_decimals, value) {
 			return
 		}
 	}
@@ -57820,19 +57853,17 @@ func (x *fastReflection_QueryLiquidityPoolResponse) Range(f func(protoreflect.Fi
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryLiquidityPoolResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryLiquidityPoolResponse.address":
-		return x.Address != ""
-	case "inference.inference.QueryLiquidityPoolResponse.codeId":
-		return x.CodeId != uint64(0)
-	case "inference.inference.QueryLiquidityPoolResponse.block_height":
-		return x.BlockHeight != uint64(0)
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+		return x.IsValid_ != false
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
+		return x.Decimals != uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57842,19 +57873,17 @@ func (x *fastReflection_QueryLiquidityPoolResponse) Has(fd protoreflect.FieldDes
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryLiquidityPoolResponse.address":
-		x.Address = ""
-	case "inference.inference.QueryLiquidityPoolResponse.codeId":
-		x.CodeId = uint64(0)
-	case "inference.inference.QueryLiquidityPoolResponse.block_height":
-		x.BlockHeight = uint64(0)
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+		x.IsValid_ = false
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
+		x.Decimals = uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57864,22 +57893,19 @@ func (x *fastReflection_QueryLiquidityPoolResponse) Clear(fd protoreflect.FieldD
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryLiquidityPoolResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryLiquidityPoolResponse.address":
-		value := x.Address
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryLiquidityPoolResponse.codeId":
-		value := x.CodeId
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryLiquidityPoolResponse.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+		value := x.IsValid_
+		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
+		value := x.Decimals
+		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -57893,19 +57919,17 @@ func (x *fastReflection_QueryLiquidityPoolResponse) Get(descriptor protoreflect.
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryLiquidityPoolResponse.address":
-		x.Address = value.Interface().(string)
-	case "inference.inference.QueryLiquidityPoolResponse.codeId":
-		x.CodeId = value.Uint()
-	case "inference.inference.QueryLiquidityPoolResponse.block_height":
-		x.BlockHeight = value.Uint()
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+		x.IsValid_ = value.Bool()
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
+		x.Decimals = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -57919,48 +57943,44 @@ func (x *fastReflection_QueryLiquidityPoolResponse) Set(fd protoreflect.FieldDes
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryLiquidityPoolResponse.address":
-		panic(fmt.Errorf("field address of message inference.inference.QueryLiquidityPoolResponse is not mutable"))
-	case "inference.inference.QueryLiquidityPoolResponse.codeId":
-		panic(fmt.Errorf("field codeId of message inference.inference.QueryLiquidityPoolResponse is not mutable"))
-	case "inference.inference.QueryLiquidityPoolResponse.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryLiquidityPoolResponse is not mutable"))
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+		panic(fmt.Errorf("field is_valid of message inference.inference.QueryValidateIbcTokenForTradeResponse is not mutable"))
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
+		panic(fmt.Errorf("field decimals of message inference.inference.QueryValidateIbcTokenForTradeResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryLiquidityPoolResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryLiquidityPoolResponse.address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryLiquidityPoolResponse.codeId":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryLiquidityPoolResponse.block_height":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.is_valid":
+		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryValidateIbcTokenForTradeResponse.decimals":
+		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryValidateIbcTokenForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryValidateIbcTokenForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryLiquidityPoolResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryLiquidityPoolResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryValidateIbcTokenForTradeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -57968,7 +57988,7 @@ func (x *fastReflection_QueryLiquidityPoolResponse) WhichOneof(d protoreflect.On
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryLiquidityPoolResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -57979,7 +57999,7 @@ func (x *fastReflection_QueryLiquidityPoolResponse) GetUnknown() protoreflect.Ra
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryLiquidityPoolResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -57991,7 +58011,7 @@ func (x *fastReflection_QueryLiquidityPoolResponse) SetUnknown(fields protorefle
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryLiquidityPoolResponse) IsValid() bool {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -58001,9 +58021,9 @@ func (x *fastReflection_QueryLiquidityPoolResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryValidateIbcTokenForTradeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryLiquidityPoolResponse)
+		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58015,15 +58035,11 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 		var n int
 		var l int
 		_ = l
-		l = len(x.Address)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.CodeId != 0 {
-			n += 1 + runtime.Sov(uint64(x.CodeId))
+		if x.IsValid_ {
+			n += 2
 		}
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if x.Decimals != 0 {
+			n += 1 + runtime.Sov(uint64(x.Decimals))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -58035,7 +58051,7 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryLiquidityPoolResponse)
+		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58054,22 +58070,20 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
-			i--
-			dAtA[i] = 0x18
-		}
-		if x.CodeId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.CodeId))
+		if x.Decimals != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
 			i--
 			dAtA[i] = 0x10
 		}
-		if len(x.Address) > 0 {
-			i -= len(x.Address)
-			copy(dAtA[i:], x.Address)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
+		if x.IsValid_ {
 			i--
-			dAtA[i] = 0xa
+			if x.IsValid_ {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -58082,7 +58096,7 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryLiquidityPoolResponse)
+		x := input.Message.Interface().(*QueryValidateIbcTokenForTradeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58114,49 +58128,17 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Address = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IsValid_", wireType)
 				}
-				x.CodeId = 0
+				var v int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -58166,16 +58148,17 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.CodeId |= uint64(b&0x7F) << shift
+					v |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 3:
+				x.IsValid_ = bool(v != 0)
+			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
 				}
-				x.BlockHeight = 0
+				x.Decimals = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -58185,7 +58168,7 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= uint64(b&0x7F) << shift
+					x.Decimals |= uint32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -58226,23 +58209,23 @@ func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.M
 }
 
 var (
-	md_QueryEpochInfoRequest protoreflect.MessageDescriptor
+	md_QueryLiquidityPoolRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryEpochInfoRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochInfoRequest")
+	md_QueryLiquidityPoolRequest = File_inference_inference_query_proto.Messages().ByName("QueryLiquidityPoolRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryEpochInfoRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryLiquidityPoolRequest)(nil)
 
-type fastReflection_QueryEpochInfoRequest QueryEpochInfoRequest
+type fastReflection_QueryLiquidityPoolRequest QueryLiquidityPoolRequest
 
-func (x *QueryEpochInfoRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryEpochInfoRequest)(x)
+func (x *QueryLiquidityPoolRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryLiquidityPoolRequest)(x)
 }
 
-func (x *QueryEpochInfoRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryLiquidityPoolRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[120]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -58254,43 +58237,43 @@ func (x *QueryEpochInfoRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryEpochInfoRequest_messageType fastReflection_QueryEpochInfoRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryEpochInfoRequest_messageType{}
+var _fastReflection_QueryLiquidityPoolRequest_messageType fastReflection_QueryLiquidityPoolRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryLiquidityPoolRequest_messageType{}
 
-type fastReflection_QueryEpochInfoRequest_messageType struct{}
+type fastReflection_QueryLiquidityPoolRequest_messageType struct{}
 
-func (x fastReflection_QueryEpochInfoRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryEpochInfoRequest)(nil)
+func (x fastReflection_QueryLiquidityPoolRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryLiquidityPoolRequest)(nil)
 }
-func (x fastReflection_QueryEpochInfoRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochInfoRequest)
+func (x fastReflection_QueryLiquidityPoolRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryLiquidityPoolRequest)
 }
-func (x fastReflection_QueryEpochInfoRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochInfoRequest
+func (x fastReflection_QueryLiquidityPoolRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryLiquidityPoolRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryEpochInfoRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochInfoRequest
+func (x *fastReflection_QueryLiquidityPoolRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryLiquidityPoolRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryEpochInfoRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryEpochInfoRequest_messageType
+func (x *fastReflection_QueryLiquidityPoolRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryLiquidityPoolRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryEpochInfoRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochInfoRequest)
+func (x *fastReflection_QueryLiquidityPoolRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryLiquidityPoolRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryEpochInfoRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryEpochInfoRequest)(x)
+func (x *fastReflection_QueryLiquidityPoolRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryLiquidityPoolRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -58298,7 +58281,7 @@ func (x *fastReflection_QueryEpochInfoRequest) Interface() protoreflect.ProtoMes
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryEpochInfoRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryLiquidityPoolRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -58312,13 +58295,13 @@ func (x *fastReflection_QueryEpochInfoRequest) Range(f func(protoreflect.FieldDe
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryEpochInfoRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryLiquidityPoolRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -58328,13 +58311,13 @@ func (x *fastReflection_QueryEpochInfoRequest) Has(fd protoreflect.FieldDescript
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryLiquidityPoolRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -58344,13 +58327,13 @@ func (x *fastReflection_QueryEpochInfoRequest) Clear(fd protoreflect.FieldDescri
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryEpochInfoRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryLiquidityPoolRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -58364,13 +58347,13 @@ func (x *fastReflection_QueryEpochInfoRequest) Get(descriptor protoreflect.Field
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryLiquidityPoolRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -58384,36 +58367,36 @@ func (x *fastReflection_QueryEpochInfoRequest) Set(fd protoreflect.FieldDescript
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryLiquidityPoolRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryEpochInfoRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryLiquidityPoolRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryEpochInfoRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryLiquidityPoolRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochInfoRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryLiquidityPoolRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -58421,7 +58404,7 @@ func (x *fastReflection_QueryEpochInfoRequest) WhichOneof(d protoreflect.OneofDe
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryEpochInfoRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryLiquidityPoolRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -58432,7 +58415,7 @@ func (x *fastReflection_QueryEpochInfoRequest) GetUnknown() protoreflect.RawFiel
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryLiquidityPoolRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -58444,7 +58427,7 @@ func (x *fastReflection_QueryEpochInfoRequest) SetUnknown(fields protoreflect.Ra
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryEpochInfoRequest) IsValid() bool {
+func (x *fastReflection_QueryLiquidityPoolRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -58454,9 +58437,9 @@ func (x *fastReflection_QueryEpochInfoRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryEpochInfoRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryLiquidityPoolRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryEpochInfoRequest)
+		x := input.Message.Interface().(*QueryLiquidityPoolRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58478,7 +58461,7 @@ func (x *fastReflection_QueryEpochInfoRequest) ProtoMethods() *protoiface.Method
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochInfoRequest)
+		x := input.Message.Interface().(*QueryLiquidityPoolRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58508,7 +58491,7 @@ func (x *fastReflection_QueryEpochInfoRequest) ProtoMethods() *protoiface.Method
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochInfoRequest)
+		x := input.Message.Interface().(*QueryLiquidityPoolRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58540,10 +58523,10 @@ func (x *fastReflection_QueryEpochInfoRequest) ProtoMethods() *protoiface.Method
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -58582,33 +58565,29 @@ func (x *fastReflection_QueryEpochInfoRequest) ProtoMethods() *protoiface.Method
 }
 
 var (
-	md_QueryEpochInfoResponse                               protoreflect.MessageDescriptor
-	fd_QueryEpochInfoResponse_block_height                  protoreflect.FieldDescriptor
-	fd_QueryEpochInfoResponse_params                        protoreflect.FieldDescriptor
-	fd_QueryEpochInfoResponse_latest_epoch                  protoreflect.FieldDescriptor
-	fd_QueryEpochInfoResponse_is_confirmation_poc_active    protoreflect.FieldDescriptor
-	fd_QueryEpochInfoResponse_active_confirmation_poc_event protoreflect.FieldDescriptor
+	md_QueryLiquidityPoolResponse              protoreflect.MessageDescriptor
+	fd_QueryLiquidityPoolResponse_address      protoreflect.FieldDescriptor
+	fd_QueryLiquidityPoolResponse_codeId       protoreflect.FieldDescriptor
+	fd_QueryLiquidityPoolResponse_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryEpochInfoResponse = File_inference_inference_query_proto.Messages().ByName("QueryEpochInfoResponse")
-	fd_QueryEpochInfoResponse_block_height = md_QueryEpochInfoResponse.Fields().ByName("block_height")
-	fd_QueryEpochInfoResponse_params = md_QueryEpochInfoResponse.Fields().ByName("params")
-	fd_QueryEpochInfoResponse_latest_epoch = md_QueryEpochInfoResponse.Fields().ByName("latest_epoch")
-	fd_QueryEpochInfoResponse_is_confirmation_poc_active = md_QueryEpochInfoResponse.Fields().ByName("is_confirmation_poc_active")
-	fd_QueryEpochInfoResponse_active_confirmation_poc_event = md_QueryEpochInfoResponse.Fields().ByName("active_confirmation_poc_event")
+	md_QueryLiquidityPoolResponse = File_inference_inference_query_proto.Messages().ByName("QueryLiquidityPoolResponse")
+	fd_QueryLiquidityPoolResponse_address = md_QueryLiquidityPoolResponse.Fields().ByName("address")
+	fd_QueryLiquidityPoolResponse_codeId = md_QueryLiquidityPoolResponse.Fields().ByName("codeId")
+	fd_QueryLiquidityPoolResponse_block_height = md_QueryLiquidityPoolResponse.Fields().ByName("block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryEpochInfoResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryLiquidityPoolResponse)(nil)
 
-type fastReflection_QueryEpochInfoResponse QueryEpochInfoResponse
+type fastReflection_QueryLiquidityPoolResponse QueryLiquidityPoolResponse
 
-func (x *QueryEpochInfoResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryEpochInfoResponse)(x)
+func (x *QueryLiquidityPoolResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryLiquidityPoolResponse)(x)
 }
 
-func (x *QueryEpochInfoResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryLiquidityPoolResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[121]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -58620,43 +58599,43 @@ func (x *QueryEpochInfoResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryEpochInfoResponse_messageType fastReflection_QueryEpochInfoResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryEpochInfoResponse_messageType{}
+var _fastReflection_QueryLiquidityPoolResponse_messageType fastReflection_QueryLiquidityPoolResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryLiquidityPoolResponse_messageType{}
 
-type fastReflection_QueryEpochInfoResponse_messageType struct{}
+type fastReflection_QueryLiquidityPoolResponse_messageType struct{}
 
-func (x fastReflection_QueryEpochInfoResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryEpochInfoResponse)(nil)
+func (x fastReflection_QueryLiquidityPoolResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryLiquidityPoolResponse)(nil)
 }
-func (x fastReflection_QueryEpochInfoResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochInfoResponse)
+func (x fastReflection_QueryLiquidityPoolResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryLiquidityPoolResponse)
 }
-func (x fastReflection_QueryEpochInfoResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochInfoResponse
+func (x fastReflection_QueryLiquidityPoolResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryLiquidityPoolResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryEpochInfoResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryEpochInfoResponse
+func (x *fastReflection_QueryLiquidityPoolResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryLiquidityPoolResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryEpochInfoResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryEpochInfoResponse_messageType
+func (x *fastReflection_QueryLiquidityPoolResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryLiquidityPoolResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryEpochInfoResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryEpochInfoResponse)
+func (x *fastReflection_QueryLiquidityPoolResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryLiquidityPoolResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryEpochInfoResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryEpochInfoResponse)(x)
+func (x *fastReflection_QueryLiquidityPoolResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryLiquidityPoolResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -58664,34 +58643,22 @@ func (x *fastReflection_QueryEpochInfoResponse) Interface() protoreflect.ProtoMe
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryEpochInfoResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.BlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.BlockHeight)
-		if !f(fd_QueryEpochInfoResponse_block_height, value) {
-			return
-		}
-	}
-	if x.Params != nil {
-		value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
-		if !f(fd_QueryEpochInfoResponse_params, value) {
-			return
-		}
-	}
-	if x.LatestEpoch != nil {
-		value := protoreflect.ValueOfMessage(x.LatestEpoch.ProtoReflect())
-		if !f(fd_QueryEpochInfoResponse_latest_epoch, value) {
+func (x *fastReflection_QueryLiquidityPoolResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Address != "" {
+		value := protoreflect.ValueOfString(x.Address)
+		if !f(fd_QueryLiquidityPoolResponse_address, value) {
 			return
 		}
 	}
-	if x.IsConfirmationPocActive != false {
-		value := protoreflect.ValueOfBool(x.IsConfirmationPocActive)
-		if !f(fd_QueryEpochInfoResponse_is_confirmation_poc_active, value) {
+	if x.CodeId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.CodeId)
+		if !f(fd_QueryLiquidityPoolResponse_codeId, value) {
 			return
 		}
 	}
-	if x.ActiveConfirmationPocEvent != nil {
-		value := protoreflect.ValueOfMessage(x.ActiveConfirmationPocEvent.ProtoReflect())
-		if !f(fd_QueryEpochInfoResponse_active_confirmation_poc_event, value) {
+	if x.BlockHeight != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.BlockHeight)
+		if !f(fd_QueryLiquidityPoolResponse_block_height, value) {
 			return
 		}
 	}
@@ -58708,23 +58675,19 @@ func (x *fastReflection_QueryEpochInfoResponse) Range(f func(protoreflect.FieldD
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryEpochInfoResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryLiquidityPoolResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochInfoResponse.block_height":
-		return x.BlockHeight != int64(0)
-	case "inference.inference.QueryEpochInfoResponse.params":
-		return x.Params != nil
-	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
-		return x.LatestEpoch != nil
-	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
-		return x.IsConfirmationPocActive != false
-	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
-		return x.ActiveConfirmationPocEvent != nil
+	case "inference.inference.QueryLiquidityPoolResponse.address":
+		return x.Address != ""
+	case "inference.inference.QueryLiquidityPoolResponse.codeId":
+		return x.CodeId != uint64(0)
+	case "inference.inference.QueryLiquidityPoolResponse.block_height":
+		return x.BlockHeight != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -58734,23 +58697,19 @@ func (x *fastReflection_QueryEpochInfoResponse) Has(fd protoreflect.FieldDescrip
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryLiquidityPoolResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochInfoResponse.block_height":
-		x.BlockHeight = int64(0)
-	case "inference.inference.QueryEpochInfoResponse.params":
-		x.Params = nil
-	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
-		x.LatestEpoch = nil
-	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
-		x.IsConfirmationPocActive = false
-	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
-		x.ActiveConfirmationPocEvent = nil
+	case "inference.inference.QueryLiquidityPoolResponse.address":
+		x.Address = ""
+	case "inference.inference.QueryLiquidityPoolResponse.codeId":
+		x.CodeId = uint64(0)
+	case "inference.inference.QueryLiquidityPoolResponse.block_height":
+		x.BlockHeight = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -58760,28 +58719,22 @@ func (x *fastReflection_QueryEpochInfoResponse) Clear(fd protoreflect.FieldDescr
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryEpochInfoResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryLiquidityPoolResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryEpochInfoResponse.block_height":
+	case "inference.inference.QueryLiquidityPoolResponse.address":
+		value := x.Address
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryLiquidityPoolResponse.codeId":
+		value := x.CodeId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryLiquidityPoolResponse.block_height":
 		value := x.BlockHeight
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.QueryEpochInfoResponse.params":
-		value := x.Params
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
-		value := x.LatestEpoch
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
-		value := x.IsConfirmationPocActive
-		return protoreflect.ValueOfBool(value)
-	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
-		value := x.ActiveConfirmationPocEvent
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -58795,23 +58748,19 @@ func (x *fastReflection_QueryEpochInfoResponse) Get(descriptor protoreflect.Fiel
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryLiquidityPoolResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochInfoResponse.block_height":
-		x.BlockHeight = value.Int()
-	case "inference.inference.QueryEpochInfoResponse.params":
-		x.Params = value.Message().Interface().(*Params)
-	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
-		x.LatestEpoch = value.Message().Interface().(*Epoch)
-	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
-		x.IsConfirmationPocActive = value.Bool()
-	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
-		x.ActiveConfirmationPocEvent = value.Message().Interface().(*ConfirmationPoCEvent)
+	case "inference.inference.QueryLiquidityPoolResponse.address":
+		x.Address = value.Interface().(string)
+	case "inference.inference.QueryLiquidityPoolResponse.codeId":
+		x.CodeId = value.Uint()
+	case "inference.inference.QueryLiquidityPoolResponse.block_height":
+		x.BlockHeight = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -58825,68 +58774,48 @@ func (x *fastReflection_QueryEpochInfoResponse) Set(fd protoreflect.FieldDescrip
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryLiquidityPoolResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochInfoResponse.params":
-		if x.Params == nil {
-			x.Params = new(Params)
-		}
-		return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
-		if x.LatestEpoch == nil {
-			x.LatestEpoch = new(Epoch)
-		}
-		return protoreflect.ValueOfMessage(x.LatestEpoch.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
-		if x.ActiveConfirmationPocEvent == nil {
-			x.ActiveConfirmationPocEvent = new(ConfirmationPoCEvent)
-		}
-		return protoreflect.ValueOfMessage(x.ActiveConfirmationPocEvent.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryEpochInfoResponse is not mutable"))
-	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
-		panic(fmt.Errorf("field is_confirmation_poc_active of message inference.inference.QueryEpochInfoResponse is not mutable"))
+	case "inference.inference.QueryLiquidityPoolResponse.address":
+		panic(fmt.Errorf("field address of message inference.inference.QueryLiquidityPoolResponse is not mutable"))
+	case "inference.inference.QueryLiquidityPoolResponse.codeId":
+		panic(fmt.Errorf("field codeId of message inference.inference.QueryLiquidityPoolResponse is not mutable"))
+	case "inference.inference.QueryLiquidityPoolResponse.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryLiquidityPoolResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryEpochInfoResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryLiquidityPoolResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryEpochInfoResponse.block_height":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.QueryEpochInfoResponse.params":
-		m := new(Params)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
-		m := new(Epoch)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
-		return protoreflect.ValueOfBool(false)
-	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
-		m := new(ConfirmationPoCEvent)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryLiquidityPoolResponse.address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryLiquidityPoolResponse.codeId":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryLiquidityPoolResponse.block_height":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryEpochInfoResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryLiquidityPoolResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochInfoResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryLiquidityPoolResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -58894,7 +58823,7 @@ func (x *fastReflection_QueryEpochInfoResponse) WhichOneof(d protoreflect.OneofD
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryEpochInfoResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryLiquidityPoolResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -58905,7 +58834,7 @@ func (x *fastReflection_QueryEpochInfoResponse) GetUnknown() protoreflect.RawFie
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryEpochInfoResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryLiquidityPoolResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -58917,7 +58846,7 @@ func (x *fastReflection_QueryEpochInfoResponse) SetUnknown(fields protoreflect.R
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryEpochInfoResponse) IsValid() bool {
+func (x *fastReflection_QueryLiquidityPoolResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -58927,9 +58856,9 @@ func (x *fastReflection_QueryEpochInfoResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryLiquidityPoolResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryEpochInfoResponse)
+		x := input.Message.Interface().(*QueryLiquidityPoolResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58941,23 +58870,15 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 		var n int
 		var l int
 		_ = l
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
-		}
-		if x.Params != nil {
-			l = options.Size(x.Params)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.LatestEpoch != nil {
-			l = options.Size(x.LatestEpoch)
+		l = len(x.Address)
+		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.IsConfirmationPocActive {
-			n += 2
+		if x.CodeId != 0 {
+			n += 1 + runtime.Sov(uint64(x.CodeId))
 		}
-		if x.ActiveConfirmationPocEvent != nil {
-			l = options.Size(x.ActiveConfirmationPocEvent)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -58969,7 +58890,7 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochInfoResponse)
+		x := input.Message.Interface().(*QueryLiquidityPoolResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -58988,62 +58909,22 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.ActiveConfirmationPocEvent != nil {
-			encoded, err := options.Marshal(x.ActiveConfirmationPocEvent)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if x.IsConfirmationPocActive {
-			i--
-			if x.IsConfirmationPocActive {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
-			}
-			i--
-			dAtA[i] = 0x20
-		}
-		if x.LatestEpoch != nil {
-			encoded, err := options.Marshal(x.LatestEpoch)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0x1a
+			dAtA[i] = 0x18
 		}
-		if x.Params != nil {
-			encoded, err := options.Marshal(x.Params)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.CodeId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CodeId))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
+		if len(x.Address) > 0 {
+			i -= len(x.Address)
+			copy(dAtA[i:], x.Address)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -59056,7 +58937,7 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryEpochInfoResponse)
+		x := input.Message.Interface().(*QueryLiquidityPoolResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -59088,72 +58969,17 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
-				}
-				x.BlockHeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.BlockHeight |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Params == nil {
-					x.Params = &Params{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LatestEpoch", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -59163,33 +58989,29 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.LatestEpoch == nil {
-					x.LatestEpoch = &Epoch{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.LatestEpoch); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.Address = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 4:
+			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IsConfirmationPocActive", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
 				}
-				var v int
+				x.CodeId = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -59199,17 +59021,16 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					x.CodeId |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.IsConfirmationPocActive = bool(v != 0)
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActiveConfirmationPocEvent", wireType)
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				var msglen int
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -59219,28 +59040,11 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.BlockHeight |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.ActiveConfirmationPocEvent == nil {
-					x.ActiveConfirmationPocEvent = &ConfirmationPoCEvent{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ActiveConfirmationPocEvent); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -59277,25 +59081,23 @@ func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Metho
 }
 
 var (
-	md_QueryCountPoCbatchesAtHeightRequest             protoreflect.MessageDescriptor
-	fd_QueryCountPoCbatchesAtHeightRequest_blockHeight protoreflect.FieldDescriptor
+	md_QueryEpochInfoRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCountPoCbatchesAtHeightRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCbatchesAtHeightRequest")
-	fd_QueryCountPoCbatchesAtHeightRequest_blockHeight = md_QueryCountPoCbatchesAtHeightRequest.Fields().ByName("blockHeight")
+	md_QueryEpochInfoRequest = File_inference_inference_query_proto.Messages().ByName("QueryEpochInfoRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryEpochInfoRequest)(nil)
 
-type fastReflection_QueryCountPoCbatchesAtHeightRequest QueryCountPoCbatchesAtHeightRequest
+type fastReflection_QueryEpochInfoRequest QueryEpochInfoRequest
 
-func (x *QueryCountPoCbatchesAtHeightRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(x)
+func (x *QueryEpochInfoRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEpochInfoRequest)(x)
 }
 
-func (x *QueryCountPoCbatchesAtHeightRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryEpochInfoRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[122]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -59307,57 +59109,51 @@ func (x *QueryCountPoCbatchesAtHeightRequest) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType{}
+var _fastReflection_QueryEpochInfoRequest_messageType fastReflection_QueryEpochInfoRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochInfoRequest_messageType{}
 
-type fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType struct{}
+type fastReflection_QueryEpochInfoRequest_messageType struct{}
 
-func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(nil)
+func (x fastReflection_QueryEpochInfoRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEpochInfoRequest)(nil)
 }
-func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCbatchesAtHeightRequest)
+func (x fastReflection_QueryEpochInfoRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochInfoRequest)
 }
-func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCbatchesAtHeightRequest
+func (x fastReflection_QueryEpochInfoRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochInfoRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCbatchesAtHeightRequest
+func (x *fastReflection_QueryEpochInfoRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochInfoRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType
+func (x *fastReflection_QueryEpochInfoRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEpochInfoRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCbatchesAtHeightRequest)
+func (x *fastReflection_QueryEpochInfoRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochInfoRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryCountPoCbatchesAtHeightRequest)(x)
-}
+func (x *fastReflection_QueryEpochInfoRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryEpochInfoRequest)(x)
+}
 
 // Range iterates over every populated field in an undefined order,
 // calling f for each field descriptor and value encountered.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.BlockHeight != int32(0) {
-		value := protoreflect.ValueOfInt32(x.BlockHeight)
-		if !f(fd_QueryCountPoCbatchesAtHeightRequest_blockHeight, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryEpochInfoRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -59371,15 +59167,13 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEpochInfoRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
-		return x.BlockHeight != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -59389,15 +59183,13 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEpochInfoRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
-		x.BlockHeight = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -59407,16 +59199,13 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochInfoRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
-		value := x.BlockHeight
-		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -59430,15 +59219,13 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEpochInfoRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
-		x.BlockHeight = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -59452,40 +59239,36 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochInfoRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
-		panic(fmt.Errorf("field blockHeight of message inference.inference.QueryCountPoCbatchesAtHeightRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochInfoRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
-		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEpochInfoRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCbatchesAtHeightRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochInfoRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -59493,7 +59276,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEpochInfoRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -59504,7 +59287,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEpochInfoRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -59516,7 +59299,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) IsValid() bool {
+func (x *fastReflection_QueryEpochInfoRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -59526,9 +59309,9 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEpochInfoRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
+		x := input.Message.Interface().(*QueryEpochInfoRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -59540,9 +59323,6 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *pro
 		var n int
 		var l int
 		_ = l
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -59553,7 +59333,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
+		x := input.Message.Interface().(*QueryEpochInfoRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -59572,11 +59352,6 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
-			i--
-			dAtA[i] = 0x8
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -59588,7 +59363,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
+		x := input.Message.Interface().(*QueryEpochInfoRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -59620,31 +59395,12 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
-				}
-				x.BlockHeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.BlockHeight |= int32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -59681,25 +59437,33 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *pro
 }
 
 var (
-	md_QueryCountPoCbatchesAtHeightResponse       protoreflect.MessageDescriptor
-	fd_QueryCountPoCbatchesAtHeightResponse_count protoreflect.FieldDescriptor
+	md_QueryEpochInfoResponse                               protoreflect.MessageDescriptor
+	fd_QueryEpochInfoResponse_block_height                  protoreflect.FieldDescriptor
+	fd_QueryEpochInfoResponse_params                        protoreflect.FieldDescriptor
+	fd_QueryEpochInfoResponse_latest_epoch                  protoreflect.FieldDescriptor
+	fd_QueryEpochInfoResponse_is_confirmation_poc_active    protoreflect.FieldDescriptor
+	fd_QueryEpochInfoResponse_active_confirmation_poc_event protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCountPoCbatchesAtHeightResponse = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCbatchesAtHeightResponse")
-	fd_QueryCountPoCbatchesAtHeightResponse_count = md_QueryCountPoCbatchesAtHeightResponse.Fields().ByName("count")
+	md_QueryEpochInfoResponse = File_inference_inference_query_proto.Messages().ByName("QueryEpochInfoResponse")
+	fd_QueryEpochInfoResponse_block_height = md_QueryEpochInfoResponse.Fields().ByName("block_height")
+	fd_QueryEpochInfoResponse_params = md_QueryEpochInfoResponse.Fields().ByName("params")
+	fd_QueryEpochInfoResponse_latest_epoch = md_QueryEpochInfoResponse.Fields().ByName("latest_epoch")
+	fd_QueryEpochInfoResponse_is_confirmation_poc_active = md_QueryEpochInfoResponse.Fields().ByName("is_confirmation_poc_active")
+	fd_QueryEpochInfoResponse_active_confirmation_poc_event = md_QueryEpochInfoResponse.Fields().ByName("active_confirmation_poc_event")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryEpochInfoResponse)(nil)
 
-type fastReflection_QueryCountPoCbatchesAtHeightResponse QueryCountPoCbatchesAtHeightResponse
+type fastReflection_QueryEpochInfoResponse QueryEpochInfoResponse
 
-func (x *QueryCountPoCbatchesAtHeightResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(x)
+func (x *QueryEpochInfoResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryEpochInfoResponse)(x)
 }
 
-func (x *QueryCountPoCbatchesAtHeightResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryEpochInfoResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[123]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -59711,43 +59475,43 @@ func (x *QueryCountPoCbatchesAtHeightResponse) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType{}
+var _fastReflection_QueryEpochInfoResponse_messageType fastReflection_QueryEpochInfoResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryEpochInfoResponse_messageType{}
 
-type fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType struct{}
+type fastReflection_QueryEpochInfoResponse_messageType struct{}
 
-func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(nil)
+func (x fastReflection_QueryEpochInfoResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryEpochInfoResponse)(nil)
 }
-func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCbatchesAtHeightResponse)
+func (x fastReflection_QueryEpochInfoResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochInfoResponse)
 }
-func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCbatchesAtHeightResponse
+func (x fastReflection_QueryEpochInfoResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochInfoResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCbatchesAtHeightResponse
+func (x *fastReflection_QueryEpochInfoResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryEpochInfoResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType
+func (x *fastReflection_QueryEpochInfoResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryEpochInfoResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCbatchesAtHeightResponse)
+func (x *fastReflection_QueryEpochInfoResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryEpochInfoResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryCountPoCbatchesAtHeightResponse)(x)
+func (x *fastReflection_QueryEpochInfoResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryEpochInfoResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -59755,10 +59519,34 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Count != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Count)
-		if !f(fd_QueryCountPoCbatchesAtHeightResponse_count, value) {
+func (x *fastReflection_QueryEpochInfoResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_QueryEpochInfoResponse_block_height, value) {
+			return
+		}
+	}
+	if x.Params != nil {
+		value := protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+		if !f(fd_QueryEpochInfoResponse_params, value) {
+			return
+		}
+	}
+	if x.LatestEpoch != nil {
+		value := protoreflect.ValueOfMessage(x.LatestEpoch.ProtoReflect())
+		if !f(fd_QueryEpochInfoResponse_latest_epoch, value) {
+			return
+		}
+	}
+	if x.IsConfirmationPocActive != false {
+		value := protoreflect.ValueOfBool(x.IsConfirmationPocActive)
+		if !f(fd_QueryEpochInfoResponse_is_confirmation_poc_active, value) {
+			return
+		}
+	}
+	if x.ActiveConfirmationPocEvent != nil {
+		value := protoreflect.ValueOfMessage(x.ActiveConfirmationPocEvent.ProtoReflect())
+		if !f(fd_QueryEpochInfoResponse_active_confirmation_poc_event, value) {
 			return
 		}
 	}
@@ -59775,15 +59563,23 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryEpochInfoResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
-		return x.Count != uint64(0)
+	case "inference.inference.QueryEpochInfoResponse.block_height":
+		return x.BlockHeight != int64(0)
+	case "inference.inference.QueryEpochInfoResponse.params":
+		return x.Params != nil
+	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
+		return x.LatestEpoch != nil
+	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
+		return x.IsConfirmationPocActive != false
+	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
+		return x.ActiveConfirmationPocEvent != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -59793,15 +59589,23 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryEpochInfoResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
-		x.Count = uint64(0)
+	case "inference.inference.QueryEpochInfoResponse.block_height":
+		x.BlockHeight = int64(0)
+	case "inference.inference.QueryEpochInfoResponse.params":
+		x.Params = nil
+	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
+		x.LatestEpoch = nil
+	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
+		x.IsConfirmationPocActive = false
+	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
+		x.ActiveConfirmationPocEvent = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -59811,16 +59615,28 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochInfoResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
-		value := x.Count
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryEpochInfoResponse.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryEpochInfoResponse.params":
+		value := x.Params
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
+		value := x.LatestEpoch
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
+		value := x.IsConfirmationPocActive
+		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
+		value := x.ActiveConfirmationPocEvent
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -59834,15 +59650,23 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryEpochInfoResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
-		x.Count = value.Uint()
+	case "inference.inference.QueryEpochInfoResponse.block_height":
+		x.BlockHeight = value.Int()
+	case "inference.inference.QueryEpochInfoResponse.params":
+		x.Params = value.Message().Interface().(*Params)
+	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
+		x.LatestEpoch = value.Message().Interface().(*Epoch)
+	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
+		x.IsConfirmationPocActive = value.Bool()
+	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
+		x.ActiveConfirmationPocEvent = value.Message().Interface().(*ConfirmationPoCEvent)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -59856,40 +59680,68 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochInfoResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
-		panic(fmt.Errorf("field count of message inference.inference.QueryCountPoCbatchesAtHeightResponse is not mutable"))
+	case "inference.inference.QueryEpochInfoResponse.params":
+		if x.Params == nil {
+			x.Params = new(Params)
+		}
+		return protoreflect.ValueOfMessage(x.Params.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
+		if x.LatestEpoch == nil {
+			x.LatestEpoch = new(Epoch)
+		}
+		return protoreflect.ValueOfMessage(x.LatestEpoch.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
+		if x.ActiveConfirmationPocEvent == nil {
+			x.ActiveConfirmationPocEvent = new(ConfirmationPoCEvent)
+		}
+		return protoreflect.ValueOfMessage(x.ActiveConfirmationPocEvent.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryEpochInfoResponse is not mutable"))
+	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
+		panic(fmt.Errorf("field is_confirmation_poc_active of message inference.inference.QueryEpochInfoResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryEpochInfoResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryEpochInfoResponse.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryEpochInfoResponse.params":
+		m := new(Params)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.latest_epoch":
+		m := new(Epoch)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryEpochInfoResponse.is_confirmation_poc_active":
+		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event":
+		m := new(ConfirmationPoCEvent)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryEpochInfoResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryEpochInfoResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryEpochInfoResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCbatchesAtHeightResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryEpochInfoResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -59897,7 +59749,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryEpochInfoResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -59908,7 +59760,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryEpochInfoResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -59920,7 +59772,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) IsValid() bool {
+func (x *fastReflection_QueryEpochInfoResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -59930,9 +59782,9 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryEpochInfoResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
+		x := input.Message.Interface().(*QueryEpochInfoResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -59944,8 +59796,23 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 		var n int
 		var l int
 		_ = l
-		if x.Count != 0 {
-			n += 1 + runtime.Sov(uint64(x.Count))
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		}
+		if x.Params != nil {
+			l = options.Size(x.Params)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.LatestEpoch != nil {
+			l = options.Size(x.LatestEpoch)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.IsConfirmationPocActive {
+			n += 2
+		}
+		if x.ActiveConfirmationPocEvent != nil {
+			l = options.Size(x.ActiveConfirmationPocEvent)
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -59957,7 +59824,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
+		x := input.Message.Interface().(*QueryEpochInfoResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -59976,8 +59843,60 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Count != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+		if x.ActiveConfirmationPocEvent != nil {
+			encoded, err := options.Marshal(x.ActiveConfirmationPocEvent)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if x.IsConfirmationPocActive {
+			i--
+			if x.IsConfirmationPocActive {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.LatestEpoch != nil {
+			encoded, err := options.Marshal(x.LatestEpoch)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.Params != nil {
+			encoded, err := options.Marshal(x.Params)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
 			dAtA[i] = 0x8
 		}
@@ -59992,7 +59911,7 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
+		x := input.Message.Interface().(*QueryEpochInfoResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60024,17 +59943,17 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryEpochInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				x.Count = 0
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -60044,39 +59963,167 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Count |= uint64(b&0x7F) << shift
+					x.BlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Params == nil {
+					x.Params = &Params{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LatestEpoch", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				if (iNdEx + skippy) > l {
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if !options.DiscardUnknown {
-					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				if x.LatestEpoch == nil {
+					x.LatestEpoch = &Epoch{}
 				}
-				iNdEx += skippy
-			}
-		}
-
-		if iNdEx > l {
-			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-		}
-		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
-	}
-	return &protoiface.Methods{
-		NoUnkeyedLiterals: struct{}{},
-		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
-		Size:              size,
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.LatestEpoch); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IsConfirmationPocActive", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.IsConfirmationPocActive = bool(v != 0)
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActiveConfirmationPocEvent", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.ActiveConfirmationPocEvent == nil {
+					x.ActiveConfirmationPocEvent = &ConfirmationPoCEvent{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ActiveConfirmationPocEvent); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
 		Marshal:           marshal,
 		Unmarshal:         unmarshal,
 		Merge:             nil,
@@ -60085,25 +60132,25 @@ func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *pr
 }
 
 var (
-	md_QueryCountPoCvalidationsAtHeightRequest             protoreflect.MessageDescriptor
-	fd_QueryCountPoCvalidationsAtHeightRequest_blockHeight protoreflect.FieldDescriptor
+	md_QueryCountPoCbatchesAtHeightRequest             protoreflect.MessageDescriptor
+	fd_QueryCountPoCbatchesAtHeightRequest_blockHeight protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCountPoCvalidationsAtHeightRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCvalidationsAtHeightRequest")
-	fd_QueryCountPoCvalidationsAtHeightRequest_blockHeight = md_QueryCountPoCvalidationsAtHeightRequest.Fields().ByName("blockHeight")
+	md_QueryCountPoCbatchesAtHeightRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCbatchesAtHeightRequest")
+	fd_QueryCountPoCbatchesAtHeightRequest_blockHeight = md_QueryCountPoCbatchesAtHeightRequest.Fields().ByName("blockHeight")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(nil)
 
-type fastReflection_QueryCountPoCvalidationsAtHeightRequest QueryCountPoCvalidationsAtHeightRequest
+type fastReflection_QueryCountPoCbatchesAtHeightRequest QueryCountPoCbatchesAtHeightRequest
 
-func (x *QueryCountPoCvalidationsAtHeightRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(x)
+func (x *QueryCountPoCbatchesAtHeightRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(x)
 }
 
-func (x *QueryCountPoCvalidationsAtHeightRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryCountPoCbatchesAtHeightRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[124]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -60115,43 +60162,43 @@ func (x *QueryCountPoCvalidationsAtHeightRequest) slowProtoReflect() protoreflec
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType{}
+var _fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType{}
 
-type fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType struct{}
+type fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType struct{}
 
-func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(nil)
+func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCbatchesAtHeightRequest)(nil)
 }
-func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCvalidationsAtHeightRequest)
+func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCbatchesAtHeightRequest)
 }
-func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCvalidationsAtHeightRequest
+func (x fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCbatchesAtHeightRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCvalidationsAtHeightRequest
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCbatchesAtHeightRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCountPoCbatchesAtHeightRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCvalidationsAtHeightRequest)
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCbatchesAtHeightRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryCountPoCvalidationsAtHeightRequest)(x)
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryCountPoCbatchesAtHeightRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -60159,10 +60206,10 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.BlockHeight != int32(0) {
 		value := protoreflect.ValueOfInt32(x.BlockHeight)
-		if !f(fd_QueryCountPoCvalidationsAtHeightRequest_blockHeight, value) {
+		if !f(fd_QueryCountPoCbatchesAtHeightRequest_blockHeight, value) {
 			return
 		}
 	}
@@ -60179,15 +60226,15 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
 		return x.BlockHeight != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60197,15 +60244,15 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
 		x.BlockHeight = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60215,16 +60262,16 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
 		value := x.BlockHeight
 		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -60238,15 +60285,15 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
 		x.BlockHeight = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60260,40 +60307,40 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
-		panic(fmt.Errorf("field blockHeight of message inference.inference.QueryCountPoCvalidationsAtHeightRequest is not mutable"))
+	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
+		panic(fmt.Errorf("field blockHeight of message inference.inference.QueryCountPoCbatchesAtHeightRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+	case "inference.inference.QueryCountPoCbatchesAtHeightRequest.blockHeight":
 		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCvalidationsAtHeightRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCbatchesAtHeightRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -60301,7 +60348,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -60312,7 +60359,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -60324,7 +60371,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) IsValid() bool {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -60334,9 +60381,9 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
+		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60361,7 +60408,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
+		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60396,7 +60443,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
+		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60428,10 +60475,10 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -60489,25 +60536,25 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods()
 }
 
 var (
-	md_QueryCountPoCvalidationsAtHeightResponse       protoreflect.MessageDescriptor
-	fd_QueryCountPoCvalidationsAtHeightResponse_count protoreflect.FieldDescriptor
+	md_QueryCountPoCbatchesAtHeightResponse       protoreflect.MessageDescriptor
+	fd_QueryCountPoCbatchesAtHeightResponse_count protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryCountPoCvalidationsAtHeightResponse = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCvalidationsAtHeightResponse")
-	fd_QueryCountPoCvalidationsAtHeightResponse_count = md_QueryCountPoCvalidationsAtHeightResponse.Fields().ByName("count")
+	md_QueryCountPoCbatchesAtHeightResponse = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCbatchesAtHeightResponse")
+	fd_QueryCountPoCbatchesAtHeightResponse_count = md_QueryCountPoCbatchesAtHeightResponse.Fields().ByName("count")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(nil)
 
-type fastReflection_QueryCountPoCvalidationsAtHeightResponse QueryCountPoCvalidationsAtHeightResponse
+type fastReflection_QueryCountPoCbatchesAtHeightResponse QueryCountPoCbatchesAtHeightResponse
 
-func (x *QueryCountPoCvalidationsAtHeightResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(x)
+func (x *QueryCountPoCbatchesAtHeightResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(x)
 }
 
-func (x *QueryCountPoCvalidationsAtHeightResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryCountPoCbatchesAtHeightResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[125]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -60519,43 +60566,43 @@ func (x *QueryCountPoCvalidationsAtHeightResponse) slowProtoReflect() protorefle
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType{}
+var _fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType{}
 
-type fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType struct{}
+type fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType struct{}
 
-func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(nil)
+func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCbatchesAtHeightResponse)(nil)
 }
-func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCvalidationsAtHeightResponse)
+func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCbatchesAtHeightResponse)
 }
-func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCvalidationsAtHeightResponse
+func (x fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCbatchesAtHeightResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryCountPoCvalidationsAtHeightResponse
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCbatchesAtHeightResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCountPoCbatchesAtHeightResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryCountPoCvalidationsAtHeightResponse)
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCbatchesAtHeightResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryCountPoCvalidationsAtHeightResponse)(x)
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryCountPoCbatchesAtHeightResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -60563,10 +60610,10 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Interface() pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Count != uint64(0) {
 		value := protoreflect.ValueOfUint64(x.Count)
-		if !f(fd_QueryCountPoCvalidationsAtHeightResponse_count, value) {
+		if !f(fd_QueryCountPoCbatchesAtHeightResponse_count, value) {
 			return
 		}
 	}
@@ -60583,15 +60630,15 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Range(f func(p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
 		return x.Count != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60601,15 +60648,15 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Has(fd protore
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
 		x.Count = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60619,16 +60666,16 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Clear(fd proto
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
 		value := x.Count
 		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -60642,15 +60689,15 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
 		x.Count = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60664,40 +60711,40 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Set(fd protore
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
-		panic(fmt.Errorf("field count of message inference.inference.QueryCountPoCvalidationsAtHeightResponse is not mutable"))
+	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
+		panic(fmt.Errorf("field count of message inference.inference.QueryCountPoCbatchesAtHeightResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+	case "inference.inference.QueryCountPoCbatchesAtHeightResponse.count":
 		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCbatchesAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCbatchesAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCvalidationsAtHeightResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCbatchesAtHeightResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -60705,7 +60752,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) WhichOneof(d p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -60716,7 +60763,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) GetUnknown() p
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -60728,7 +60775,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) SetUnknown(fie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) IsValid() bool {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -60738,9 +60785,9 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCountPoCbatchesAtHeightResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
+		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60765,7 +60812,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
+		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60800,7 +60847,7 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
+		x := input.Message.Interface().(*QueryCountPoCbatchesAtHeightResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -60832,10 +60879,10 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -60893,23 +60940,25 @@ func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods()
 }
 
 var (
-	md_QueryApprovedTokensForTradeRequest protoreflect.MessageDescriptor
+	md_QueryCountPoCvalidationsAtHeightRequest             protoreflect.MessageDescriptor
+	fd_QueryCountPoCvalidationsAtHeightRequest_blockHeight protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryApprovedTokensForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryApprovedTokensForTradeRequest")
+	md_QueryCountPoCvalidationsAtHeightRequest = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCvalidationsAtHeightRequest")
+	fd_QueryCountPoCvalidationsAtHeightRequest_blockHeight = md_QueryCountPoCvalidationsAtHeightRequest.Fields().ByName("blockHeight")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryApprovedTokensForTradeRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(nil)
 
-type fastReflection_QueryApprovedTokensForTradeRequest QueryApprovedTokensForTradeRequest
+type fastReflection_QueryCountPoCvalidationsAtHeightRequest QueryCountPoCvalidationsAtHeightRequest
 
-func (x *QueryApprovedTokensForTradeRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryApprovedTokensForTradeRequest)(x)
+func (x *QueryCountPoCvalidationsAtHeightRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(x)
 }
 
-func (x *QueryApprovedTokensForTradeRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryCountPoCvalidationsAtHeightRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[126]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -60921,43 +60970,43 @@ func (x *QueryApprovedTokensForTradeRequest) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryApprovedTokensForTradeRequest_messageType fastReflection_QueryApprovedTokensForTradeRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryApprovedTokensForTradeRequest_messageType{}
+var _fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType{}
 
-type fastReflection_QueryApprovedTokensForTradeRequest_messageType struct{}
+type fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType struct{}
 
-func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryApprovedTokensForTradeRequest)(nil)
+func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCvalidationsAtHeightRequest)(nil)
 }
-func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryApprovedTokensForTradeRequest)
+func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCvalidationsAtHeightRequest)
 }
-func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryApprovedTokensForTradeRequest
+func (x fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCvalidationsAtHeightRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryApprovedTokensForTradeRequest
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCvalidationsAtHeightRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryApprovedTokensForTradeRequest_messageType
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCountPoCvalidationsAtHeightRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryApprovedTokensForTradeRequest)
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCvalidationsAtHeightRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryApprovedTokensForTradeRequest)(x)
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryCountPoCvalidationsAtHeightRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -60965,7 +61014,13 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.BlockHeight != int32(0) {
+		value := protoreflect.ValueOfInt32(x.BlockHeight)
+		if !f(fd_QueryCountPoCvalidationsAtHeightRequest_blockHeight, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -60979,13 +61034,15 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+		return x.BlockHeight != int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -60995,13 +61052,15 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+		x.BlockHeight = int32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61011,13 +61070,16 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -61031,13 +61093,15 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+		x.BlockHeight = int32(value.Int())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61051,36 +61115,40 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+		panic(fmt.Errorf("field blockHeight of message inference.inference.QueryCountPoCvalidationsAtHeightRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryCountPoCvalidationsAtHeightRequest.blockHeight":
+		return protoreflect.ValueOfInt32(int32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryApprovedTokensForTradeRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCvalidationsAtHeightRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -61088,7 +61156,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -61099,7 +61167,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -61111,7 +61179,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) IsValid() bool {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -61121,9 +61189,9 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
+		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -61135,6 +61203,9 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -61145,7 +61216,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
+		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -61164,6 +61235,11 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
+			i--
+			dAtA[i] = 0x8
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -61175,7 +61251,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
+		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -61207,12 +61283,31 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				}
+				x.BlockHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.BlockHeight |= int32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -61248,77 +61343,26 @@ func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *prot
 	}
 }
 
-var _ protoreflect.List = (*_QueryApprovedTokensForTradeResponse_1_list)(nil)
-
-type _QueryApprovedTokensForTradeResponse_1_list struct {
-	list *[]*BridgeTokenReference
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*BridgeTokenReference)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*BridgeTokenReference)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(BridgeTokenReference)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) NewElement() protoreflect.Value {
-	v := new(BridgeTokenReference)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryApprovedTokensForTradeResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryApprovedTokensForTradeResponse                 protoreflect.MessageDescriptor
-	fd_QueryApprovedTokensForTradeResponse_approved_tokens protoreflect.FieldDescriptor
+	md_QueryCountPoCvalidationsAtHeightResponse       protoreflect.MessageDescriptor
+	fd_QueryCountPoCvalidationsAtHeightResponse_count protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryApprovedTokensForTradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryApprovedTokensForTradeResponse")
-	fd_QueryApprovedTokensForTradeResponse_approved_tokens = md_QueryApprovedTokensForTradeResponse.Fields().ByName("approved_tokens")
+	md_QueryCountPoCvalidationsAtHeightResponse = File_inference_inference_query_proto.Messages().ByName("QueryCountPoCvalidationsAtHeightResponse")
+	fd_QueryCountPoCvalidationsAtHeightResponse_count = md_QueryCountPoCvalidationsAtHeightResponse.Fields().ByName("count")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryApprovedTokensForTradeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(nil)
 
-type fastReflection_QueryApprovedTokensForTradeResponse QueryApprovedTokensForTradeResponse
+type fastReflection_QueryCountPoCvalidationsAtHeightResponse QueryCountPoCvalidationsAtHeightResponse
 
-func (x *QueryApprovedTokensForTradeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryApprovedTokensForTradeResponse)(x)
+func (x *QueryCountPoCvalidationsAtHeightResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(x)
 }
 
-func (x *QueryApprovedTokensForTradeResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryCountPoCvalidationsAtHeightResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[127]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -61330,43 +61374,43 @@ func (x *QueryApprovedTokensForTradeResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryApprovedTokensForTradeResponse_messageType fastReflection_QueryApprovedTokensForTradeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryApprovedTokensForTradeResponse_messageType{}
+var _fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType{}
 
-type fastReflection_QueryApprovedTokensForTradeResponse_messageType struct{}
+type fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType struct{}
 
-func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryApprovedTokensForTradeResponse)(nil)
+func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryCountPoCvalidationsAtHeightResponse)(nil)
 }
-func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryApprovedTokensForTradeResponse)
+func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCvalidationsAtHeightResponse)
 }
-func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryApprovedTokensForTradeResponse
+func (x fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCvalidationsAtHeightResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryApprovedTokensForTradeResponse
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryCountPoCvalidationsAtHeightResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryApprovedTokensForTradeResponse_messageType
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryCountPoCvalidationsAtHeightResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryApprovedTokensForTradeResponse)
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryCountPoCvalidationsAtHeightResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryApprovedTokensForTradeResponse)(x)
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryCountPoCvalidationsAtHeightResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -61374,10 +61418,10 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.ApprovedTokens) != 0 {
-		value := protoreflect.ValueOfList(&_QueryApprovedTokensForTradeResponse_1_list{list: &x.ApprovedTokens})
-		if !f(fd_QueryApprovedTokensForTradeResponse_approved_tokens, value) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Count != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Count)
+		if !f(fd_QueryCountPoCvalidationsAtHeightResponse_count, value) {
 			return
 		}
 	}
@@ -61394,15 +61438,15 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
-		return len(x.ApprovedTokens) != 0
+	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+		return x.Count != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61412,15 +61456,15 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
-		x.ApprovedTokens = nil
+	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+		x.Count = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61430,19 +61474,16 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
-		if len(x.ApprovedTokens) == 0 {
-			return protoreflect.ValueOfList(&_QueryApprovedTokensForTradeResponse_1_list{})
-		}
-		listValue := &_QueryApprovedTokensForTradeResponse_1_list{list: &x.ApprovedTokens}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+		value := x.Count
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -61456,17 +61497,15 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
-		lv := value.List()
-		clv := lv.(*_QueryApprovedTokensForTradeResponse_1_list)
-		x.ApprovedTokens = *clv.list
+	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+		x.Count = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61480,45 +61519,40 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
-		if x.ApprovedTokens == nil {
-			x.ApprovedTokens = []*BridgeTokenReference{}
-		}
-		value := &_QueryApprovedTokensForTradeResponse_1_list{list: &x.ApprovedTokens}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+		panic(fmt.Errorf("field count of message inference.inference.QueryCountPoCvalidationsAtHeightResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
-		list := []*BridgeTokenReference{}
-		return protoreflect.ValueOfList(&_QueryApprovedTokensForTradeResponse_1_list{list: &list})
+	case "inference.inference.QueryCountPoCvalidationsAtHeightResponse.count":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryCountPoCvalidationsAtHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryCountPoCvalidationsAtHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryApprovedTokensForTradeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryCountPoCvalidationsAtHeightResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -61526,7 +61560,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -61537,7 +61571,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -61549,7 +61583,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) IsValid() bool {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -61559,9 +61593,9 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryCountPoCvalidationsAtHeightResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
+		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -61573,11 +61607,8 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 		var n int
 		var l int
 		_ = l
-		if len(x.ApprovedTokens) > 0 {
-			for _, e := range x.ApprovedTokens {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Count != 0 {
+			n += 1 + runtime.Sov(uint64(x.Count))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -61589,7 +61620,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
+		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -61608,21 +61639,10 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ApprovedTokens) > 0 {
-			for iNdEx := len(x.ApprovedTokens) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.ApprovedTokens[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if x.Count != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -61635,7 +61655,7 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
+		x := input.Message.Interface().(*QueryCountPoCvalidationsAtHeightResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -61667,17 +61687,17 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ApprovedTokens", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
 				}
-				var msglen int
+				x.Count = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -61687,26 +61707,11 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Count |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ApprovedTokens = append(x.ApprovedTokens, &BridgeTokenReference{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ApprovedTokens[len(x.ApprovedTokens)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -61743,25 +61748,23 @@ func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *pro
 }
 
 var (
-	md_QueryGetModelPerTokenPriceRequest          protoreflect.MessageDescriptor
-	fd_QueryGetModelPerTokenPriceRequest_model_id protoreflect.FieldDescriptor
+	md_QueryApprovedTokensForTradeRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetModelPerTokenPriceRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetModelPerTokenPriceRequest")
-	fd_QueryGetModelPerTokenPriceRequest_model_id = md_QueryGetModelPerTokenPriceRequest.Fields().ByName("model_id")
+	md_QueryApprovedTokensForTradeRequest = File_inference_inference_query_proto.Messages().ByName("QueryApprovedTokensForTradeRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetModelPerTokenPriceRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryApprovedTokensForTradeRequest)(nil)
 
-type fastReflection_QueryGetModelPerTokenPriceRequest QueryGetModelPerTokenPriceRequest
+type fastReflection_QueryApprovedTokensForTradeRequest QueryApprovedTokensForTradeRequest
 
-func (x *QueryGetModelPerTokenPriceRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetModelPerTokenPriceRequest)(x)
+func (x *QueryApprovedTokensForTradeRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryApprovedTokensForTradeRequest)(x)
 }
 
-func (x *QueryGetModelPerTokenPriceRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryApprovedTokensForTradeRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[128]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -61773,43 +61776,43 @@ func (x *QueryGetModelPerTokenPriceRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetModelPerTokenPriceRequest_messageType fastReflection_QueryGetModelPerTokenPriceRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetModelPerTokenPriceRequest_messageType{}
+var _fastReflection_QueryApprovedTokensForTradeRequest_messageType fastReflection_QueryApprovedTokensForTradeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryApprovedTokensForTradeRequest_messageType{}
 
-type fastReflection_QueryGetModelPerTokenPriceRequest_messageType struct{}
+type fastReflection_QueryApprovedTokensForTradeRequest_messageType struct{}
 
-func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetModelPerTokenPriceRequest)(nil)
+func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryApprovedTokensForTradeRequest)(nil)
 }
-func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelPerTokenPriceRequest)
+func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryApprovedTokensForTradeRequest)
 }
-func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelPerTokenPriceRequest
+func (x fastReflection_QueryApprovedTokensForTradeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryApprovedTokensForTradeRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelPerTokenPriceRequest
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryApprovedTokensForTradeRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetModelPerTokenPriceRequest_messageType
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryApprovedTokensForTradeRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelPerTokenPriceRequest)
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryApprovedTokensForTradeRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetModelPerTokenPriceRequest)(x)
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryApprovedTokensForTradeRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -61817,13 +61820,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_QueryGetModelPerTokenPriceRequest_model_id, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -61837,15 +61834,13 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
-		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61855,15 +61850,13 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
-		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61873,16 +61866,13 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -61896,15 +61886,13 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
-		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -61918,40 +61906,36 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.QueryGetModelPerTokenPriceRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelPerTokenPriceRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryApprovedTokensForTradeRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -61959,7 +61943,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -61970,7 +61954,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -61982,7 +61966,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) IsValid() bool {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -61992,9 +61976,9 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryApprovedTokensForTradeRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
+		x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62006,10 +61990,6 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -62020,7 +62000,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
+		x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62039,13 +62019,6 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -62057,7 +62030,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
+		x := input.Message.Interface().(*QueryApprovedTokensForTradeRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62089,44 +62062,12 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -62162,28 +62103,77 @@ func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *proto
 	}
 }
 
+var _ protoreflect.List = (*_QueryApprovedTokensForTradeResponse_1_list)(nil)
+
+type _QueryApprovedTokensForTradeResponse_1_list struct {
+	list *[]*BridgeTokenReference
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*BridgeTokenReference)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*BridgeTokenReference)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(BridgeTokenReference)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) NewElement() protoreflect.Value {
+	v := new(BridgeTokenReference)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryApprovedTokensForTradeResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetModelPerTokenPriceResponse       protoreflect.MessageDescriptor
-	fd_QueryGetModelPerTokenPriceResponse_price protoreflect.FieldDescriptor
-	fd_QueryGetModelPerTokenPriceResponse_found protoreflect.FieldDescriptor
+	md_QueryApprovedTokensForTradeResponse                 protoreflect.MessageDescriptor
+	fd_QueryApprovedTokensForTradeResponse_approved_tokens protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetModelPerTokenPriceResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetModelPerTokenPriceResponse")
-	fd_QueryGetModelPerTokenPriceResponse_price = md_QueryGetModelPerTokenPriceResponse.Fields().ByName("price")
-	fd_QueryGetModelPerTokenPriceResponse_found = md_QueryGetModelPerTokenPriceResponse.Fields().ByName("found")
+	md_QueryApprovedTokensForTradeResponse = File_inference_inference_query_proto.Messages().ByName("QueryApprovedTokensForTradeResponse")
+	fd_QueryApprovedTokensForTradeResponse_approved_tokens = md_QueryApprovedTokensForTradeResponse.Fields().ByName("approved_tokens")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetModelPerTokenPriceResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryApprovedTokensForTradeResponse)(nil)
 
-type fastReflection_QueryGetModelPerTokenPriceResponse QueryGetModelPerTokenPriceResponse
+type fastReflection_QueryApprovedTokensForTradeResponse QueryApprovedTokensForTradeResponse
 
-func (x *QueryGetModelPerTokenPriceResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetModelPerTokenPriceResponse)(x)
+func (x *QueryApprovedTokensForTradeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryApprovedTokensForTradeResponse)(x)
 }
 
-func (x *QueryGetModelPerTokenPriceResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryApprovedTokensForTradeResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[129]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -62195,43 +62185,43 @@ func (x *QueryGetModelPerTokenPriceResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetModelPerTokenPriceResponse_messageType fastReflection_QueryGetModelPerTokenPriceResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetModelPerTokenPriceResponse_messageType{}
+var _fastReflection_QueryApprovedTokensForTradeResponse_messageType fastReflection_QueryApprovedTokensForTradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryApprovedTokensForTradeResponse_messageType{}
 
-type fastReflection_QueryGetModelPerTokenPriceResponse_messageType struct{}
+type fastReflection_QueryApprovedTokensForTradeResponse_messageType struct{}
 
-func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetModelPerTokenPriceResponse)(nil)
+func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryApprovedTokensForTradeResponse)(nil)
 }
-func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelPerTokenPriceResponse)
+func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryApprovedTokensForTradeResponse)
 }
-func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelPerTokenPriceResponse
+func (x fastReflection_QueryApprovedTokensForTradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryApprovedTokensForTradeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelPerTokenPriceResponse
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryApprovedTokensForTradeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetModelPerTokenPriceResponse_messageType
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryApprovedTokensForTradeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelPerTokenPriceResponse)
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryApprovedTokensForTradeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetModelPerTokenPriceResponse)(x)
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryApprovedTokensForTradeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -62239,16 +62229,10 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Price != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Price)
-		if !f(fd_QueryGetModelPerTokenPriceResponse_price, value) {
-			return
-		}
-	}
-	if x.Found != false {
-		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryGetModelPerTokenPriceResponse_found, value) {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.ApprovedTokens) != 0 {
+		value := protoreflect.ValueOfList(&_QueryApprovedTokensForTradeResponse_1_list{list: &x.ApprovedTokens})
+		if !f(fd_QueryApprovedTokensForTradeResponse_approved_tokens, value) {
 			return
 		}
 	}
@@ -62265,17 +62249,15 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
-		return x.Price != uint64(0)
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
-		return x.Found != false
+	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
+		return len(x.ApprovedTokens) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -62285,17 +62267,15 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
-		x.Price = uint64(0)
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
-		x.Found = false
+	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
+		x.ApprovedTokens = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -62305,19 +62285,19 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
-		value := x.Price
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
-		value := x.Found
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
+		if len(x.ApprovedTokens) == 0 {
+			return protoreflect.ValueOfList(&_QueryApprovedTokensForTradeResponse_1_list{})
+		}
+		listValue := &_QueryApprovedTokensForTradeResponse_1_list{list: &x.ApprovedTokens}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -62331,17 +62311,17 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
-		x.Price = value.Uint()
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
-		x.Found = value.Bool()
+	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
+		lv := value.List()
+		clv := lv.(*_QueryApprovedTokensForTradeResponse_1_list)
+		x.ApprovedTokens = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -62355,44 +62335,45 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
-		panic(fmt.Errorf("field price of message inference.inference.QueryGetModelPerTokenPriceResponse is not mutable"))
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryGetModelPerTokenPriceResponse is not mutable"))
+	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
+		if x.ApprovedTokens == nil {
+			x.ApprovedTokens = []*BridgeTokenReference{}
+		}
+		value := &_QueryApprovedTokensForTradeResponse_1_list{list: &x.ApprovedTokens}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens":
+		list := []*BridgeTokenReference{}
+		return protoreflect.ValueOfList(&_QueryApprovedTokensForTradeResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryApprovedTokensForTradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryApprovedTokensForTradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelPerTokenPriceResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryApprovedTokensForTradeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -62400,7 +62381,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -62411,7 +62392,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -62423,7 +62404,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) IsValid() bool {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -62433,9 +62414,9 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryApprovedTokensForTradeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
+		x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62447,11 +62428,11 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if x.Price != 0 {
-			n += 1 + runtime.Sov(uint64(x.Price))
-		}
-		if x.Found {
-			n += 2
+		if len(x.ApprovedTokens) > 0 {
+			for _, e := range x.ApprovedTokens {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -62463,7 +62444,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
+		x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62482,20 +62463,21 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Found {
-			i--
-			if x.Found {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
+		if len(x.ApprovedTokens) > 0 {
+			for iNdEx := len(x.ApprovedTokens) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.ApprovedTokens[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
 			}
-			i--
-			dAtA[i] = 0x10
-		}
-		if x.Price != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
-			i--
-			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -62508,7 +62490,7 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
+		x := input.Message.Interface().(*QueryApprovedTokensForTradeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62540,17 +62522,17 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ApprovedTokens", wireType)
 				}
-				x.Price = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -62560,31 +62542,26 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Price |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				var v int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				x.Found = bool(v != 0)
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ApprovedTokens = append(x.ApprovedTokens, &BridgeTokenReference{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ApprovedTokens[len(x.ApprovedTokens)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -62621,23 +62598,25 @@ func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *prot
 }
 
 var (
-	md_QueryGetAllModelPerTokenPricesRequest protoreflect.MessageDescriptor
+	md_QueryGetModelPerTokenPriceRequest          protoreflect.MessageDescriptor
+	fd_QueryGetModelPerTokenPriceRequest_model_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetAllModelPerTokenPricesRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelPerTokenPricesRequest")
+	md_QueryGetModelPerTokenPriceRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetModelPerTokenPriceRequest")
+	fd_QueryGetModelPerTokenPriceRequest_model_id = md_QueryGetModelPerTokenPriceRequest.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetModelPerTokenPriceRequest)(nil)
 
-type fastReflection_QueryGetAllModelPerTokenPricesRequest QueryGetAllModelPerTokenPricesRequest
+type fastReflection_QueryGetModelPerTokenPriceRequest QueryGetModelPerTokenPriceRequest
 
-func (x *QueryGetAllModelPerTokenPricesRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(x)
+func (x *QueryGetModelPerTokenPriceRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetModelPerTokenPriceRequest)(x)
 }
 
-func (x *QueryGetAllModelPerTokenPricesRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetModelPerTokenPriceRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[130]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -62649,43 +62628,43 @@ func (x *QueryGetAllModelPerTokenPricesRequest) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType{}
+var _fastReflection_QueryGetModelPerTokenPriceRequest_messageType fastReflection_QueryGetModelPerTokenPriceRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelPerTokenPriceRequest_messageType{}
 
-type fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType struct{}
+type fastReflection_QueryGetModelPerTokenPriceRequest_messageType struct{}
 
-func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(nil)
+func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetModelPerTokenPriceRequest)(nil)
 }
-func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelPerTokenPricesRequest)
+func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelPerTokenPriceRequest)
 }
-func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelPerTokenPricesRequest
+func (x fastReflection_QueryGetModelPerTokenPriceRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelPerTokenPriceRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelPerTokenPricesRequest
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelPerTokenPriceRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetModelPerTokenPriceRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelPerTokenPricesRequest)
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelPerTokenPriceRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetAllModelPerTokenPricesRequest)(x)
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetModelPerTokenPriceRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -62693,7 +62672,13 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_QueryGetModelPerTokenPriceRequest_model_id, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -62707,13 +62692,15 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -62723,13 +62710,15 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -62739,13 +62728,16 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -62759,13 +62751,15 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -62779,36 +62773,40 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.QueryGetModelPerTokenPriceRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelPerTokenPriceRequest.model_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelPerTokenPricesRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelPerTokenPriceRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -62816,7 +62814,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -62827,7 +62825,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -62839,7 +62837,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) IsValid() bool {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -62849,9 +62847,9 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetModelPerTokenPriceRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
+		x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62863,6 +62861,10 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -62873,7 +62875,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
+		x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62892,6 +62894,13 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -62903,7 +62912,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
+		x := input.Message.Interface().(*QueryGetModelPerTokenPriceRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -62935,12 +62944,44 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -62977,27 +63018,27 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *p
 }
 
 var (
-	md_ModelPrice          protoreflect.MessageDescriptor
-	fd_ModelPrice_model_id protoreflect.FieldDescriptor
-	fd_ModelPrice_price    protoreflect.FieldDescriptor
+	md_QueryGetModelPerTokenPriceResponse       protoreflect.MessageDescriptor
+	fd_QueryGetModelPerTokenPriceResponse_price protoreflect.FieldDescriptor
+	fd_QueryGetModelPerTokenPriceResponse_found protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ModelPrice = File_inference_inference_query_proto.Messages().ByName("ModelPrice")
-	fd_ModelPrice_model_id = md_ModelPrice.Fields().ByName("model_id")
-	fd_ModelPrice_price = md_ModelPrice.Fields().ByName("price")
+	md_QueryGetModelPerTokenPriceResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetModelPerTokenPriceResponse")
+	fd_QueryGetModelPerTokenPriceResponse_price = md_QueryGetModelPerTokenPriceResponse.Fields().ByName("price")
+	fd_QueryGetModelPerTokenPriceResponse_found = md_QueryGetModelPerTokenPriceResponse.Fields().ByName("found")
 }
 
-var _ protoreflect.Message = (*fastReflection_ModelPrice)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetModelPerTokenPriceResponse)(nil)
 
-type fastReflection_ModelPrice ModelPrice
+type fastReflection_QueryGetModelPerTokenPriceResponse QueryGetModelPerTokenPriceResponse
 
-func (x *ModelPrice) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ModelPrice)(x)
+func (x *QueryGetModelPerTokenPriceResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetModelPerTokenPriceResponse)(x)
 }
 
-func (x *ModelPrice) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetModelPerTokenPriceResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[131]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -63009,43 +63050,43 @@ func (x *ModelPrice) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ModelPrice_messageType fastReflection_ModelPrice_messageType
-var _ protoreflect.MessageType = fastReflection_ModelPrice_messageType{}
+var _fastReflection_QueryGetModelPerTokenPriceResponse_messageType fastReflection_QueryGetModelPerTokenPriceResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelPerTokenPriceResponse_messageType{}
 
-type fastReflection_ModelPrice_messageType struct{}
+type fastReflection_QueryGetModelPerTokenPriceResponse_messageType struct{}
 
-func (x fastReflection_ModelPrice_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ModelPrice)(nil)
+func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetModelPerTokenPriceResponse)(nil)
 }
-func (x fastReflection_ModelPrice_messageType) New() protoreflect.Message {
-	return new(fastReflection_ModelPrice)
+func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelPerTokenPriceResponse)
 }
-func (x fastReflection_ModelPrice_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ModelPrice
+func (x fastReflection_QueryGetModelPerTokenPriceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelPerTokenPriceResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ModelPrice) Descriptor() protoreflect.MessageDescriptor {
-	return md_ModelPrice
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelPerTokenPriceResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ModelPrice) Type() protoreflect.MessageType {
-	return _fastReflection_ModelPrice_messageType
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetModelPerTokenPriceResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ModelPrice) New() protoreflect.Message {
-	return new(fastReflection_ModelPrice)
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelPerTokenPriceResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ModelPrice) Interface() protoreflect.ProtoMessage {
-	return (*ModelPrice)(x)
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetModelPerTokenPriceResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -63053,16 +63094,16 @@ func (x *fastReflection_ModelPrice) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ModelPrice) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_ModelPrice_model_id, value) {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Price != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Price)
+		if !f(fd_QueryGetModelPerTokenPriceResponse_price, value) {
 			return
 		}
 	}
-	if x.Price != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Price)
-		if !f(fd_ModelPrice_price, value) {
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryGetModelPerTokenPriceResponse_found, value) {
 			return
 		}
 	}
@@ -63079,17 +63120,17 @@ func (x *fastReflection_ModelPrice) Range(f func(protoreflect.FieldDescriptor, p
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ModelPrice) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ModelPrice.model_id":
-		return x.ModelId != ""
-	case "inference.inference.ModelPrice.price":
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
 		return x.Price != uint64(0)
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
+		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -63099,17 +63140,17 @@ func (x *fastReflection_ModelPrice) Has(fd protoreflect.FieldDescriptor) bool {
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelPrice) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ModelPrice.model_id":
-		x.ModelId = ""
-	case "inference.inference.ModelPrice.price":
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
 		x.Price = uint64(0)
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
+		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -63119,19 +63160,19 @@ func (x *fastReflection_ModelPrice) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ModelPrice) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ModelPrice.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.ModelPrice.price":
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
 		value := x.Price
 		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -63145,17 +63186,17 @@ func (x *fastReflection_ModelPrice) Get(descriptor protoreflect.FieldDescriptor)
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelPrice) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ModelPrice.model_id":
-		x.ModelId = value.Interface().(string)
-	case "inference.inference.ModelPrice.price":
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
 		x.Price = value.Uint()
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
+		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -63169,44 +63210,44 @@ func (x *fastReflection_ModelPrice) Set(fd protoreflect.FieldDescriptor, value p
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelPrice) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ModelPrice.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.ModelPrice is not mutable"))
-	case "inference.inference.ModelPrice.price":
-		panic(fmt.Errorf("field price of message inference.inference.ModelPrice is not mutable"))
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
+		panic(fmt.Errorf("field price of message inference.inference.QueryGetModelPerTokenPriceResponse is not mutable"))
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryGetModelPerTokenPriceResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ModelPrice) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ModelPrice.model_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.ModelPrice.price":
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.price":
 		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetModelPerTokenPriceResponse.found":
+		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelPerTokenPriceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelPerTokenPriceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ModelPrice) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelPrice", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelPerTokenPriceResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -63214,7 +63255,7 @@ func (x *fastReflection_ModelPrice) WhichOneof(d protoreflect.OneofDescriptor) p
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ModelPrice) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -63225,7 +63266,7 @@ func (x *fastReflection_ModelPrice) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelPrice) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -63237,7 +63278,7 @@ func (x *fastReflection_ModelPrice) SetUnknown(fields protoreflect.RawFields) {
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ModelPrice) IsValid() bool {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -63247,9 +63288,9 @@ func (x *fastReflection_ModelPrice) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetModelPerTokenPriceResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ModelPrice)
+		x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -63261,13 +63302,12 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.Price != 0 {
 			n += 1 + runtime.Sov(uint64(x.Price))
 		}
+		if x.Found {
+			n += 2
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -63278,7 +63318,7 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ModelPrice)
+		x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -63297,17 +63337,20 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Price != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
 			i--
 			dAtA[i] = 0x10
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+		if x.Price != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -63320,7 +63363,7 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ModelPrice)
+		x := input.Message.Interface().(*QueryGetModelPerTokenPriceResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -63352,17 +63395,17 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelPrice: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelPrice: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
 				}
-				var stringLen uint64
+				x.Price = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -63372,29 +63415,16 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.Price |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 				}
-				x.Price = 0
+				var v int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -63404,11 +63434,12 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Price |= uint64(b&0x7F) << shift
+					v |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				x.Found = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -63444,77 +63475,24 @@ func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 	}
 }
 
-var _ protoreflect.List = (*_QueryGetAllModelPerTokenPricesResponse_1_list)(nil)
-
-type _QueryGetAllModelPerTokenPricesResponse_1_list struct {
-	list *[]*ModelPrice
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ModelPrice)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ModelPrice)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ModelPrice)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ModelPrice)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryGetAllModelPerTokenPricesResponse              protoreflect.MessageDescriptor
-	fd_QueryGetAllModelPerTokenPricesResponse_model_prices protoreflect.FieldDescriptor
+	md_QueryGetAllModelPerTokenPricesRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetAllModelPerTokenPricesResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelPerTokenPricesResponse")
-	fd_QueryGetAllModelPerTokenPricesResponse_model_prices = md_QueryGetAllModelPerTokenPricesResponse.Fields().ByName("model_prices")
+	md_QueryGetAllModelPerTokenPricesRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelPerTokenPricesRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetAllModelPerTokenPricesResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(nil)
 
-type fastReflection_QueryGetAllModelPerTokenPricesResponse QueryGetAllModelPerTokenPricesResponse
+type fastReflection_QueryGetAllModelPerTokenPricesRequest QueryGetAllModelPerTokenPricesRequest
 
-func (x *QueryGetAllModelPerTokenPricesResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelPerTokenPricesResponse)(x)
+func (x *QueryGetAllModelPerTokenPricesRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(x)
 }
 
-func (x *QueryGetAllModelPerTokenPricesResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetAllModelPerTokenPricesRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[132]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -63526,43 +63504,43 @@ func (x *QueryGetAllModelPerTokenPricesResponse) slowProtoReflect() protoreflect
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType{}
+var _fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType{}
 
-type fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType struct{}
+type fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType struct{}
 
-func (x fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelPerTokenPricesResponse)(nil)
+func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelPerTokenPricesRequest)(nil)
 }
-func (x fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelPerTokenPricesResponse)
+func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelPerTokenPricesRequest)
 }
-func (x fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelPerTokenPricesResponse
+func (x fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelPerTokenPricesRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelPerTokenPricesResponse
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelPerTokenPricesRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetAllModelPerTokenPricesRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelPerTokenPricesResponse)
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelPerTokenPricesRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetAllModelPerTokenPricesResponse)(x)
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetAllModelPerTokenPricesRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -63570,13 +63548,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Interface() prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.ModelPrices) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetAllModelPerTokenPricesResponse_1_list{list: &x.ModelPrices})
-		if !f(fd_QueryGetAllModelPerTokenPricesResponse_model_prices, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -63590,15 +63562,13 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Range(f func(pro
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
-		return len(x.ModelPrices) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -63608,15 +63578,13 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Has(fd protorefl
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
-		x.ModelPrices = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -63626,19 +63594,13 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Clear(fd protore
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
-		if len(x.ModelPrices) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetAllModelPerTokenPricesResponse_1_list{})
-		}
-		listValue := &_QueryGetAllModelPerTokenPricesResponse_1_list{list: &x.ModelPrices}
-		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -63652,17 +63614,13 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Get(descriptor p
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
-		lv := value.List()
-		clv := lv.(*_QueryGetAllModelPerTokenPricesResponse_1_list)
-		x.ModelPrices = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -63676,45 +63634,36 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Set(fd protorefl
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
-		if x.ModelPrices == nil {
-			x.ModelPrices = []*ModelPrice{}
-		}
-		value := &_QueryGetAllModelPerTokenPricesResponse_1_list{list: &x.ModelPrices}
-		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
-		list := []*ModelPrice{}
-		return protoreflect.ValueOfList(&_QueryGetAllModelPerTokenPricesResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelPerTokenPricesResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelPerTokenPricesRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -63722,7 +63671,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) WhichOneof(d pro
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -63733,7 +63682,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) GetUnknown() pro
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -63745,7 +63694,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) SetUnknown(field
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) IsValid() bool {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -63755,9 +63704,9 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
+		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -63769,12 +63718,6 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *
 		var n int
 		var l int
 		_ = l
-		if len(x.ModelPrices) > 0 {
-			for _, e := range x.ModelPrices {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -63785,7 +63728,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
+		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -63804,22 +63747,6 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelPrices) > 0 {
-			for iNdEx := len(x.ModelPrices) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.ModelPrices[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -63831,7 +63758,7 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
+		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -63863,46 +63790,12 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelPrices", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelPrices = append(x.ModelPrices, &ModelPrice{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ModelPrices[len(x.ModelPrices)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -63939,25 +63832,27 @@ func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *
 }
 
 var (
-	md_QueryGetModelCapacityRequest          protoreflect.MessageDescriptor
-	fd_QueryGetModelCapacityRequest_model_id protoreflect.FieldDescriptor
+	md_ModelPrice          protoreflect.MessageDescriptor
+	fd_ModelPrice_model_id protoreflect.FieldDescriptor
+	fd_ModelPrice_price    protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetModelCapacityRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetModelCapacityRequest")
-	fd_QueryGetModelCapacityRequest_model_id = md_QueryGetModelCapacityRequest.Fields().ByName("model_id")
+	md_ModelPrice = File_inference_inference_query_proto.Messages().ByName("ModelPrice")
+	fd_ModelPrice_model_id = md_ModelPrice.Fields().ByName("model_id")
+	fd_ModelPrice_price = md_ModelPrice.Fields().ByName("price")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetModelCapacityRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_ModelPrice)(nil)
 
-type fastReflection_QueryGetModelCapacityRequest QueryGetModelCapacityRequest
+type fastReflection_ModelPrice ModelPrice
 
-func (x *QueryGetModelCapacityRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetModelCapacityRequest)(x)
+func (x *ModelPrice) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ModelPrice)(x)
 }
 
-func (x *QueryGetModelCapacityRequest) slowProtoReflect() protoreflect.Message {
+func (x *ModelPrice) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[133]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -63969,43 +63864,43 @@ func (x *QueryGetModelCapacityRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetModelCapacityRequest_messageType fastReflection_QueryGetModelCapacityRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetModelCapacityRequest_messageType{}
+var _fastReflection_ModelPrice_messageType fastReflection_ModelPrice_messageType
+var _ protoreflect.MessageType = fastReflection_ModelPrice_messageType{}
 
-type fastReflection_QueryGetModelCapacityRequest_messageType struct{}
+type fastReflection_ModelPrice_messageType struct{}
 
-func (x fastReflection_QueryGetModelCapacityRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetModelCapacityRequest)(nil)
+func (x fastReflection_ModelPrice_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ModelPrice)(nil)
 }
-func (x fastReflection_QueryGetModelCapacityRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelCapacityRequest)
+func (x fastReflection_ModelPrice_messageType) New() protoreflect.Message {
+	return new(fastReflection_ModelPrice)
 }
-func (x fastReflection_QueryGetModelCapacityRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelCapacityRequest
+func (x fastReflection_ModelPrice_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ModelPrice
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetModelCapacityRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelCapacityRequest
+func (x *fastReflection_ModelPrice) Descriptor() protoreflect.MessageDescriptor {
+	return md_ModelPrice
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetModelCapacityRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetModelCapacityRequest_messageType
+func (x *fastReflection_ModelPrice) Type() protoreflect.MessageType {
+	return _fastReflection_ModelPrice_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetModelCapacityRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelCapacityRequest)
+func (x *fastReflection_ModelPrice) New() protoreflect.Message {
+	return new(fastReflection_ModelPrice)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetModelCapacityRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetModelCapacityRequest)(x)
+func (x *fastReflection_ModelPrice) Interface() protoreflect.ProtoMessage {
+	return (*ModelPrice)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -64013,10 +63908,16 @@ func (x *fastReflection_QueryGetModelCapacityRequest) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetModelCapacityRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_ModelPrice) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.ModelId != "" {
 		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_QueryGetModelCapacityRequest_model_id, value) {
+		if !f(fd_ModelPrice_model_id, value) {
+			return
+		}
+	}
+	if x.Price != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Price)
+		if !f(fd_ModelPrice_price, value) {
 			return
 		}
 	}
@@ -64033,15 +63934,17 @@ func (x *fastReflection_QueryGetModelCapacityRequest) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetModelCapacityRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ModelPrice) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+	case "inference.inference.ModelPrice.model_id":
 		return x.ModelId != ""
+	case "inference.inference.ModelPrice.price":
+		return x.Price != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64051,15 +63954,17 @@ func (x *fastReflection_QueryGetModelCapacityRequest) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ModelPrice) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+	case "inference.inference.ModelPrice.model_id":
 		x.ModelId = ""
+	case "inference.inference.ModelPrice.price":
+		x.Price = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64069,16 +63974,19 @@ func (x *fastReflection_QueryGetModelCapacityRequest) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetModelCapacityRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelPrice) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+	case "inference.inference.ModelPrice.model_id":
 		value := x.ModelId
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.ModelPrice.price":
+		value := x.Price
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -64092,15 +64000,17 @@ func (x *fastReflection_QueryGetModelCapacityRequest) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ModelPrice) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+	case "inference.inference.ModelPrice.model_id":
 		x.ModelId = value.Interface().(string)
+	case "inference.inference.ModelPrice.price":
+		x.Price = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64114,40 +64024,44 @@ func (x *fastReflection_QueryGetModelCapacityRequest) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelPrice) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityRequest.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.QueryGetModelCapacityRequest is not mutable"))
+	case "inference.inference.ModelPrice.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.ModelPrice is not mutable"))
+	case "inference.inference.ModelPrice.price":
+		panic(fmt.Errorf("field price of message inference.inference.ModelPrice is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetModelCapacityRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelPrice) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+	case "inference.inference.ModelPrice.model_id":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.ModelPrice.price":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelPrice"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelPrice does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetModelCapacityRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ModelPrice) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelCapacityRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelPrice", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -64155,7 +64069,7 @@ func (x *fastReflection_QueryGetModelCapacityRequest) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetModelCapacityRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ModelPrice) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -64166,7 +64080,7 @@ func (x *fastReflection_QueryGetModelCapacityRequest) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ModelPrice) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -64178,7 +64092,7 @@ func (x *fastReflection_QueryGetModelCapacityRequest) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetModelCapacityRequest) IsValid() bool {
+func (x *fastReflection_ModelPrice) IsValid() bool {
 	return x != nil
 }
 
@@ -64188,9 +64102,9 @@ func (x *fastReflection_QueryGetModelCapacityRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ModelPrice) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetModelCapacityRequest)
+		x := input.Message.Interface().(*ModelPrice)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -64206,6 +64120,9 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		if x.Price != 0 {
+			n += 1 + runtime.Sov(uint64(x.Price))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -64216,7 +64133,7 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelCapacityRequest)
+		x := input.Message.Interface().(*ModelPrice)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -64235,6 +64152,11 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.Price != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
+			i--
+			dAtA[i] = 0x10
+		}
 		if len(x.ModelId) > 0 {
 			i -= len(x.ModelId)
 			copy(dAtA[i:], x.ModelId)
@@ -64253,7 +64175,7 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelCapacityRequest)
+		x := input.Message.Interface().(*ModelPrice)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -64285,10 +64207,10 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelPrice: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelPrice: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -64323,6 +64245,25 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 				}
 				x.ModelId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+				}
+				x.Price = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Price |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -64358,76 +64299,125 @@ func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface
 	}
 }
 
-var (
-	md_QueryGetModelCapacityResponse          protoreflect.MessageDescriptor
-	fd_QueryGetModelCapacityResponse_capacity protoreflect.FieldDescriptor
-	fd_QueryGetModelCapacityResponse_found    protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_QueryGetAllModelPerTokenPricesResponse_1_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryGetModelCapacityResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetModelCapacityResponse")
-	fd_QueryGetModelCapacityResponse_capacity = md_QueryGetModelCapacityResponse.Fields().ByName("capacity")
-	fd_QueryGetModelCapacityResponse_found = md_QueryGetModelCapacityResponse.Fields().ByName("found")
+type _QueryGetAllModelPerTokenPricesResponse_1_list struct {
+	list *[]*ModelPrice
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetModelCapacityResponse)(nil)
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-type fastReflection_QueryGetModelCapacityResponse QueryGetModelCapacityResponse
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
 
-func (x *QueryGetModelCapacityResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetModelCapacityResponse)(x)
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ModelPrice)
+	(*x.list)[i] = concreteValue
 }
 
-func (x *QueryGetModelCapacityResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[134]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ModelPrice)
+	*x.list = append(*x.list, concreteValue)
 }
 
-var _fastReflection_QueryGetModelCapacityResponse_messageType fastReflection_QueryGetModelCapacityResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetModelCapacityResponse_messageType{}
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ModelPrice)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
 
-type fastReflection_QueryGetModelCapacityResponse_messageType struct{}
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
 
-func (x fastReflection_QueryGetModelCapacityResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetModelCapacityResponse)(nil)
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ModelPrice)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
-func (x fastReflection_QueryGetModelCapacityResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelCapacityResponse)
+
+func (x *_QueryGetAllModelPerTokenPricesResponse_1_list) IsValid() bool {
+	return x.list != nil
 }
-func (x fastReflection_QueryGetModelCapacityResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelCapacityResponse
+
+var (
+	md_QueryGetAllModelPerTokenPricesResponse              protoreflect.MessageDescriptor
+	fd_QueryGetAllModelPerTokenPricesResponse_model_prices protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetAllModelPerTokenPricesResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelPerTokenPricesResponse")
+	fd_QueryGetAllModelPerTokenPricesResponse_model_prices = md_QueryGetAllModelPerTokenPricesResponse.Fields().ByName("model_prices")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetAllModelPerTokenPricesResponse)(nil)
+
+type fastReflection_QueryGetAllModelPerTokenPricesResponse QueryGetAllModelPerTokenPricesResponse
+
+func (x *QueryGetAllModelPerTokenPricesResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelPerTokenPricesResponse)(x)
+}
+
+func (x *QueryGetAllModelPerTokenPricesResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[134]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType{}
+
+type fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType struct{}
+
+func (x fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelPerTokenPricesResponse)(nil)
+}
+func (x fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelPerTokenPricesResponse)
+}
+func (x fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelPerTokenPricesResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetModelCapacityResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetModelCapacityResponse
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelPerTokenPricesResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetModelCapacityResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetModelCapacityResponse_messageType
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetAllModelPerTokenPricesResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetModelCapacityResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetModelCapacityResponse)
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelPerTokenPricesResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetModelCapacityResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetModelCapacityResponse)(x)
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetAllModelPerTokenPricesResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -64435,16 +64425,10 @@ func (x *fastReflection_QueryGetModelCapacityResponse) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetModelCapacityResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Capacity != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Capacity)
-		if !f(fd_QueryGetModelCapacityResponse_capacity, value) {
-			return
-		}
-	}
-	if x.Found != false {
-		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryGetModelCapacityResponse_found, value) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.ModelPrices) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGetAllModelPerTokenPricesResponse_1_list{list: &x.ModelPrices})
+		if !f(fd_QueryGetAllModelPerTokenPricesResponse_model_prices, value) {
 			return
 		}
 	}
@@ -64461,17 +64445,15 @@ func (x *fastReflection_QueryGetModelCapacityResponse) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetModelCapacityResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityResponse.capacity":
-		return x.Capacity != uint64(0)
-	case "inference.inference.QueryGetModelCapacityResponse.found":
-		return x.Found != false
+	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
+		return len(x.ModelPrices) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64481,17 +64463,15 @@ func (x *fastReflection_QueryGetModelCapacityResponse) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityResponse.capacity":
-		x.Capacity = uint64(0)
-	case "inference.inference.QueryGetModelCapacityResponse.found":
-		x.Found = false
+	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
+		x.ModelPrices = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64501,19 +64481,19 @@ func (x *fastReflection_QueryGetModelCapacityResponse) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetModelCapacityResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetModelCapacityResponse.capacity":
-		value := x.Capacity
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetModelCapacityResponse.found":
-		value := x.Found
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
+		if len(x.ModelPrices) == 0 {
+			return protoreflect.ValueOfList(&_QueryGetAllModelPerTokenPricesResponse_1_list{})
+		}
+		listValue := &_QueryGetAllModelPerTokenPricesResponse_1_list{list: &x.ModelPrices}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -64527,17 +64507,17 @@ func (x *fastReflection_QueryGetModelCapacityResponse) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityResponse.capacity":
-		x.Capacity = value.Uint()
-	case "inference.inference.QueryGetModelCapacityResponse.found":
-		x.Found = value.Bool()
+	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
+		lv := value.List()
+		clv := lv.(*_QueryGetAllModelPerTokenPricesResponse_1_list)
+		x.ModelPrices = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64551,44 +64531,45 @@ func (x *fastReflection_QueryGetModelCapacityResponse) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityResponse.capacity":
-		panic(fmt.Errorf("field capacity of message inference.inference.QueryGetModelCapacityResponse is not mutable"))
-	case "inference.inference.QueryGetModelCapacityResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryGetModelCapacityResponse is not mutable"))
+	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
+		if x.ModelPrices == nil {
+			x.ModelPrices = []*ModelPrice{}
+		}
+		value := &_QueryGetAllModelPerTokenPricesResponse_1_list{list: &x.ModelPrices}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetModelCapacityResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetModelCapacityResponse.capacity":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetModelCapacityResponse.found":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices":
+		list := []*ModelPrice{}
+		return protoreflect.ValueOfList(&_QueryGetAllModelPerTokenPricesResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelPerTokenPricesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelPerTokenPricesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetModelCapacityResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelCapacityResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelPerTokenPricesResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -64596,7 +64577,7 @@ func (x *fastReflection_QueryGetModelCapacityResponse) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetModelCapacityResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -64607,7 +64588,7 @@ func (x *fastReflection_QueryGetModelCapacityResponse) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetModelCapacityResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -64619,7 +64600,7 @@ func (x *fastReflection_QueryGetModelCapacityResponse) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetModelCapacityResponse) IsValid() bool {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -64629,9 +64610,9 @@ func (x *fastReflection_QueryGetModelCapacityResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetAllModelPerTokenPricesResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetModelCapacityResponse)
+		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -64643,11 +64624,11 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if x.Capacity != 0 {
-			n += 1 + runtime.Sov(uint64(x.Capacity))
-		}
-		if x.Found {
-			n += 2
+		if len(x.ModelPrices) > 0 {
+			for _, e := range x.ModelPrices {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -64659,7 +64640,7 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelCapacityResponse)
+		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -64678,20 +64659,21 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Found {
-			i--
-			if x.Found {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
+		if len(x.ModelPrices) > 0 {
+			for iNdEx := len(x.ModelPrices) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.ModelPrices[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
 			}
-			i--
-			dAtA[i] = 0x10
-		}
-		if x.Capacity != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Capacity))
-			i--
-			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -64704,7 +64686,7 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetModelCapacityResponse)
+		x := input.Message.Interface().(*QueryGetAllModelPerTokenPricesResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -64736,17 +64718,17 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelPrices", wireType)
 				}
-				x.Capacity = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -64756,31 +64738,26 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Capacity |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				var v int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				x.Found = bool(v != 0)
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelPrices = append(x.ModelPrices, &ModelPrice{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ModelPrices[len(x.ModelPrices)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -64817,23 +64794,25 @@ func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryGetAllModelCapacitiesRequest protoreflect.MessageDescriptor
+	md_QueryGetModelCapacityRequest          protoreflect.MessageDescriptor
+	fd_QueryGetModelCapacityRequest_model_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetAllModelCapacitiesRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelCapacitiesRequest")
+	md_QueryGetModelCapacityRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetModelCapacityRequest")
+	fd_QueryGetModelCapacityRequest_model_id = md_QueryGetModelCapacityRequest.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetAllModelCapacitiesRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetModelCapacityRequest)(nil)
 
-type fastReflection_QueryGetAllModelCapacitiesRequest QueryGetAllModelCapacitiesRequest
+type fastReflection_QueryGetModelCapacityRequest QueryGetModelCapacityRequest
 
-func (x *QueryGetAllModelCapacitiesRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelCapacitiesRequest)(x)
+func (x *QueryGetModelCapacityRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetModelCapacityRequest)(x)
 }
 
-func (x *QueryGetAllModelCapacitiesRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetModelCapacityRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[135]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -64845,43 +64824,43 @@ func (x *QueryGetAllModelCapacitiesRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetAllModelCapacitiesRequest_messageType fastReflection_QueryGetAllModelCapacitiesRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetAllModelCapacitiesRequest_messageType{}
+var _fastReflection_QueryGetModelCapacityRequest_messageType fastReflection_QueryGetModelCapacityRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelCapacityRequest_messageType{}
 
-type fastReflection_QueryGetAllModelCapacitiesRequest_messageType struct{}
+type fastReflection_QueryGetModelCapacityRequest_messageType struct{}
 
-func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelCapacitiesRequest)(nil)
+func (x fastReflection_QueryGetModelCapacityRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetModelCapacityRequest)(nil)
 }
-func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelCapacitiesRequest)
+func (x fastReflection_QueryGetModelCapacityRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelCapacityRequest)
 }
-func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelCapacitiesRequest
+func (x fastReflection_QueryGetModelCapacityRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelCapacityRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelCapacitiesRequest
+func (x *fastReflection_QueryGetModelCapacityRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelCapacityRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetAllModelCapacitiesRequest_messageType
+func (x *fastReflection_QueryGetModelCapacityRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetModelCapacityRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelCapacitiesRequest)
+func (x *fastReflection_QueryGetModelCapacityRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelCapacityRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetAllModelCapacitiesRequest)(x)
+func (x *fastReflection_QueryGetModelCapacityRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetModelCapacityRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -64889,7 +64868,13 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetModelCapacityRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_QueryGetModelCapacityRequest_model_id, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -64903,13 +64888,15 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetModelCapacityRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64919,13 +64906,15 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetModelCapacityRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64935,13 +64924,16 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelCapacityRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+		value := x.ModelId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -64955,13 +64947,15 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetModelCapacityRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -64975,36 +64969,40 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelCapacityRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.QueryGetModelCapacityRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelCapacityRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryGetModelCapacityRequest.model_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetModelCapacityRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelCapacitiesRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelCapacityRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -65012,7 +65010,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetModelCapacityRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -65023,7 +65021,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetModelCapacityRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -65035,7 +65033,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) IsValid() bool {
+func (x *fastReflection_QueryGetModelCapacityRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -65045,9 +65043,9 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetModelCapacityRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
+		x := input.Message.Interface().(*QueryGetModelCapacityRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65059,6 +65057,10 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
+		l = len(x.ModelId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -65069,7 +65071,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
+		x := input.Message.Interface().(*QueryGetModelCapacityRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65088,6 +65090,13 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -65099,7 +65108,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
+		x := input.Message.Interface().(*QueryGetModelCapacityRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65131,12 +65140,44 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -65172,125 +65213,76 @@ func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *proto
 	}
 }
 
-var _ protoreflect.List = (*_QueryGetAllModelCapacitiesResponse_1_list)(nil)
+var (
+	md_QueryGetModelCapacityResponse          protoreflect.MessageDescriptor
+	fd_QueryGetModelCapacityResponse_capacity protoreflect.FieldDescriptor
+	fd_QueryGetModelCapacityResponse_found    protoreflect.FieldDescriptor
+)
 
-type _QueryGetAllModelCapacitiesResponse_1_list struct {
-	list *[]*ModelCapacity
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetModelCapacityResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetModelCapacityResponse")
+	fd_QueryGetModelCapacityResponse_capacity = md_QueryGetModelCapacityResponse.Fields().ByName("capacity")
+	fd_QueryGetModelCapacityResponse_found = md_QueryGetModelCapacityResponse.Fields().ByName("found")
 }
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
+var _ protoreflect.Message = (*fastReflection_QueryGetModelCapacityResponse)(nil)
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
+type fastReflection_QueryGetModelCapacityResponse QueryGetModelCapacityResponse
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ModelCapacity)
-	(*x.list)[i] = concreteValue
+func (x *QueryGetModelCapacityResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetModelCapacityResponse)(x)
 }
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ModelCapacity)
-	*x.list = append(*x.list, concreteValue)
+func (x *QueryGetModelCapacityResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[136]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
 }
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ModelCapacity)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
+var _fastReflection_QueryGetModelCapacityResponse_messageType fastReflection_QueryGetModelCapacityResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetModelCapacityResponse_messageType{}
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
+type fastReflection_QueryGetModelCapacityResponse_messageType struct{}
 
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ModelCapacity)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
+func (x fastReflection_QueryGetModelCapacityResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetModelCapacityResponse)(nil)
 }
-
-func (x *_QueryGetAllModelCapacitiesResponse_1_list) IsValid() bool {
-	return x.list != nil
+func (x fastReflection_QueryGetModelCapacityResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelCapacityResponse)
 }
-
-var (
-	md_QueryGetAllModelCapacitiesResponse                  protoreflect.MessageDescriptor
-	fd_QueryGetAllModelCapacitiesResponse_model_capacities protoreflect.FieldDescriptor
-)
-
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryGetAllModelCapacitiesResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelCapacitiesResponse")
-	fd_QueryGetAllModelCapacitiesResponse_model_capacities = md_QueryGetAllModelCapacitiesResponse.Fields().ByName("model_capacities")
-}
-
-var _ protoreflect.Message = (*fastReflection_QueryGetAllModelCapacitiesResponse)(nil)
-
-type fastReflection_QueryGetAllModelCapacitiesResponse QueryGetAllModelCapacitiesResponse
-
-func (x *QueryGetAllModelCapacitiesResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelCapacitiesResponse)(x)
-}
-
-func (x *QueryGetAllModelCapacitiesResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[136]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-var _fastReflection_QueryGetAllModelCapacitiesResponse_messageType fastReflection_QueryGetAllModelCapacitiesResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetAllModelCapacitiesResponse_messageType{}
-
-type fastReflection_QueryGetAllModelCapacitiesResponse_messageType struct{}
-
-func (x fastReflection_QueryGetAllModelCapacitiesResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetAllModelCapacitiesResponse)(nil)
-}
-func (x fastReflection_QueryGetAllModelCapacitiesResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelCapacitiesResponse)
-}
-func (x fastReflection_QueryGetAllModelCapacitiesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelCapacitiesResponse
+func (x fastReflection_QueryGetModelCapacityResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelCapacityResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetAllModelCapacitiesResponse
+func (x *fastReflection_QueryGetModelCapacityResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetModelCapacityResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetAllModelCapacitiesResponse_messageType
+func (x *fastReflection_QueryGetModelCapacityResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetModelCapacityResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetAllModelCapacitiesResponse)
+func (x *fastReflection_QueryGetModelCapacityResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetModelCapacityResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetAllModelCapacitiesResponse)(x)
+func (x *fastReflection_QueryGetModelCapacityResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetModelCapacityResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -65298,10 +65290,16 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.ModelCapacities) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGetAllModelCapacitiesResponse_1_list{list: &x.ModelCapacities})
-		if !f(fd_QueryGetAllModelCapacitiesResponse_model_capacities, value) {
+func (x *fastReflection_QueryGetModelCapacityResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Capacity != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Capacity)
+		if !f(fd_QueryGetModelCapacityResponse_capacity, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryGetModelCapacityResponse_found, value) {
 			return
 		}
 	}
@@ -65318,15 +65316,17 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetModelCapacityResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
-		return len(x.ModelCapacities) != 0
+	case "inference.inference.QueryGetModelCapacityResponse.capacity":
+		return x.Capacity != uint64(0)
+	case "inference.inference.QueryGetModelCapacityResponse.found":
+		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -65336,15 +65336,17 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetModelCapacityResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
-		x.ModelCapacities = nil
+	case "inference.inference.QueryGetModelCapacityResponse.capacity":
+		x.Capacity = uint64(0)
+	case "inference.inference.QueryGetModelCapacityResponse.found":
+		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -65354,19 +65356,19 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelCapacityResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
-		if len(x.ModelCapacities) == 0 {
-			return protoreflect.ValueOfList(&_QueryGetAllModelCapacitiesResponse_1_list{})
-		}
-		listValue := &_QueryGetAllModelCapacitiesResponse_1_list{list: &x.ModelCapacities}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGetModelCapacityResponse.capacity":
+		value := x.Capacity
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetModelCapacityResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -65380,17 +65382,17 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetModelCapacityResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
-		lv := value.List()
-		clv := lv.(*_QueryGetAllModelCapacitiesResponse_1_list)
-		x.ModelCapacities = *clv.list
+	case "inference.inference.QueryGetModelCapacityResponse.capacity":
+		x.Capacity = value.Uint()
+	case "inference.inference.QueryGetModelCapacityResponse.found":
+		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -65404,45 +65406,44 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelCapacityResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
-		if x.ModelCapacities == nil {
-			x.ModelCapacities = []*ModelCapacity{}
-		}
-		value := &_QueryGetAllModelCapacitiesResponse_1_list{list: &x.ModelCapacities}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryGetModelCapacityResponse.capacity":
+		panic(fmt.Errorf("field capacity of message inference.inference.QueryGetModelCapacityResponse is not mutable"))
+	case "inference.inference.QueryGetModelCapacityResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryGetModelCapacityResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetModelCapacityResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
-		list := []*ModelCapacity{}
-		return protoreflect.ValueOfList(&_QueryGetAllModelCapacitiesResponse_1_list{list: &list})
+	case "inference.inference.QueryGetModelCapacityResponse.capacity":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetModelCapacityResponse.found":
+		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetModelCapacityResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetModelCapacityResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetModelCapacityResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelCapacitiesResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetModelCapacityResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -65450,7 +65451,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetModelCapacityResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -65461,7 +65462,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetModelCapacityResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -65473,7 +65474,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) IsValid() bool {
+func (x *fastReflection_QueryGetModelCapacityResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -65483,9 +65484,9 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetModelCapacityResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
+		x := input.Message.Interface().(*QueryGetModelCapacityResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65497,11 +65498,11 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if len(x.ModelCapacities) > 0 {
-			for _, e := range x.ModelCapacities {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Capacity != 0 {
+			n += 1 + runtime.Sov(uint64(x.Capacity))
+		}
+		if x.Found {
+			n += 2
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -65513,7 +65514,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
+		x := input.Message.Interface().(*QueryGetModelCapacityResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65532,21 +65533,20 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelCapacities) > 0 {
-			for iNdEx := len(x.ModelCapacities) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.ModelCapacities[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
 			}
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.Capacity != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Capacity))
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -65559,7 +65559,7 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
+		x := input.Message.Interface().(*QueryGetModelCapacityResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65591,17 +65591,17 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetModelCapacityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelCapacities", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
 				}
-				var msglen int
+				x.Capacity = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -65611,26 +65611,31 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Capacity |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 				}
-				x.ModelCapacities = append(x.ModelCapacities, &ModelCapacity{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ModelCapacities[len(x.ModelCapacities)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-				iNdEx = postIndex
+				x.Found = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -65667,27 +65672,23 @@ func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *prot
 }
 
 var (
-	md_ModelCapacity          protoreflect.MessageDescriptor
-	fd_ModelCapacity_model_id protoreflect.FieldDescriptor
-	fd_ModelCapacity_capacity protoreflect.FieldDescriptor
+	md_QueryGetAllModelCapacitiesRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ModelCapacity = File_inference_inference_query_proto.Messages().ByName("ModelCapacity")
-	fd_ModelCapacity_model_id = md_ModelCapacity.Fields().ByName("model_id")
-	fd_ModelCapacity_capacity = md_ModelCapacity.Fields().ByName("capacity")
+	md_QueryGetAllModelCapacitiesRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelCapacitiesRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_ModelCapacity)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetAllModelCapacitiesRequest)(nil)
 
-type fastReflection_ModelCapacity ModelCapacity
+type fastReflection_QueryGetAllModelCapacitiesRequest QueryGetAllModelCapacitiesRequest
 
-func (x *ModelCapacity) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ModelCapacity)(x)
+func (x *QueryGetAllModelCapacitiesRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelCapacitiesRequest)(x)
 }
 
-func (x *ModelCapacity) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetAllModelCapacitiesRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[137]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -65699,43 +65700,43 @@ func (x *ModelCapacity) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ModelCapacity_messageType fastReflection_ModelCapacity_messageType
-var _ protoreflect.MessageType = fastReflection_ModelCapacity_messageType{}
+var _fastReflection_QueryGetAllModelCapacitiesRequest_messageType fastReflection_QueryGetAllModelCapacitiesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllModelCapacitiesRequest_messageType{}
 
-type fastReflection_ModelCapacity_messageType struct{}
+type fastReflection_QueryGetAllModelCapacitiesRequest_messageType struct{}
 
-func (x fastReflection_ModelCapacity_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ModelCapacity)(nil)
+func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelCapacitiesRequest)(nil)
 }
-func (x fastReflection_ModelCapacity_messageType) New() protoreflect.Message {
-	return new(fastReflection_ModelCapacity)
+func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelCapacitiesRequest)
 }
-func (x fastReflection_ModelCapacity_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ModelCapacity
+func (x fastReflection_QueryGetAllModelCapacitiesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelCapacitiesRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ModelCapacity) Descriptor() protoreflect.MessageDescriptor {
-	return md_ModelCapacity
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelCapacitiesRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ModelCapacity) Type() protoreflect.MessageType {
-	return _fastReflection_ModelCapacity_messageType
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetAllModelCapacitiesRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ModelCapacity) New() protoreflect.Message {
-	return new(fastReflection_ModelCapacity)
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelCapacitiesRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ModelCapacity) Interface() protoreflect.ProtoMessage {
-	return (*ModelCapacity)(x)
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetAllModelCapacitiesRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -65743,19 +65744,7 @@ func (x *fastReflection_ModelCapacity) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ModelCapacity) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_ModelCapacity_model_id, value) {
-			return
-		}
-	}
-	if x.Capacity != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Capacity)
-		if !f(fd_ModelCapacity_capacity, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -65769,17 +65758,13 @@ func (x *fastReflection_ModelCapacity) Range(f func(protoreflect.FieldDescriptor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ModelCapacity) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ModelCapacity.model_id":
-		return x.ModelId != ""
-	case "inference.inference.ModelCapacity.capacity":
-		return x.Capacity != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -65789,17 +65774,13 @@ func (x *fastReflection_ModelCapacity) Has(fd protoreflect.FieldDescriptor) bool
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelCapacity) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ModelCapacity.model_id":
-		x.ModelId = ""
-	case "inference.inference.ModelCapacity.capacity":
-		x.Capacity = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -65809,19 +65790,13 @@ func (x *fastReflection_ModelCapacity) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ModelCapacity) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ModelCapacity.model_id":
-		value := x.ModelId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.ModelCapacity.capacity":
-		value := x.Capacity
-		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -65835,17 +65810,13 @@ func (x *fastReflection_ModelCapacity) Get(descriptor protoreflect.FieldDescript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelCapacity) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ModelCapacity.model_id":
-		x.ModelId = value.Interface().(string)
-	case "inference.inference.ModelCapacity.capacity":
-		x.Capacity = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -65859,44 +65830,36 @@ func (x *fastReflection_ModelCapacity) Set(fd protoreflect.FieldDescriptor, valu
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelCapacity) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ModelCapacity.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.ModelCapacity is not mutable"))
-	case "inference.inference.ModelCapacity.capacity":
-		panic(fmt.Errorf("field capacity of message inference.inference.ModelCapacity is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ModelCapacity) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ModelCapacity.model_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.ModelCapacity.capacity":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ModelCapacity) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelCapacity", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelCapacitiesRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -65904,7 +65867,7 @@ func (x *fastReflection_ModelCapacity) WhichOneof(d protoreflect.OneofDescriptor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ModelCapacity) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -65915,7 +65878,7 @@ func (x *fastReflection_ModelCapacity) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ModelCapacity) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -65927,7 +65890,7 @@ func (x *fastReflection_ModelCapacity) SetUnknown(fields protoreflect.RawFields)
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ModelCapacity) IsValid() bool {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -65937,9 +65900,9 @@ func (x *fastReflection_ModelCapacity) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetAllModelCapacitiesRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ModelCapacity)
+		x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65951,13 +65914,6 @@ func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.Capacity != 0 {
-			n += 1 + runtime.Sov(uint64(x.Capacity))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -65968,7 +65924,7 @@ func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ModelCapacity)
+		x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -65987,18 +65943,6 @@ func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Capacity != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Capacity))
-			i--
-			dAtA[i] = 0x10
-		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -66010,7 +65954,7 @@ func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ModelCapacity)
+		x := input.Message.Interface().(*QueryGetAllModelCapacitiesRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66042,63 +65986,12 @@ func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelCapacity: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
-				}
-				x.Capacity = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Capacity |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -66134,31 +66027,80 @@ func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 	}
 }
 
-var (
-	md_QueryGranteesByMessageTypeRequest                  protoreflect.MessageDescriptor
-	fd_QueryGranteesByMessageTypeRequest_granter_address  protoreflect.FieldDescriptor
-	fd_QueryGranteesByMessageTypeRequest_message_type_url protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_QueryGetAllModelCapacitiesResponse_1_list)(nil)
 
-func init() {
-	file_inference_inference_query_proto_init()
-	md_QueryGranteesByMessageTypeRequest = File_inference_inference_query_proto.Messages().ByName("QueryGranteesByMessageTypeRequest")
-	fd_QueryGranteesByMessageTypeRequest_granter_address = md_QueryGranteesByMessageTypeRequest.Fields().ByName("granter_address")
-	fd_QueryGranteesByMessageTypeRequest_message_type_url = md_QueryGranteesByMessageTypeRequest.Fields().ByName("message_type_url")
+type _QueryGetAllModelCapacitiesResponse_1_list struct {
+	list *[]*ModelCapacity
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGranteesByMessageTypeRequest)(nil)
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-type fastReflection_QueryGranteesByMessageTypeRequest QueryGranteesByMessageTypeRequest
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
 
-func (x *QueryGranteesByMessageTypeRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGranteesByMessageTypeRequest)(x)
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ModelCapacity)
+	(*x.list)[i] = concreteValue
 }
 
-func (x *QueryGranteesByMessageTypeRequest) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_query_proto_msgTypes[138]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ModelCapacity)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ModelCapacity)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ModelCapacity)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryGetAllModelCapacitiesResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryGetAllModelCapacitiesResponse                  protoreflect.MessageDescriptor
+	fd_QueryGetAllModelCapacitiesResponse_model_capacities protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetAllModelCapacitiesResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetAllModelCapacitiesResponse")
+	fd_QueryGetAllModelCapacitiesResponse_model_capacities = md_QueryGetAllModelCapacitiesResponse.Fields().ByName("model_capacities")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetAllModelCapacitiesResponse)(nil)
+
+type fastReflection_QueryGetAllModelCapacitiesResponse QueryGetAllModelCapacitiesResponse
+
+func (x *QueryGetAllModelCapacitiesResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelCapacitiesResponse)(x)
+}
+
+func (x *QueryGetAllModelCapacitiesResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[138]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
 			ms.StoreMessageInfo(mi)
 		}
@@ -66167,43 +66109,43 @@ func (x *QueryGranteesByMessageTypeRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGranteesByMessageTypeRequest_messageType fastReflection_QueryGranteesByMessageTypeRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGranteesByMessageTypeRequest_messageType{}
+var _fastReflection_QueryGetAllModelCapacitiesResponse_messageType fastReflection_QueryGetAllModelCapacitiesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetAllModelCapacitiesResponse_messageType{}
 
-type fastReflection_QueryGranteesByMessageTypeRequest_messageType struct{}
+type fastReflection_QueryGetAllModelCapacitiesResponse_messageType struct{}
 
-func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGranteesByMessageTypeRequest)(nil)
+func (x fastReflection_QueryGetAllModelCapacitiesResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetAllModelCapacitiesResponse)(nil)
 }
-func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGranteesByMessageTypeRequest)
+func (x fastReflection_QueryGetAllModelCapacitiesResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelCapacitiesResponse)
 }
-func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGranteesByMessageTypeRequest
+func (x fastReflection_QueryGetAllModelCapacitiesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelCapacitiesResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGranteesByMessageTypeRequest
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetAllModelCapacitiesResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGranteesByMessageTypeRequest_messageType
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetAllModelCapacitiesResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGranteesByMessageTypeRequest)
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetAllModelCapacitiesResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGranteesByMessageTypeRequest)(x)
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetAllModelCapacitiesResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -66211,16 +66153,10 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.GranterAddress != "" {
-		value := protoreflect.ValueOfString(x.GranterAddress)
-		if !f(fd_QueryGranteesByMessageTypeRequest_granter_address, value) {
-			return
-		}
-	}
-	if x.MessageTypeUrl != "" {
-		value := protoreflect.ValueOfString(x.MessageTypeUrl)
-		if !f(fd_QueryGranteesByMessageTypeRequest_message_type_url, value) {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.ModelCapacities) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGetAllModelCapacitiesResponse_1_list{list: &x.ModelCapacities})
+		if !f(fd_QueryGetAllModelCapacitiesResponse_model_capacities, value) {
 			return
 		}
 	}
@@ -66237,17 +66173,15 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
-		return x.GranterAddress != ""
-	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
-		return x.MessageTypeUrl != ""
+	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
+		return len(x.ModelCapacities) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -66257,17 +66191,15 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
-		x.GranterAddress = ""
-	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
-		x.MessageTypeUrl = ""
+	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
+		x.ModelCapacities = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -66277,19 +66209,19 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
-		value := x.GranterAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
-		value := x.MessageTypeUrl
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
+		if len(x.ModelCapacities) == 0 {
+			return protoreflect.ValueOfList(&_QueryGetAllModelCapacitiesResponse_1_list{})
+		}
+		listValue := &_QueryGetAllModelCapacitiesResponse_1_list{list: &x.ModelCapacities}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -66303,17 +66235,17 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
-		x.GranterAddress = value.Interface().(string)
-	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
-		x.MessageTypeUrl = value.Interface().(string)
+	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
+		lv := value.List()
+		clv := lv.(*_QueryGetAllModelCapacitiesResponse_1_list)
+		x.ModelCapacities = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -66327,44 +66259,45 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
-		panic(fmt.Errorf("field granter_address of message inference.inference.QueryGranteesByMessageTypeRequest is not mutable"))
-	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
-		panic(fmt.Errorf("field message_type_url of message inference.inference.QueryGranteesByMessageTypeRequest is not mutable"))
+	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
+		if x.ModelCapacities == nil {
+			x.ModelCapacities = []*ModelCapacity{}
+		}
+		value := &_QueryGetAllModelCapacitiesResponse_1_list{list: &x.ModelCapacities}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
-		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities":
+		list := []*ModelCapacity{}
+		return protoreflect.ValueOfList(&_QueryGetAllModelCapacitiesResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetAllModelCapacitiesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetAllModelCapacitiesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGranteesByMessageTypeRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetAllModelCapacitiesResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -66372,7 +66305,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -66383,7 +66316,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -66395,7 +66328,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) IsValid() bool {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -66405,9 +66338,9 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetAllModelCapacitiesResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
+		x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66419,13 +66352,11 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		l = len(x.GranterAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.MessageTypeUrl)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.ModelCapacities) > 0 {
+			for _, e := range x.ModelCapacities {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -66437,7 +66368,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
+		x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66456,19 +66387,21 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.MessageTypeUrl) > 0 {
-			i -= len(x.MessageTypeUrl)
-			copy(dAtA[i:], x.MessageTypeUrl)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MessageTypeUrl)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.GranterAddress) > 0 {
-			i -= len(x.GranterAddress)
-			copy(dAtA[i:], x.GranterAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GranterAddress)))
-			i--
-			dAtA[i] = 0xa
+		if len(x.ModelCapacities) > 0 {
+			for iNdEx := len(x.ModelCapacities) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.ModelCapacities[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -66481,7 +66414,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
+		x := input.Message.Interface().(*QueryGetAllModelCapacitiesResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66513,17 +66446,17 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GranterAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelCapacities", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -66533,55 +66466,25 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.GranterAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MessageTypeUrl", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				x.ModelCapacities = append(x.ModelCapacities, &ModelCapacity{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ModelCapacities[len(x.ModelCapacities)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-				x.MessageTypeUrl = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -66619,27 +66522,27 @@ func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *proto
 }
 
 var (
-	md_Grantee         protoreflect.MessageDescriptor
-	fd_Grantee_address protoreflect.FieldDescriptor
-	fd_Grantee_pub_key protoreflect.FieldDescriptor
+	md_ModelCapacity          protoreflect.MessageDescriptor
+	fd_ModelCapacity_model_id protoreflect.FieldDescriptor
+	fd_ModelCapacity_capacity protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_Grantee = File_inference_inference_query_proto.Messages().ByName("Grantee")
-	fd_Grantee_address = md_Grantee.Fields().ByName("address")
-	fd_Grantee_pub_key = md_Grantee.Fields().ByName("pub_key")
+	md_ModelCapacity = File_inference_inference_query_proto.Messages().ByName("ModelCapacity")
+	fd_ModelCapacity_model_id = md_ModelCapacity.Fields().ByName("model_id")
+	fd_ModelCapacity_capacity = md_ModelCapacity.Fields().ByName("capacity")
 }
 
-var _ protoreflect.Message = (*fastReflection_Grantee)(nil)
+var _ protoreflect.Message = (*fastReflection_ModelCapacity)(nil)
 
-type fastReflection_Grantee Grantee
+type fastReflection_ModelCapacity ModelCapacity
 
-func (x *Grantee) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_Grantee)(x)
+func (x *ModelCapacity) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ModelCapacity)(x)
 }
 
-func (x *Grantee) slowProtoReflect() protoreflect.Message {
+func (x *ModelCapacity) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[139]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -66651,43 +66554,43 @@ func (x *Grantee) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_Grantee_messageType fastReflection_Grantee_messageType
-var _ protoreflect.MessageType = fastReflection_Grantee_messageType{}
+var _fastReflection_ModelCapacity_messageType fastReflection_ModelCapacity_messageType
+var _ protoreflect.MessageType = fastReflection_ModelCapacity_messageType{}
 
-type fastReflection_Grantee_messageType struct{}
+type fastReflection_ModelCapacity_messageType struct{}
 
-func (x fastReflection_Grantee_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_Grantee)(nil)
+func (x fastReflection_ModelCapacity_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ModelCapacity)(nil)
 }
-func (x fastReflection_Grantee_messageType) New() protoreflect.Message {
-	return new(fastReflection_Grantee)
+func (x fastReflection_ModelCapacity_messageType) New() protoreflect.Message {
+	return new(fastReflection_ModelCapacity)
 }
-func (x fastReflection_Grantee_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_Grantee
+func (x fastReflection_ModelCapacity_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ModelCapacity
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_Grantee) Descriptor() protoreflect.MessageDescriptor {
-	return md_Grantee
+func (x *fastReflection_ModelCapacity) Descriptor() protoreflect.MessageDescriptor {
+	return md_ModelCapacity
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_Grantee) Type() protoreflect.MessageType {
-	return _fastReflection_Grantee_messageType
+func (x *fastReflection_ModelCapacity) Type() protoreflect.MessageType {
+	return _fastReflection_ModelCapacity_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_Grantee) New() protoreflect.Message {
-	return new(fastReflection_Grantee)
+func (x *fastReflection_ModelCapacity) New() protoreflect.Message {
+	return new(fastReflection_ModelCapacity)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_Grantee) Interface() protoreflect.ProtoMessage {
-	return (*Grantee)(x)
+func (x *fastReflection_ModelCapacity) Interface() protoreflect.ProtoMessage {
+	return (*ModelCapacity)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -66695,16 +66598,16 @@ func (x *fastReflection_Grantee) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_Grantee) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Address != "" {
-		value := protoreflect.ValueOfString(x.Address)
-		if !f(fd_Grantee_address, value) {
+func (x *fastReflection_ModelCapacity) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_ModelCapacity_model_id, value) {
 			return
 		}
 	}
-	if x.PubKey != "" {
-		value := protoreflect.ValueOfString(x.PubKey)
-		if !f(fd_Grantee_pub_key, value) {
+	if x.Capacity != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Capacity)
+		if !f(fd_ModelCapacity_capacity, value) {
 			return
 		}
 	}
@@ -66721,17 +66624,17 @@ func (x *fastReflection_Grantee) Range(f func(protoreflect.FieldDescriptor, prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_Grantee) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ModelCapacity) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.Grantee.address":
-		return x.Address != ""
-	case "inference.inference.Grantee.pub_key":
-		return x.PubKey != ""
+	case "inference.inference.ModelCapacity.model_id":
+		return x.ModelId != ""
+	case "inference.inference.ModelCapacity.capacity":
+		return x.Capacity != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
 		}
-		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -66741,17 +66644,17 @@ func (x *fastReflection_Grantee) Has(fd protoreflect.FieldDescriptor) bool {
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_Grantee) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ModelCapacity) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.Grantee.address":
-		x.Address = ""
-	case "inference.inference.Grantee.pub_key":
-		x.PubKey = ""
+	case "inference.inference.ModelCapacity.model_id":
+		x.ModelId = ""
+	case "inference.inference.ModelCapacity.capacity":
+		x.Capacity = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
 		}
-		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -66761,19 +66664,19 @@ func (x *fastReflection_Grantee) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_Grantee) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelCapacity) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.Grantee.address":
-		value := x.Address
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.Grantee.pub_key":
-		value := x.PubKey
+	case "inference.inference.ModelCapacity.model_id":
+		value := x.ModelId
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.ModelCapacity.capacity":
+		value := x.Capacity
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
 		}
-		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -66787,17 +66690,17 @@ func (x *fastReflection_Grantee) Get(descriptor protoreflect.FieldDescriptor) pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_Grantee) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ModelCapacity) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.Grantee.address":
-		x.Address = value.Interface().(string)
-	case "inference.inference.Grantee.pub_key":
-		x.PubKey = value.Interface().(string)
+	case "inference.inference.ModelCapacity.model_id":
+		x.ModelId = value.Interface().(string)
+	case "inference.inference.ModelCapacity.capacity":
+		x.Capacity = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
 		}
-		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -66811,44 +66714,44 @@ func (x *fastReflection_Grantee) Set(fd protoreflect.FieldDescriptor, value prot
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_Grantee) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelCapacity) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.Grantee.address":
-		panic(fmt.Errorf("field address of message inference.inference.Grantee is not mutable"))
-	case "inference.inference.Grantee.pub_key":
-		panic(fmt.Errorf("field pub_key of message inference.inference.Grantee is not mutable"))
+	case "inference.inference.ModelCapacity.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.ModelCapacity is not mutable"))
+	case "inference.inference.ModelCapacity.capacity":
+		panic(fmt.Errorf("field capacity of message inference.inference.ModelCapacity is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
 		}
-		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_Grantee) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ModelCapacity) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.Grantee.address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.Grantee.pub_key":
+	case "inference.inference.ModelCapacity.model_id":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.ModelCapacity.capacity":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ModelCapacity"))
 		}
-		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ModelCapacity does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_Grantee) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ModelCapacity) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.Grantee", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ModelCapacity", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -66856,7 +66759,7 @@ func (x *fastReflection_Grantee) WhichOneof(d protoreflect.OneofDescriptor) prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_Grantee) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ModelCapacity) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -66867,7 +66770,7 @@ func (x *fastReflection_Grantee) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_Grantee) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ModelCapacity) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -66879,7 +66782,7 @@ func (x *fastReflection_Grantee) SetUnknown(fields protoreflect.RawFields) {
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_Grantee) IsValid() bool {
+func (x *fastReflection_ModelCapacity) IsValid() bool {
 	return x != nil
 }
 
@@ -66889,9 +66792,9 @@ func (x *fastReflection_Grantee) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ModelCapacity) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*Grantee)
+		x := input.Message.Interface().(*ModelCapacity)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66903,13 +66806,12 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		l = len(x.Address)
+		l = len(x.ModelId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.PubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Capacity != 0 {
+			n += 1 + runtime.Sov(uint64(x.Capacity))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -66921,7 +66823,7 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*Grantee)
+		x := input.Message.Interface().(*ModelCapacity)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66940,17 +66842,15 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.PubKey) > 0 {
-			i -= len(x.PubKey)
-			copy(dAtA[i:], x.PubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
+		if x.Capacity != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Capacity))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if len(x.Address) > 0 {
-			i -= len(x.Address)
-			copy(dAtA[i:], x.Address)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -66965,7 +66865,7 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*Grantee)
+		x := input.Message.Interface().(*ModelCapacity)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -66997,15 +66897,15 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Grantee: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelCapacity: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Grantee: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ModelCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -67033,13 +66933,13 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Address = string(dAtA[iNdEx:postIndex])
+				x.ModelId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
 				}
-				var stringLen uint64
+				x.Capacity = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -67049,31 +66949,18 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.Capacity |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.PubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if (iNdEx + skippy) > l {
@@ -67102,77 +66989,28 @@ func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 	}
 }
 
-var _ protoreflect.List = (*_QueryGranteesByMessageTypeResponse_1_list)(nil)
-
-type _QueryGranteesByMessageTypeResponse_1_list struct {
-	list *[]*Grantee
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*Grantee)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*Grantee)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(Grantee)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) NewElement() protoreflect.Value {
-	v := new(Grantee)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryGranteesByMessageTypeResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryGranteesByMessageTypeResponse          protoreflect.MessageDescriptor
-	fd_QueryGranteesByMessageTypeResponse_grantees protoreflect.FieldDescriptor
+	md_QueryGranteesByMessageTypeRequest                  protoreflect.MessageDescriptor
+	fd_QueryGranteesByMessageTypeRequest_granter_address  protoreflect.FieldDescriptor
+	fd_QueryGranteesByMessageTypeRequest_message_type_url protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGranteesByMessageTypeResponse = File_inference_inference_query_proto.Messages().ByName("QueryGranteesByMessageTypeResponse")
-	fd_QueryGranteesByMessageTypeResponse_grantees = md_QueryGranteesByMessageTypeResponse.Fields().ByName("grantees")
+	md_QueryGranteesByMessageTypeRequest = File_inference_inference_query_proto.Messages().ByName("QueryGranteesByMessageTypeRequest")
+	fd_QueryGranteesByMessageTypeRequest_granter_address = md_QueryGranteesByMessageTypeRequest.Fields().ByName("granter_address")
+	fd_QueryGranteesByMessageTypeRequest_message_type_url = md_QueryGranteesByMessageTypeRequest.Fields().ByName("message_type_url")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGranteesByMessageTypeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGranteesByMessageTypeRequest)(nil)
 
-type fastReflection_QueryGranteesByMessageTypeResponse QueryGranteesByMessageTypeResponse
+type fastReflection_QueryGranteesByMessageTypeRequest QueryGranteesByMessageTypeRequest
 
-func (x *QueryGranteesByMessageTypeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGranteesByMessageTypeResponse)(x)
+func (x *QueryGranteesByMessageTypeRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGranteesByMessageTypeRequest)(x)
 }
 
-func (x *QueryGranteesByMessageTypeResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGranteesByMessageTypeRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[140]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -67184,43 +67022,43 @@ func (x *QueryGranteesByMessageTypeResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGranteesByMessageTypeResponse_messageType fastReflection_QueryGranteesByMessageTypeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGranteesByMessageTypeResponse_messageType{}
+var _fastReflection_QueryGranteesByMessageTypeRequest_messageType fastReflection_QueryGranteesByMessageTypeRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGranteesByMessageTypeRequest_messageType{}
 
-type fastReflection_QueryGranteesByMessageTypeResponse_messageType struct{}
+type fastReflection_QueryGranteesByMessageTypeRequest_messageType struct{}
 
-func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGranteesByMessageTypeResponse)(nil)
+func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGranteesByMessageTypeRequest)(nil)
 }
-func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGranteesByMessageTypeResponse)
+func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGranteesByMessageTypeRequest)
 }
-func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGranteesByMessageTypeResponse
+func (x fastReflection_QueryGranteesByMessageTypeRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGranteesByMessageTypeRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGranteesByMessageTypeResponse
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGranteesByMessageTypeRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGranteesByMessageTypeResponse_messageType
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGranteesByMessageTypeRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGranteesByMessageTypeResponse)
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGranteesByMessageTypeRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGranteesByMessageTypeResponse)(x)
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGranteesByMessageTypeRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -67228,10 +67066,16 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Grantees) != 0 {
-		value := protoreflect.ValueOfList(&_QueryGranteesByMessageTypeResponse_1_list{list: &x.Grantees})
-		if !f(fd_QueryGranteesByMessageTypeResponse_grantees, value) {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.GranterAddress != "" {
+		value := protoreflect.ValueOfString(x.GranterAddress)
+		if !f(fd_QueryGranteesByMessageTypeRequest_granter_address, value) {
+			return
+		}
+	}
+	if x.MessageTypeUrl != "" {
+		value := protoreflect.ValueOfString(x.MessageTypeUrl)
+		if !f(fd_QueryGranteesByMessageTypeRequest_message_type_url, value) {
 			return
 		}
 	}
@@ -67248,15 +67092,17 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
-		return len(x.Grantees) != 0
+	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
+		return x.GranterAddress != ""
+	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
+		return x.MessageTypeUrl != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -67266,15 +67112,17 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
-		x.Grantees = nil
+	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
+		x.GranterAddress = ""
+	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
+		x.MessageTypeUrl = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -67284,19 +67132,19 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
-		if len(x.Grantees) == 0 {
-			return protoreflect.ValueOfList(&_QueryGranteesByMessageTypeResponse_1_list{})
-		}
-		listValue := &_QueryGranteesByMessageTypeResponse_1_list{list: &x.Grantees}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
+		value := x.GranterAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
+		value := x.MessageTypeUrl
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -67310,17 +67158,17 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
-		lv := value.List()
-		clv := lv.(*_QueryGranteesByMessageTypeResponse_1_list)
-		x.Grantees = *clv.list
+	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
+		x.GranterAddress = value.Interface().(string)
+	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
+		x.MessageTypeUrl = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -67334,45 +67182,44 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
-		if x.Grantees == nil {
-			x.Grantees = []*Grantee{}
-		}
-		value := &_QueryGranteesByMessageTypeResponse_1_list{list: &x.Grantees}
-		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
+		panic(fmt.Errorf("field granter_address of message inference.inference.QueryGranteesByMessageTypeRequest is not mutable"))
+	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
+		panic(fmt.Errorf("field message_type_url of message inference.inference.QueryGranteesByMessageTypeRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
-		list := []*Grantee{}
-		return protoreflect.ValueOfList(&_QueryGranteesByMessageTypeResponse_1_list{list: &list})
+	case "inference.inference.QueryGranteesByMessageTypeRequest.granter_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryGranteesByMessageTypeRequest.message_type_url":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGranteesByMessageTypeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGranteesByMessageTypeRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -67380,7 +67227,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -67391,7 +67238,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -67403,7 +67250,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) IsValid() bool {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -67413,9 +67260,9 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGranteesByMessageTypeRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
+		x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -67427,11 +67274,13 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if len(x.Grantees) > 0 {
-			for _, e := range x.Grantees {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		l = len(x.GranterAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.MessageTypeUrl)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -67443,7 +67292,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
+		x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -67462,21 +67311,19 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Grantees) > 0 {
-			for iNdEx := len(x.Grantees) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Grantees[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+		if len(x.MessageTypeUrl) > 0 {
+			i -= len(x.MessageTypeUrl)
+			copy(dAtA[i:], x.MessageTypeUrl)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MessageTypeUrl)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.GranterAddress) > 0 {
+			i -= len(x.GranterAddress)
+			copy(dAtA[i:], x.GranterAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.GranterAddress)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -67489,7 +67336,7 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
+		x := input.Message.Interface().(*QueryGranteesByMessageTypeRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -67521,17 +67368,17 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Grantees", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field GranterAddress", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -67541,25 +67388,55 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Grantees = append(x.Grantees, &Grantee{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Grantees[len(x.Grantees)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.GranterAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MessageTypeUrl", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
+				x.MessageTypeUrl = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -67597,23 +67474,27 @@ func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *prot
 }
 
 var (
-	md_QueryParticipantAllowListRequest protoreflect.MessageDescriptor
+	md_Grantee         protoreflect.MessageDescriptor
+	fd_Grantee_address protoreflect.FieldDescriptor
+	fd_Grantee_pub_key protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryParticipantAllowListRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantAllowListRequest")
+	md_Grantee = File_inference_inference_query_proto.Messages().ByName("Grantee")
+	fd_Grantee_address = md_Grantee.Fields().ByName("address")
+	fd_Grantee_pub_key = md_Grantee.Fields().ByName("pub_key")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryParticipantAllowListRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_Grantee)(nil)
 
-type fastReflection_QueryParticipantAllowListRequest QueryParticipantAllowListRequest
+type fastReflection_Grantee Grantee
 
-func (x *QueryParticipantAllowListRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryParticipantAllowListRequest)(x)
+func (x *Grantee) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_Grantee)(x)
 }
 
-func (x *QueryParticipantAllowListRequest) slowProtoReflect() protoreflect.Message {
+func (x *Grantee) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[141]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -67625,43 +67506,43 @@ func (x *QueryParticipantAllowListRequest) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryParticipantAllowListRequest_messageType fastReflection_QueryParticipantAllowListRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryParticipantAllowListRequest_messageType{}
+var _fastReflection_Grantee_messageType fastReflection_Grantee_messageType
+var _ protoreflect.MessageType = fastReflection_Grantee_messageType{}
 
-type fastReflection_QueryParticipantAllowListRequest_messageType struct{}
+type fastReflection_Grantee_messageType struct{}
 
-func (x fastReflection_QueryParticipantAllowListRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryParticipantAllowListRequest)(nil)
+func (x fastReflection_Grantee_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_Grantee)(nil)
 }
-func (x fastReflection_QueryParticipantAllowListRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantAllowListRequest)
+func (x fastReflection_Grantee_messageType) New() protoreflect.Message {
+	return new(fastReflection_Grantee)
 }
-func (x fastReflection_QueryParticipantAllowListRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantAllowListRequest
+func (x fastReflection_Grantee_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_Grantee
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryParticipantAllowListRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantAllowListRequest
+func (x *fastReflection_Grantee) Descriptor() protoreflect.MessageDescriptor {
+	return md_Grantee
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryParticipantAllowListRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryParticipantAllowListRequest_messageType
+func (x *fastReflection_Grantee) Type() protoreflect.MessageType {
+	return _fastReflection_Grantee_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryParticipantAllowListRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantAllowListRequest)
+func (x *fastReflection_Grantee) New() protoreflect.Message {
+	return new(fastReflection_Grantee)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryParticipantAllowListRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryParticipantAllowListRequest)(x)
+func (x *fastReflection_Grantee) Interface() protoreflect.ProtoMessage {
+	return (*Grantee)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -67669,7 +67550,19 @@ func (x *fastReflection_QueryParticipantAllowListRequest) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryParticipantAllowListRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_Grantee) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Address != "" {
+		value := protoreflect.ValueOfString(x.Address)
+		if !f(fd_Grantee_address, value) {
+			return
+		}
+	}
+	if x.PubKey != "" {
+		value := protoreflect.ValueOfString(x.PubKey)
+		if !f(fd_Grantee_pub_key, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -67683,13 +67576,17 @@ func (x *fastReflection_QueryParticipantAllowListRequest) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryParticipantAllowListRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_Grantee) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.Grantee.address":
+		return x.Address != ""
+	case "inference.inference.Grantee.pub_key":
+		return x.PubKey != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -67699,13 +67596,17 @@ func (x *fastReflection_QueryParticipantAllowListRequest) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_Grantee) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.Grantee.address":
+		x.Address = ""
+	case "inference.inference.Grantee.pub_key":
+		x.PubKey = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -67715,13 +67616,19 @@ func (x *fastReflection_QueryParticipantAllowListRequest) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryParticipantAllowListRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_Grantee) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.Grantee.address":
+		value := x.Address
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.Grantee.pub_key":
+		value := x.PubKey
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -67735,13 +67642,17 @@ func (x *fastReflection_QueryParticipantAllowListRequest) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_Grantee) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.Grantee.address":
+		x.Address = value.Interface().(string)
+	case "inference.inference.Grantee.pub_key":
+		x.PubKey = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -67755,36 +67666,44 @@ func (x *fastReflection_QueryParticipantAllowListRequest) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_Grantee) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.Grantee.address":
+		panic(fmt.Errorf("field address of message inference.inference.Grantee is not mutable"))
+	case "inference.inference.Grantee.pub_key":
+		panic(fmt.Errorf("field pub_key of message inference.inference.Grantee is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryParticipantAllowListRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_Grantee) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.Grantee.address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.Grantee.pub_key":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.Grantee"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.Grantee does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryParticipantAllowListRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_Grantee) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantAllowListRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.Grantee", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -67792,7 +67711,7 @@ func (x *fastReflection_QueryParticipantAllowListRequest) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryParticipantAllowListRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_Grantee) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -67803,7 +67722,7 @@ func (x *fastReflection_QueryParticipantAllowListRequest) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_Grantee) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -67815,7 +67734,7 @@ func (x *fastReflection_QueryParticipantAllowListRequest) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryParticipantAllowListRequest) IsValid() bool {
+func (x *fastReflection_Grantee) IsValid() bool {
 	return x != nil
 }
 
@@ -67825,9 +67744,9 @@ func (x *fastReflection_QueryParticipantAllowListRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_Grantee) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryParticipantAllowListRequest)
+		x := input.Message.Interface().(*Grantee)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -67839,6 +67758,14 @@ func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
+		l = len(x.Address)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.PubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -67849,7 +67776,7 @@ func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantAllowListRequest)
+		x := input.Message.Interface().(*Grantee)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -67868,6 +67795,20 @@ func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.PubKey) > 0 {
+			i -= len(x.PubKey)
+			copy(dAtA[i:], x.PubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.PubKey)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Address) > 0 {
+			i -= len(x.Address)
+			copy(dAtA[i:], x.Address)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -67879,7 +67820,7 @@ func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantAllowListRequest)
+		x := input.Message.Interface().(*Grantee)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -67911,20 +67852,84 @@ func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Grantee: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Grantee: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Address = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.PubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if (iNdEx + skippy) > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
@@ -67952,72 +67957,77 @@ func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoi
 	}
 }
 
-var _ protoreflect.List = (*_QueryParticipantAllowListResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryGranteesByMessageTypeResponse_1_list)(nil)
 
-type _QueryParticipantAllowListResponse_1_list struct {
-	list *[]string
+type _QueryGranteesByMessageTypeResponse_1_list struct {
+	list *[]*Grantee
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) Len() int {
+func (x *_QueryGranteesByMessageTypeResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfString((*x.list)[i])
+func (x *_QueryGranteesByMessageTypeResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
+func (x *_QueryGranteesByMessageTypeResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Grantee)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
+func (x *_QueryGranteesByMessageTypeResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*Grantee)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message QueryParticipantAllowListResponse at list field Addresses as it is not of Message kind"))
+func (x *_QueryGranteesByMessageTypeResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(Grantee)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) Truncate(n int) {
+func (x *_QueryGranteesByMessageTypeResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) NewElement() protoreflect.Value {
-	v := ""
-	return protoreflect.ValueOfString(v)
+func (x *_QueryGranteesByMessageTypeResponse_1_list) NewElement() protoreflect.Value {
+	v := new(Grantee)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryParticipantAllowListResponse_1_list) IsValid() bool {
+func (x *_QueryGranteesByMessageTypeResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryParticipantAllowListResponse           protoreflect.MessageDescriptor
-	fd_QueryParticipantAllowListResponse_addresses protoreflect.FieldDescriptor
+	md_QueryGranteesByMessageTypeResponse          protoreflect.MessageDescriptor
+	fd_QueryGranteesByMessageTypeResponse_grantees protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryParticipantAllowListResponse = File_inference_inference_query_proto.Messages().ByName("QueryParticipantAllowListResponse")
-	fd_QueryParticipantAllowListResponse_addresses = md_QueryParticipantAllowListResponse.Fields().ByName("addresses")
+	md_QueryGranteesByMessageTypeResponse = File_inference_inference_query_proto.Messages().ByName("QueryGranteesByMessageTypeResponse")
+	fd_QueryGranteesByMessageTypeResponse_grantees = md_QueryGranteesByMessageTypeResponse.Fields().ByName("grantees")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryParticipantAllowListResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGranteesByMessageTypeResponse)(nil)
 
-type fastReflection_QueryParticipantAllowListResponse QueryParticipantAllowListResponse
+type fastReflection_QueryGranteesByMessageTypeResponse QueryGranteesByMessageTypeResponse
 
-func (x *QueryParticipantAllowListResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryParticipantAllowListResponse)(x)
+func (x *QueryGranteesByMessageTypeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGranteesByMessageTypeResponse)(x)
 }
 
-func (x *QueryParticipantAllowListResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGranteesByMessageTypeResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[142]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -68029,43 +68039,43 @@ func (x *QueryParticipantAllowListResponse) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryParticipantAllowListResponse_messageType fastReflection_QueryParticipantAllowListResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryParticipantAllowListResponse_messageType{}
+var _fastReflection_QueryGranteesByMessageTypeResponse_messageType fastReflection_QueryGranteesByMessageTypeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGranteesByMessageTypeResponse_messageType{}
 
-type fastReflection_QueryParticipantAllowListResponse_messageType struct{}
+type fastReflection_QueryGranteesByMessageTypeResponse_messageType struct{}
 
-func (x fastReflection_QueryParticipantAllowListResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryParticipantAllowListResponse)(nil)
+func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGranteesByMessageTypeResponse)(nil)
 }
-func (x fastReflection_QueryParticipantAllowListResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantAllowListResponse)
+func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGranteesByMessageTypeResponse)
 }
-func (x fastReflection_QueryParticipantAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantAllowListResponse
+func (x fastReflection_QueryGranteesByMessageTypeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGranteesByMessageTypeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryParticipantAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantAllowListResponse
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGranteesByMessageTypeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryParticipantAllowListResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryParticipantAllowListResponse_messageType
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGranteesByMessageTypeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryParticipantAllowListResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantAllowListResponse)
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGranteesByMessageTypeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryParticipantAllowListResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryParticipantAllowListResponse)(x)
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGranteesByMessageTypeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -68073,10 +68083,10 @@ func (x *fastReflection_QueryParticipantAllowListResponse) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryParticipantAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Addresses) != 0 {
-		value := protoreflect.ValueOfList(&_QueryParticipantAllowListResponse_1_list{list: &x.Addresses})
-		if !f(fd_QueryParticipantAllowListResponse_addresses, value) {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Grantees) != 0 {
+		value := protoreflect.ValueOfList(&_QueryGranteesByMessageTypeResponse_1_list{list: &x.Grantees})
+		if !f(fd_QueryGranteesByMessageTypeResponse_grantees, value) {
 			return
 		}
 	}
@@ -68093,15 +68103,15 @@ func (x *fastReflection_QueryParticipantAllowListResponse) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryParticipantAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantAllowListResponse.addresses":
-		return len(x.Addresses) != 0
+	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
+		return len(x.Grantees) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68111,15 +68121,15 @@ func (x *fastReflection_QueryParticipantAllowListResponse) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantAllowListResponse.addresses":
-		x.Addresses = nil
+	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
+		x.Grantees = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68129,19 +68139,19 @@ func (x *fastReflection_QueryParticipantAllowListResponse) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryParticipantAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryParticipantAllowListResponse.addresses":
-		if len(x.Addresses) == 0 {
-			return protoreflect.ValueOfList(&_QueryParticipantAllowListResponse_1_list{})
+	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
+		if len(x.Grantees) == 0 {
+			return protoreflect.ValueOfList(&_QueryGranteesByMessageTypeResponse_1_list{})
 		}
-		listValue := &_QueryParticipantAllowListResponse_1_list{list: &x.Addresses}
+		listValue := &_QueryGranteesByMessageTypeResponse_1_list{list: &x.Grantees}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -68155,17 +68165,17 @@ func (x *fastReflection_QueryParticipantAllowListResponse) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
 		lv := value.List()
-		clv := lv.(*_QueryParticipantAllowListResponse_1_list)
-		x.Addresses = *clv.list
+		clv := lv.(*_QueryGranteesByMessageTypeResponse_1_list)
+		x.Grantees = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68179,45 +68189,45 @@ func (x *fastReflection_QueryParticipantAllowListResponse) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantAllowListResponse.addresses":
-		if x.Addresses == nil {
-			x.Addresses = []string{}
+	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
+		if x.Grantees == nil {
+			x.Grantees = []*Grantee{}
 		}
-		value := &_QueryParticipantAllowListResponse_1_list{list: &x.Addresses}
+		value := &_QueryGranteesByMessageTypeResponse_1_list{list: &x.Grantees}
 		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryParticipantAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantAllowListResponse.addresses":
-		list := []string{}
-		return protoreflect.ValueOfList(&_QueryParticipantAllowListResponse_1_list{list: &list})
+	case "inference.inference.QueryGranteesByMessageTypeResponse.grantees":
+		list := []*Grantee{}
+		return protoreflect.ValueOfList(&_QueryGranteesByMessageTypeResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGranteesByMessageTypeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGranteesByMessageTypeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryParticipantAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantAllowListResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGranteesByMessageTypeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -68225,7 +68235,7 @@ func (x *fastReflection_QueryParticipantAllowListResponse) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryParticipantAllowListResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -68236,7 +68246,7 @@ func (x *fastReflection_QueryParticipantAllowListResponse) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantAllowListResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -68248,7 +68258,7 @@ func (x *fastReflection_QueryParticipantAllowListResponse) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryParticipantAllowListResponse) IsValid() bool {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -68258,9 +68268,9 @@ func (x *fastReflection_QueryParticipantAllowListResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGranteesByMessageTypeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryParticipantAllowListResponse)
+		x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -68272,9 +68282,9 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if len(x.Addresses) > 0 {
-			for _, s := range x.Addresses {
-				l = len(s)
+		if len(x.Grantees) > 0 {
+			for _, e := range x.Grantees {
+				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
 		}
@@ -68288,7 +68298,7 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantAllowListResponse)
+		x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -68307,11 +68317,18 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Addresses) > 0 {
-			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
-				i -= len(x.Addresses[iNdEx])
-				copy(dAtA[i:], x.Addresses[iNdEx])
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
+		if len(x.Grantees) > 0 {
+			for iNdEx := len(x.Grantees) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Grantees[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 				i--
 				dAtA[i] = 0xa
 			}
@@ -68327,7 +68344,7 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantAllowListResponse)
+		x := input.Message.Interface().(*QueryGranteesByMessageTypeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -68359,17 +68376,17 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Grantees", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -68379,23 +68396,25 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
+				x.Grantees = append(x.Grantees, &Grantee{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Grantees[len(x.Grantees)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -68433,23 +68452,23 @@ func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *proto
 }
 
 var (
-	md_QueryGetMLNodeVersionRequest protoreflect.MessageDescriptor
+	md_QueryParticipantAllowListRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetMLNodeVersionRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetMLNodeVersionRequest")
+	md_QueryParticipantAllowListRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantAllowListRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetMLNodeVersionRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryParticipantAllowListRequest)(nil)
 
-type fastReflection_QueryGetMLNodeVersionRequest QueryGetMLNodeVersionRequest
+type fastReflection_QueryParticipantAllowListRequest QueryParticipantAllowListRequest
 
-func (x *QueryGetMLNodeVersionRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetMLNodeVersionRequest)(x)
+func (x *QueryParticipantAllowListRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParticipantAllowListRequest)(x)
 }
 
-func (x *QueryGetMLNodeVersionRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryParticipantAllowListRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[143]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -68461,43 +68480,43 @@ func (x *QueryGetMLNodeVersionRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetMLNodeVersionRequest_messageType fastReflection_QueryGetMLNodeVersionRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetMLNodeVersionRequest_messageType{}
+var _fastReflection_QueryParticipantAllowListRequest_messageType fastReflection_QueryParticipantAllowListRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantAllowListRequest_messageType{}
 
-type fastReflection_QueryGetMLNodeVersionRequest_messageType struct{}
+type fastReflection_QueryParticipantAllowListRequest_messageType struct{}
 
-func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetMLNodeVersionRequest)(nil)
+func (x fastReflection_QueryParticipantAllowListRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParticipantAllowListRequest)(nil)
 }
-func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMLNodeVersionRequest)
+func (x fastReflection_QueryParticipantAllowListRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantAllowListRequest)
 }
-func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMLNodeVersionRequest
+func (x fastReflection_QueryParticipantAllowListRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantAllowListRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMLNodeVersionRequest
+func (x *fastReflection_QueryParticipantAllowListRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantAllowListRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetMLNodeVersionRequest_messageType
+func (x *fastReflection_QueryParticipantAllowListRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParticipantAllowListRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMLNodeVersionRequest)
+func (x *fastReflection_QueryParticipantAllowListRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantAllowListRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetMLNodeVersionRequest)(x)
+func (x *fastReflection_QueryParticipantAllowListRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryParticipantAllowListRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -68505,7 +68524,7 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryParticipantAllowListRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -68519,13 +68538,13 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryParticipantAllowListRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68535,13 +68554,13 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryParticipantAllowListRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68551,13 +68570,13 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantAllowListRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -68571,13 +68590,13 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryParticipantAllowListRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68591,36 +68610,36 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantAllowListRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantAllowListRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryParticipantAllowListRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMLNodeVersionRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantAllowListRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -68628,7 +68647,7 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryParticipantAllowListRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -68639,7 +68658,7 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryParticipantAllowListRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -68651,7 +68670,7 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) IsValid() bool {
+func (x *fastReflection_QueryParticipantAllowListRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -68661,9 +68680,9 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryParticipantAllowListRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
+		x := input.Message.Interface().(*QueryParticipantAllowListRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -68685,7 +68704,7 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
+		x := input.Message.Interface().(*QueryParticipantAllowListRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -68715,7 +68734,7 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
+		x := input.Message.Interface().(*QueryParticipantAllowListRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -68747,10 +68766,10 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -68788,26 +68807,72 @@ func (x *fastReflection_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface
 	}
 }
 
+var _ protoreflect.List = (*_QueryParticipantAllowListResponse_1_list)(nil)
+
+type _QueryParticipantAllowListResponse_1_list struct {
+	list *[]string
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message QueryParticipantAllowListResponse at list field Addresses as it is not of Message kind"))
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_QueryParticipantAllowListResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryGetMLNodeVersionResponse                protoreflect.MessageDescriptor
-	fd_QueryGetMLNodeVersionResponse_mlnode_version protoreflect.FieldDescriptor
+	md_QueryParticipantAllowListResponse           protoreflect.MessageDescriptor
+	fd_QueryParticipantAllowListResponse_addresses protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetMLNodeVersionResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetMLNodeVersionResponse")
-	fd_QueryGetMLNodeVersionResponse_mlnode_version = md_QueryGetMLNodeVersionResponse.Fields().ByName("mlnode_version")
+	md_QueryParticipantAllowListResponse = File_inference_inference_query_proto.Messages().ByName("QueryParticipantAllowListResponse")
+	fd_QueryParticipantAllowListResponse_addresses = md_QueryParticipantAllowListResponse.Fields().ByName("addresses")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetMLNodeVersionResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryParticipantAllowListResponse)(nil)
 
-type fastReflection_QueryGetMLNodeVersionResponse QueryGetMLNodeVersionResponse
+type fastReflection_QueryParticipantAllowListResponse QueryParticipantAllowListResponse
 
-func (x *QueryGetMLNodeVersionResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetMLNodeVersionResponse)(x)
+func (x *QueryParticipantAllowListResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParticipantAllowListResponse)(x)
 }
 
-func (x *QueryGetMLNodeVersionResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryParticipantAllowListResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[144]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -68819,43 +68884,43 @@ func (x *QueryGetMLNodeVersionResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetMLNodeVersionResponse_messageType fastReflection_QueryGetMLNodeVersionResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetMLNodeVersionResponse_messageType{}
+var _fastReflection_QueryParticipantAllowListResponse_messageType fastReflection_QueryParticipantAllowListResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantAllowListResponse_messageType{}
 
-type fastReflection_QueryGetMLNodeVersionResponse_messageType struct{}
+type fastReflection_QueryParticipantAllowListResponse_messageType struct{}
 
-func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetMLNodeVersionResponse)(nil)
+func (x fastReflection_QueryParticipantAllowListResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParticipantAllowListResponse)(nil)
 }
-func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMLNodeVersionResponse)
+func (x fastReflection_QueryParticipantAllowListResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantAllowListResponse)
 }
-func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMLNodeVersionResponse
+func (x fastReflection_QueryParticipantAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantAllowListResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetMLNodeVersionResponse
+func (x *fastReflection_QueryParticipantAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantAllowListResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetMLNodeVersionResponse_messageType
+func (x *fastReflection_QueryParticipantAllowListResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParticipantAllowListResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetMLNodeVersionResponse)
+func (x *fastReflection_QueryParticipantAllowListResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantAllowListResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetMLNodeVersionResponse)(x)
+func (x *fastReflection_QueryParticipantAllowListResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryParticipantAllowListResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -68863,10 +68928,10 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.MlnodeVersion != nil {
-		value := protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
-		if !f(fd_QueryGetMLNodeVersionResponse_mlnode_version, value) {
+func (x *fastReflection_QueryParticipantAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Addresses) != 0 {
+		value := protoreflect.ValueOfList(&_QueryParticipantAllowListResponse_1_list{list: &x.Addresses})
+		if !f(fd_QueryParticipantAllowListResponse_addresses, value) {
 			return
 		}
 	}
@@ -68883,15 +68948,15 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryParticipantAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
-		return x.MlnodeVersion != nil
+	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+		return len(x.Addresses) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68901,15 +68966,15 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryParticipantAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
-		x.MlnodeVersion = nil
+	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+		x.Addresses = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68919,16 +68984,19 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
-		value := x.MlnodeVersion
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+		if len(x.Addresses) == 0 {
+			return protoreflect.ValueOfList(&_QueryParticipantAllowListResponse_1_list{})
+		}
+		listValue := &_QueryParticipantAllowListResponse_1_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -68942,15 +69010,17 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryParticipantAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
-		x.MlnodeVersion = value.Message().Interface().(*MLNodeVersion)
+	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+		lv := value.List()
+		clv := lv.(*_QueryParticipantAllowListResponse_1_list)
+		x.Addresses = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -68964,44 +69034,45 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
-		if x.MlnodeVersion == nil {
-			x.MlnodeVersion = new(MLNodeVersion)
+	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+		if x.Addresses == nil {
+			x.Addresses = []string{}
 		}
-		return protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
+		value := &_QueryParticipantAllowListResponse_1_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
-		m := new(MLNodeVersion)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryParticipantAllowListResponse.addresses":
+		list := []string{}
+		return protoreflect.ValueOfList(&_QueryParticipantAllowListResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantAllowListResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantAllowListResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryParticipantAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMLNodeVersionResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantAllowListResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -69009,7 +69080,7 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryParticipantAllowListResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -69020,7 +69091,7 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryParticipantAllowListResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -69032,7 +69103,7 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) IsValid() bool {
+func (x *fastReflection_QueryParticipantAllowListResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -69042,9 +69113,9 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryParticipantAllowListResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
+		x := input.Message.Interface().(*QueryParticipantAllowListResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69056,9 +69127,11 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if x.MlnodeVersion != nil {
-			l = options.Size(x.MlnodeVersion)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.Addresses) > 0 {
+			for _, s := range x.Addresses {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -69070,7 +69143,7 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
+		x := input.Message.Interface().(*QueryParticipantAllowListResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69089,19 +69162,14 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.MlnodeVersion != nil {
-			encoded, err := options.Marshal(x.MlnodeVersion)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
+		if len(x.Addresses) > 0 {
+			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.Addresses[iNdEx])
+				copy(dAtA[i:], x.Addresses[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
+				i--
+				dAtA[i] = 0xa
 			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -69114,7 +69182,7 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
+		x := input.Message.Interface().(*QueryParticipantAllowListResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69146,17 +69214,17 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MlnodeVersion", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -69166,27 +69234,23 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.MlnodeVersion == nil {
-					x.MlnodeVersion = &MLNodeVersion{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MlnodeVersion); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -69224,25 +69288,23 @@ func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryExcludedParticipantsRequest             protoreflect.MessageDescriptor
-	fd_QueryExcludedParticipantsRequest_epoch_index protoreflect.FieldDescriptor
+	md_QueryGetMLNodeVersionRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryExcludedParticipantsRequest = File_inference_inference_query_proto.Messages().ByName("QueryExcludedParticipantsRequest")
-	fd_QueryExcludedParticipantsRequest_epoch_index = md_QueryExcludedParticipantsRequest.Fields().ByName("epoch_index")
+	md_QueryGetMLNodeVersionRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetMLNodeVersionRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryExcludedParticipantsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetMLNodeVersionRequest)(nil)
 
-type fastReflection_QueryExcludedParticipantsRequest QueryExcludedParticipantsRequest
+type fastReflection_QueryGetMLNodeVersionRequest QueryGetMLNodeVersionRequest
 
-func (x *QueryExcludedParticipantsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryExcludedParticipantsRequest)(x)
+func (x *QueryGetMLNodeVersionRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetMLNodeVersionRequest)(x)
 }
 
-func (x *QueryExcludedParticipantsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetMLNodeVersionRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[145]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -69254,43 +69316,43 @@ func (x *QueryExcludedParticipantsRequest) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryExcludedParticipantsRequest_messageType fastReflection_QueryExcludedParticipantsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryExcludedParticipantsRequest_messageType{}
+var _fastReflection_QueryGetMLNodeVersionRequest_messageType fastReflection_QueryGetMLNodeVersionRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMLNodeVersionRequest_messageType{}
 
-type fastReflection_QueryExcludedParticipantsRequest_messageType struct{}
+type fastReflection_QueryGetMLNodeVersionRequest_messageType struct{}
 
-func (x fastReflection_QueryExcludedParticipantsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryExcludedParticipantsRequest)(nil)
+func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetMLNodeVersionRequest)(nil)
 }
-func (x fastReflection_QueryExcludedParticipantsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryExcludedParticipantsRequest)
+func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMLNodeVersionRequest)
 }
-func (x fastReflection_QueryExcludedParticipantsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryExcludedParticipantsRequest
+func (x fastReflection_QueryGetMLNodeVersionRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMLNodeVersionRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryExcludedParticipantsRequest
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMLNodeVersionRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryExcludedParticipantsRequest_messageType
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetMLNodeVersionRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryExcludedParticipantsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryExcludedParticipantsRequest)
+func (x *fastReflection_QueryGetMLNodeVersionRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMLNodeVersionRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryExcludedParticipantsRequest)(x)
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetMLNodeVersionRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -69298,13 +69360,7 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryExcludedParticipantsRequest_epoch_index, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -69318,15 +69374,13 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
-		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -69336,15 +69390,13 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
-		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -69354,16 +69406,13 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -69377,15 +69426,13 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
-		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -69399,40 +69446,36 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryExcludedParticipantsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryExcludedParticipantsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryExcludedParticipantsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryExcludedParticipantsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMLNodeVersionRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -69440,7 +69483,7 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryExcludedParticipantsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -69451,7 +69494,7 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -69463,7 +69506,7 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryExcludedParticipantsRequest) IsValid() bool {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -69473,9 +69516,9 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetMLNodeVersionRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
+		x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69487,9 +69530,6 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -69500,7 +69540,7 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
+		x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69519,11 +69559,6 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
-			i--
-			dAtA[i] = 0x8
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -69535,7 +69570,7 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
+		x := input.Message.Interface().(*QueryGetMLNodeVersionRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69567,31 +69602,12 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-				}
-				x.EpochIndex = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -69627,77 +69643,26 @@ func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoi
 	}
 }
 
-var _ protoreflect.List = (*_QueryExcludedParticipantsResponse_1_list)(nil)
-
-type _QueryExcludedParticipantsResponse_1_list struct {
-	list *[]*ExcludedParticipant
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ExcludedParticipant)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ExcludedParticipant)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ExcludedParticipant)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ExcludedParticipant)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryExcludedParticipantsResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryExcludedParticipantsResponse       protoreflect.MessageDescriptor
-	fd_QueryExcludedParticipantsResponse_items protoreflect.FieldDescriptor
+	md_QueryGetMLNodeVersionResponse                protoreflect.MessageDescriptor
+	fd_QueryGetMLNodeVersionResponse_mlnode_version protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryExcludedParticipantsResponse = File_inference_inference_query_proto.Messages().ByName("QueryExcludedParticipantsResponse")
-	fd_QueryExcludedParticipantsResponse_items = md_QueryExcludedParticipantsResponse.Fields().ByName("items")
+	md_QueryGetMLNodeVersionResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetMLNodeVersionResponse")
+	fd_QueryGetMLNodeVersionResponse_mlnode_version = md_QueryGetMLNodeVersionResponse.Fields().ByName("mlnode_version")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryExcludedParticipantsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetMLNodeVersionResponse)(nil)
 
-type fastReflection_QueryExcludedParticipantsResponse QueryExcludedParticipantsResponse
+type fastReflection_QueryGetMLNodeVersionResponse QueryGetMLNodeVersionResponse
 
-func (x *QueryExcludedParticipantsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryExcludedParticipantsResponse)(x)
+func (x *QueryGetMLNodeVersionResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetMLNodeVersionResponse)(x)
 }
 
-func (x *QueryExcludedParticipantsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetMLNodeVersionResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[146]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -69709,43 +69674,43 @@ func (x *QueryExcludedParticipantsResponse) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryExcludedParticipantsResponse_messageType fastReflection_QueryExcludedParticipantsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryExcludedParticipantsResponse_messageType{}
+var _fastReflection_QueryGetMLNodeVersionResponse_messageType fastReflection_QueryGetMLNodeVersionResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetMLNodeVersionResponse_messageType{}
 
-type fastReflection_QueryExcludedParticipantsResponse_messageType struct{}
+type fastReflection_QueryGetMLNodeVersionResponse_messageType struct{}
 
-func (x fastReflection_QueryExcludedParticipantsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryExcludedParticipantsResponse)(nil)
+func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetMLNodeVersionResponse)(nil)
 }
-func (x fastReflection_QueryExcludedParticipantsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryExcludedParticipantsResponse)
+func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMLNodeVersionResponse)
 }
-func (x fastReflection_QueryExcludedParticipantsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryExcludedParticipantsResponse
+func (x fastReflection_QueryGetMLNodeVersionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMLNodeVersionResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryExcludedParticipantsResponse
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetMLNodeVersionResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryExcludedParticipantsResponse_messageType
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetMLNodeVersionResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryExcludedParticipantsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryExcludedParticipantsResponse)
+func (x *fastReflection_QueryGetMLNodeVersionResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetMLNodeVersionResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryExcludedParticipantsResponse)(x)
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetMLNodeVersionResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -69753,10 +69718,10 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Items) != 0 {
-		value := protoreflect.ValueOfList(&_QueryExcludedParticipantsResponse_1_list{list: &x.Items})
-		if !f(fd_QueryExcludedParticipantsResponse_items, value) {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.MlnodeVersion != nil {
+		value := protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
+		if !f(fd_QueryGetMLNodeVersionResponse_mlnode_version, value) {
 			return
 		}
 	}
@@ -69773,15 +69738,15 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsResponse.items":
-		return len(x.Items) != 0
+	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+		return x.MlnodeVersion != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -69791,15 +69756,15 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsResponse.items":
-		x.Items = nil
+	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+		x.MlnodeVersion = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -69809,19 +69774,16 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryExcludedParticipantsResponse.items":
-		if len(x.Items) == 0 {
-			return protoreflect.ValueOfList(&_QueryExcludedParticipantsResponse_1_list{})
-		}
-		listValue := &_QueryExcludedParticipantsResponse_1_list{list: &x.Items}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+		value := x.MlnodeVersion
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -69835,17 +69797,15 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsResponse.items":
-		lv := value.List()
-		clv := lv.(*_QueryExcludedParticipantsResponse_1_list)
-		x.Items = *clv.list
+	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+		x.MlnodeVersion = value.Message().Interface().(*MLNodeVersion)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -69859,45 +69819,44 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsResponse.items":
-		if x.Items == nil {
-			x.Items = []*ExcludedParticipant{}
+	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+		if x.MlnodeVersion == nil {
+			x.MlnodeVersion = new(MLNodeVersion)
 		}
-		value := &_QueryExcludedParticipantsResponse_1_list{list: &x.Items}
-		return protoreflect.ValueOfList(value)
+		return protoreflect.ValueOfMessage(x.MlnodeVersion.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryExcludedParticipantsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryExcludedParticipantsResponse.items":
-		list := []*ExcludedParticipant{}
-		return protoreflect.ValueOfList(&_QueryExcludedParticipantsResponse_1_list{list: &list})
+	case "inference.inference.QueryGetMLNodeVersionResponse.mlnode_version":
+		m := new(MLNodeVersion)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetMLNodeVersionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetMLNodeVersionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryExcludedParticipantsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryExcludedParticipantsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetMLNodeVersionResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -69905,7 +69864,7 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryExcludedParticipantsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -69916,7 +69875,7 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryExcludedParticipantsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -69928,7 +69887,7 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryExcludedParticipantsResponse) IsValid() bool {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -69938,9 +69897,9 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetMLNodeVersionResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
+		x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69952,11 +69911,9 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if len(x.Items) > 0 {
-			for _, e := range x.Items {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.MlnodeVersion != nil {
+			l = options.Size(x.MlnodeVersion)
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -69968,7 +69925,7 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
+		x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -69987,21 +69944,19 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Items) > 0 {
-			for iNdEx := len(x.Items) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Items[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
+		if x.MlnodeVersion != nil {
+			encoded, err := options.Marshal(x.MlnodeVersion)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
 			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -70014,7 +69969,7 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
+		x := input.Message.Interface().(*QueryGetMLNodeVersionResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70046,15 +70001,15 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetMLNodeVersionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MlnodeVersion", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -70081,8 +70036,10 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Items = append(x.Items, &ExcludedParticipant{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Items[len(x.Items)-1]); err != nil {
+				if x.MlnodeVersion == nil {
+					x.MlnodeVersion = &MLNodeVersion{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.MlnodeVersion); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -70122,23 +70079,23 @@ func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *proto
 }
 
 var (
-	md_QueryActiveConfirmationPoCEventRequest protoreflect.MessageDescriptor
+	md_QueryGetLastUpgradeHeightRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryActiveConfirmationPoCEventRequest = File_inference_inference_query_proto.Messages().ByName("QueryActiveConfirmationPoCEventRequest")
+	md_QueryGetLastUpgradeHeightRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetLastUpgradeHeightRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryActiveConfirmationPoCEventRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetLastUpgradeHeightRequest)(nil)
 
-type fastReflection_QueryActiveConfirmationPoCEventRequest QueryActiveConfirmationPoCEventRequest
+type fastReflection_QueryGetLastUpgradeHeightRequest QueryGetLastUpgradeHeightRequest
 
-func (x *QueryActiveConfirmationPoCEventRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryActiveConfirmationPoCEventRequest)(x)
+func (x *QueryGetLastUpgradeHeightRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetLastUpgradeHeightRequest)(x)
 }
 
-func (x *QueryActiveConfirmationPoCEventRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetLastUpgradeHeightRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[147]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -70150,43 +70107,43 @@ func (x *QueryActiveConfirmationPoCEventRequest) slowProtoReflect() protoreflect
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryActiveConfirmationPoCEventRequest_messageType fastReflection_QueryActiveConfirmationPoCEventRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryActiveConfirmationPoCEventRequest_messageType{}
+var _fastReflection_QueryGetLastUpgradeHeightRequest_messageType fastReflection_QueryGetLastUpgradeHeightRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetLastUpgradeHeightRequest_messageType{}
 
-type fastReflection_QueryActiveConfirmationPoCEventRequest_messageType struct{}
+type fastReflection_QueryGetLastUpgradeHeightRequest_messageType struct{}
 
-func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryActiveConfirmationPoCEventRequest)(nil)
+func (x fastReflection_QueryGetLastUpgradeHeightRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetLastUpgradeHeightRequest)(nil)
 }
-func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryActiveConfirmationPoCEventRequest)
+func (x fastReflection_QueryGetLastUpgradeHeightRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetLastUpgradeHeightRequest)
 }
-func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryActiveConfirmationPoCEventRequest
+func (x fastReflection_QueryGetLastUpgradeHeightRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetLastUpgradeHeightRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryActiveConfirmationPoCEventRequest
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetLastUpgradeHeightRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryActiveConfirmationPoCEventRequest_messageType
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetLastUpgradeHeightRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryActiveConfirmationPoCEventRequest)
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetLastUpgradeHeightRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryActiveConfirmationPoCEventRequest)(x)
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetLastUpgradeHeightRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -70194,7 +70151,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Interface() prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -70208,13 +70165,13 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Range(f func(pro
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -70224,13 +70181,13 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Has(fd protorefl
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -70240,13 +70197,13 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Clear(fd protore
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -70260,13 +70217,13 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Get(descriptor p
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -70280,36 +70237,36 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Set(fd protorefl
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryActiveConfirmationPoCEventRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetLastUpgradeHeightRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -70317,7 +70274,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) WhichOneof(d pro
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -70328,7 +70285,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) GetUnknown() pro
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -70340,7 +70297,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) SetUnknown(field
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) IsValid() bool {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -70350,9 +70307,9 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetLastUpgradeHeightRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
+		x := input.Message.Interface().(*QueryGetLastUpgradeHeightRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70374,7 +70331,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
+		x := input.Message.Interface().(*QueryGetLastUpgradeHeightRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70404,7 +70361,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
+		x := input.Message.Interface().(*QueryGetLastUpgradeHeightRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70436,10 +70393,10 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetLastUpgradeHeightRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetLastUpgradeHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -70478,27 +70435,27 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *
 }
 
 var (
-	md_QueryActiveConfirmationPoCEventResponse           protoreflect.MessageDescriptor
-	fd_QueryActiveConfirmationPoCEventResponse_is_active protoreflect.FieldDescriptor
-	fd_QueryActiveConfirmationPoCEventResponse_event     protoreflect.FieldDescriptor
+	md_QueryGetLastUpgradeHeightResponse                     protoreflect.MessageDescriptor
+	fd_QueryGetLastUpgradeHeightResponse_last_upgrade_height protoreflect.FieldDescriptor
+	fd_QueryGetLastUpgradeHeightResponse_found               protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryActiveConfirmationPoCEventResponse = File_inference_inference_query_proto.Messages().ByName("QueryActiveConfirmationPoCEventResponse")
-	fd_QueryActiveConfirmationPoCEventResponse_is_active = md_QueryActiveConfirmationPoCEventResponse.Fields().ByName("is_active")
-	fd_QueryActiveConfirmationPoCEventResponse_event = md_QueryActiveConfirmationPoCEventResponse.Fields().ByName("event")
+	md_QueryGetLastUpgradeHeightResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetLastUpgradeHeightResponse")
+	fd_QueryGetLastUpgradeHeightResponse_last_upgrade_height = md_QueryGetLastUpgradeHeightResponse.Fields().ByName("last_upgrade_height")
+	fd_QueryGetLastUpgradeHeightResponse_found = md_QueryGetLastUpgradeHeightResponse.Fields().ByName("found")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryActiveConfirmationPoCEventResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryGetLastUpgradeHeightResponse)(nil)
 
-type fastReflection_QueryActiveConfirmationPoCEventResponse QueryActiveConfirmationPoCEventResponse
+type fastReflection_QueryGetLastUpgradeHeightResponse QueryGetLastUpgradeHeightResponse
 
-func (x *QueryActiveConfirmationPoCEventResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryActiveConfirmationPoCEventResponse)(x)
+func (x *QueryGetLastUpgradeHeightResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetLastUpgradeHeightResponse)(x)
 }
 
-func (x *QueryActiveConfirmationPoCEventResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryGetLastUpgradeHeightResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[148]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -70510,43 +70467,43 @@ func (x *QueryActiveConfirmationPoCEventResponse) slowProtoReflect() protoreflec
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryActiveConfirmationPoCEventResponse_messageType fastReflection_QueryActiveConfirmationPoCEventResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryActiveConfirmationPoCEventResponse_messageType{}
+var _fastReflection_QueryGetLastUpgradeHeightResponse_messageType fastReflection_QueryGetLastUpgradeHeightResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetLastUpgradeHeightResponse_messageType{}
 
-type fastReflection_QueryActiveConfirmationPoCEventResponse_messageType struct{}
+type fastReflection_QueryGetLastUpgradeHeightResponse_messageType struct{}
 
-func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryActiveConfirmationPoCEventResponse)(nil)
+func (x fastReflection_QueryGetLastUpgradeHeightResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetLastUpgradeHeightResponse)(nil)
 }
-func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryActiveConfirmationPoCEventResponse)
+func (x fastReflection_QueryGetLastUpgradeHeightResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetLastUpgradeHeightResponse)
 }
-func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryActiveConfirmationPoCEventResponse
+func (x fastReflection_QueryGetLastUpgradeHeightResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetLastUpgradeHeightResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryActiveConfirmationPoCEventResponse
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetLastUpgradeHeightResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryActiveConfirmationPoCEventResponse_messageType
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetLastUpgradeHeightResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryActiveConfirmationPoCEventResponse)
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetLastUpgradeHeightResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryActiveConfirmationPoCEventResponse)(x)
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetLastUpgradeHeightResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -70554,16 +70511,16 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.IsActive != false {
-		value := protoreflect.ValueOfBool(x.IsActive)
-		if !f(fd_QueryActiveConfirmationPoCEventResponse_is_active, value) {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.LastUpgradeHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.LastUpgradeHeight)
+		if !f(fd_QueryGetLastUpgradeHeightResponse_last_upgrade_height, value) {
 			return
 		}
 	}
-	if x.Event != nil {
-		value := protoreflect.ValueOfMessage(x.Event.ProtoReflect())
-		if !f(fd_QueryActiveConfirmationPoCEventResponse_event, value) {
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryGetLastUpgradeHeightResponse_found, value) {
 			return
 		}
 	}
@@ -70580,17 +70537,17 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
-		return x.IsActive != false
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
-		return x.Event != nil
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.last_upgrade_height":
+		return x.LastUpgradeHeight != int64(0)
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.found":
+		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -70600,17 +70557,17 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
-		x.IsActive = false
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
-		x.Event = nil
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.last_upgrade_height":
+		x.LastUpgradeHeight = int64(0)
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.found":
+		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -70620,19 +70577,19 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
-		value := x.IsActive
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.last_upgrade_height":
+		value := x.LastUpgradeHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.found":
+		value := x.Found
 		return protoreflect.ValueOfBool(value)
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
-		value := x.Event
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -70646,17 +70603,17 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
-		x.IsActive = value.Bool()
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
-		x.Event = value.Message().Interface().(*ConfirmationPoCEvent)
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.last_upgrade_height":
+		x.LastUpgradeHeight = value.Int()
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.found":
+		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -70670,48 +70627,44 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
-		if x.Event == nil {
-			x.Event = new(ConfirmationPoCEvent)
-		}
-		return protoreflect.ValueOfMessage(x.Event.ProtoReflect())
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
-		panic(fmt.Errorf("field is_active of message inference.inference.QueryActiveConfirmationPoCEventResponse is not mutable"))
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.last_upgrade_height":
+		panic(fmt.Errorf("field last_upgrade_height of message inference.inference.QueryGetLastUpgradeHeightResponse is not mutable"))
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryGetLastUpgradeHeightResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.last_upgrade_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryGetLastUpgradeHeightResponse.found":
 		return protoreflect.ValueOfBool(false)
-	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
-		m := new(ConfirmationPoCEvent)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetLastUpgradeHeightResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryGetLastUpgradeHeightResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryActiveConfirmationPoCEventResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetLastUpgradeHeightResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -70719,7 +70672,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -70730,7 +70683,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -70742,7 +70695,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) IsValid() bool {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -70752,9 +70705,9 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryGetLastUpgradeHeightResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
+		x := input.Message.Interface().(*QueryGetLastUpgradeHeightResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70766,12 +70719,11 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 		var n int
 		var l int
 		_ = l
-		if x.IsActive {
-			n += 2
+		if x.LastUpgradeHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.LastUpgradeHeight))
 		}
-		if x.Event != nil {
-			l = options.Size(x.Event)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Found {
+			n += 2
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -70783,7 +70735,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
+		x := input.Message.Interface().(*QueryGetLastUpgradeHeightResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70802,28 +70754,19 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Event != nil {
-			encoded, err := options.Marshal(x.Event)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if x.IsActive {
+		if x.Found {
 			i--
-			if x.IsActive {
+			if x.Found {
 				dAtA[i] = 1
 			} else {
 				dAtA[i] = 0
 			}
 			i--
+			dAtA[i] = 0x10
+		}
+		if x.LastUpgradeHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.LastUpgradeHeight))
+			i--
 			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
@@ -70837,7 +70780,7 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
+		x := input.Message.Interface().(*QueryGetLastUpgradeHeightResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -70869,17 +70812,17 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetLastUpgradeHeightResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetLastUpgradeHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LastUpgradeHeight", wireType)
 				}
-				var v int
+				x.LastUpgradeHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -70889,17 +70832,16 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					x.LastUpgradeHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.IsActive = bool(v != 0)
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 				}
-				var msglen int
+				var v int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -70909,28 +70851,12 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					v |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Event == nil {
-					x.Event = &ConfirmationPoCEvent{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Event); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
+				x.Found = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -70967,25 +70893,25 @@ func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods()
 }
 
 var (
-	md_QueryConfirmationPoCEventsRequest             protoreflect.MessageDescriptor
-	fd_QueryConfirmationPoCEventsRequest_epoch_index protoreflect.FieldDescriptor
+	md_QueryExcludedParticipantsRequest             protoreflect.MessageDescriptor
+	fd_QueryExcludedParticipantsRequest_epoch_index protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryConfirmationPoCEventsRequest = File_inference_inference_query_proto.Messages().ByName("QueryConfirmationPoCEventsRequest")
-	fd_QueryConfirmationPoCEventsRequest_epoch_index = md_QueryConfirmationPoCEventsRequest.Fields().ByName("epoch_index")
+	md_QueryExcludedParticipantsRequest = File_inference_inference_query_proto.Messages().ByName("QueryExcludedParticipantsRequest")
+	fd_QueryExcludedParticipantsRequest_epoch_index = md_QueryExcludedParticipantsRequest.Fields().ByName("epoch_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryConfirmationPoCEventsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryExcludedParticipantsRequest)(nil)
 
-type fastReflection_QueryConfirmationPoCEventsRequest QueryConfirmationPoCEventsRequest
+type fastReflection_QueryExcludedParticipantsRequest QueryExcludedParticipantsRequest
 
-func (x *QueryConfirmationPoCEventsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryConfirmationPoCEventsRequest)(x)
+func (x *QueryExcludedParticipantsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryExcludedParticipantsRequest)(x)
 }
 
-func (x *QueryConfirmationPoCEventsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryExcludedParticipantsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[149]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -70997,43 +70923,43 @@ func (x *QueryConfirmationPoCEventsRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryConfirmationPoCEventsRequest_messageType fastReflection_QueryConfirmationPoCEventsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryConfirmationPoCEventsRequest_messageType{}
+var _fastReflection_QueryExcludedParticipantsRequest_messageType fastReflection_QueryExcludedParticipantsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryExcludedParticipantsRequest_messageType{}
 
-type fastReflection_QueryConfirmationPoCEventsRequest_messageType struct{}
+type fastReflection_QueryExcludedParticipantsRequest_messageType struct{}
 
-func (x fastReflection_QueryConfirmationPoCEventsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryConfirmationPoCEventsRequest)(nil)
+func (x fastReflection_QueryExcludedParticipantsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryExcludedParticipantsRequest)(nil)
 }
-func (x fastReflection_QueryConfirmationPoCEventsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryConfirmationPoCEventsRequest)
+func (x fastReflection_QueryExcludedParticipantsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryExcludedParticipantsRequest)
 }
-func (x fastReflection_QueryConfirmationPoCEventsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryConfirmationPoCEventsRequest
+func (x fastReflection_QueryExcludedParticipantsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryExcludedParticipantsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryConfirmationPoCEventsRequest
+func (x *fastReflection_QueryExcludedParticipantsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryExcludedParticipantsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryConfirmationPoCEventsRequest_messageType
+func (x *fastReflection_QueryExcludedParticipantsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryExcludedParticipantsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryConfirmationPoCEventsRequest)
+func (x *fastReflection_QueryExcludedParticipantsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryExcludedParticipantsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryConfirmationPoCEventsRequest)(x)
+func (x *fastReflection_QueryExcludedParticipantsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryExcludedParticipantsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -71041,10 +70967,10 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryExcludedParticipantsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.EpochIndex != uint64(0) {
 		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryConfirmationPoCEventsRequest_epoch_index, value) {
+		if !f(fd_QueryExcludedParticipantsRequest_epoch_index, value) {
 			return
 		}
 	}
@@ -71061,15 +70987,15 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryExcludedParticipantsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
 		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -71079,15 +71005,15 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryExcludedParticipantsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
 		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -71097,16 +71023,16 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryExcludedParticipantsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
 		value := x.EpochIndex
 		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -71120,15 +71046,15 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryExcludedParticipantsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
 		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -71142,40 +71068,40 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryExcludedParticipantsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryConfirmationPoCEventsRequest is not mutable"))
+	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryExcludedParticipantsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryExcludedParticipantsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+	case "inference.inference.QueryExcludedParticipantsRequest.epoch_index":
 		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryExcludedParticipantsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryConfirmationPoCEventsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryExcludedParticipantsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -71183,7 +71109,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryExcludedParticipantsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -71194,7 +71120,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryExcludedParticipantsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -71206,7 +71132,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) IsValid() bool {
+func (x *fastReflection_QueryExcludedParticipantsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -71216,9 +71142,9 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryConfirmationPoCEventsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryExcludedParticipantsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryConfirmationPoCEventsRequest)
+		x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71243,7 +71169,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryConfirmationPoCEventsRequest)
+		x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71278,7 +71204,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryConfirmationPoCEventsRequest)
+		x := input.Message.Interface().(*QueryExcludedParticipantsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71310,10 +71236,10 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -71370,77 +71296,77 @@ func (x *fastReflection_QueryConfirmationPoCEventsRequest) ProtoMethods() *proto
 	}
 }
 
-var _ protoreflect.List = (*_QueryConfirmationPoCEventsResponse_1_list)(nil)
+var _ protoreflect.List = (*_QueryExcludedParticipantsResponse_1_list)(nil)
 
-type _QueryConfirmationPoCEventsResponse_1_list struct {
-	list *[]*ConfirmationPoCEvent
+type _QueryExcludedParticipantsResponse_1_list struct {
+	list *[]*ExcludedParticipant
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) Len() int {
+func (x *_QueryExcludedParticipantsResponse_1_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_QueryExcludedParticipantsResponse_1_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_QueryExcludedParticipantsResponse_1_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ConfirmationPoCEvent)
+	concreteValue := valueUnwrapped.Interface().(*ExcludedParticipant)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) Append(value protoreflect.Value) {
+func (x *_QueryExcludedParticipantsResponse_1_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ConfirmationPoCEvent)
+	concreteValue := valueUnwrapped.Interface().(*ExcludedParticipant)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ConfirmationPoCEvent)
+func (x *_QueryExcludedParticipantsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ExcludedParticipant)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) Truncate(n int) {
+func (x *_QueryExcludedParticipantsResponse_1_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ConfirmationPoCEvent)
+func (x *_QueryExcludedParticipantsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ExcludedParticipant)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryConfirmationPoCEventsResponse_1_list) IsValid() bool {
+func (x *_QueryExcludedParticipantsResponse_1_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryConfirmationPoCEventsResponse        protoreflect.MessageDescriptor
-	fd_QueryConfirmationPoCEventsResponse_events protoreflect.FieldDescriptor
+	md_QueryExcludedParticipantsResponse       protoreflect.MessageDescriptor
+	fd_QueryExcludedParticipantsResponse_items protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryConfirmationPoCEventsResponse = File_inference_inference_query_proto.Messages().ByName("QueryConfirmationPoCEventsResponse")
-	fd_QueryConfirmationPoCEventsResponse_events = md_QueryConfirmationPoCEventsResponse.Fields().ByName("events")
+	md_QueryExcludedParticipantsResponse = File_inference_inference_query_proto.Messages().ByName("QueryExcludedParticipantsResponse")
+	fd_QueryExcludedParticipantsResponse_items = md_QueryExcludedParticipantsResponse.Fields().ByName("items")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryConfirmationPoCEventsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryExcludedParticipantsResponse)(nil)
 
-type fastReflection_QueryConfirmationPoCEventsResponse QueryConfirmationPoCEventsResponse
+type fastReflection_QueryExcludedParticipantsResponse QueryExcludedParticipantsResponse
 
-func (x *QueryConfirmationPoCEventsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryConfirmationPoCEventsResponse)(x)
+func (x *QueryExcludedParticipantsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryExcludedParticipantsResponse)(x)
 }
 
-func (x *QueryConfirmationPoCEventsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryExcludedParticipantsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[150]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -71452,43 +71378,43 @@ func (x *QueryConfirmationPoCEventsResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryConfirmationPoCEventsResponse_messageType fastReflection_QueryConfirmationPoCEventsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryConfirmationPoCEventsResponse_messageType{}
+var _fastReflection_QueryExcludedParticipantsResponse_messageType fastReflection_QueryExcludedParticipantsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryExcludedParticipantsResponse_messageType{}
 
-type fastReflection_QueryConfirmationPoCEventsResponse_messageType struct{}
+type fastReflection_QueryExcludedParticipantsResponse_messageType struct{}
 
-func (x fastReflection_QueryConfirmationPoCEventsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryConfirmationPoCEventsResponse)(nil)
+func (x fastReflection_QueryExcludedParticipantsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryExcludedParticipantsResponse)(nil)
 }
-func (x fastReflection_QueryConfirmationPoCEventsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryConfirmationPoCEventsResponse)
+func (x fastReflection_QueryExcludedParticipantsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryExcludedParticipantsResponse)
 }
-func (x fastReflection_QueryConfirmationPoCEventsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryConfirmationPoCEventsResponse
+func (x fastReflection_QueryExcludedParticipantsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryExcludedParticipantsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryConfirmationPoCEventsResponse
+func (x *fastReflection_QueryExcludedParticipantsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryExcludedParticipantsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryConfirmationPoCEventsResponse_messageType
+func (x *fastReflection_QueryExcludedParticipantsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryExcludedParticipantsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryConfirmationPoCEventsResponse)
+func (x *fastReflection_QueryExcludedParticipantsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryExcludedParticipantsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryConfirmationPoCEventsResponse)(x)
+func (x *fastReflection_QueryExcludedParticipantsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryExcludedParticipantsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -71496,10 +71422,10 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Events) != 0 {
-		value := protoreflect.ValueOfList(&_QueryConfirmationPoCEventsResponse_1_list{list: &x.Events})
-		if !f(fd_QueryConfirmationPoCEventsResponse_events, value) {
+func (x *fastReflection_QueryExcludedParticipantsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Items) != 0 {
+		value := protoreflect.ValueOfList(&_QueryExcludedParticipantsResponse_1_list{list: &x.Items})
+		if !f(fd_QueryExcludedParticipantsResponse_items, value) {
 			return
 		}
 	}
@@ -71516,15 +71442,15 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryExcludedParticipantsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
-		return len(x.Events) != 0
+	case "inference.inference.QueryExcludedParticipantsResponse.items":
+		return len(x.Items) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -71534,15 +71460,15 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryExcludedParticipantsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
-		x.Events = nil
+	case "inference.inference.QueryExcludedParticipantsResponse.items":
+		x.Items = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -71552,19 +71478,19 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryExcludedParticipantsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
-		if len(x.Events) == 0 {
-			return protoreflect.ValueOfList(&_QueryConfirmationPoCEventsResponse_1_list{})
+	case "inference.inference.QueryExcludedParticipantsResponse.items":
+		if len(x.Items) == 0 {
+			return protoreflect.ValueOfList(&_QueryExcludedParticipantsResponse_1_list{})
 		}
-		listValue := &_QueryConfirmationPoCEventsResponse_1_list{list: &x.Events}
+		listValue := &_QueryExcludedParticipantsResponse_1_list{list: &x.Items}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -71578,17 +71504,17 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryExcludedParticipantsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+	case "inference.inference.QueryExcludedParticipantsResponse.items":
 		lv := value.List()
-		clv := lv.(*_QueryConfirmationPoCEventsResponse_1_list)
-		x.Events = *clv.list
+		clv := lv.(*_QueryExcludedParticipantsResponse_1_list)
+		x.Items = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -71602,45 +71528,45 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryExcludedParticipantsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
-		if x.Events == nil {
-			x.Events = []*ConfirmationPoCEvent{}
+	case "inference.inference.QueryExcludedParticipantsResponse.items":
+		if x.Items == nil {
+			x.Items = []*ExcludedParticipant{}
 		}
-		value := &_QueryConfirmationPoCEventsResponse_1_list{list: &x.Events}
+		value := &_QueryExcludedParticipantsResponse_1_list{list: &x.Items}
 		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryExcludedParticipantsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
-		list := []*ConfirmationPoCEvent{}
-		return protoreflect.ValueOfList(&_QueryConfirmationPoCEventsResponse_1_list{list: &list})
+	case "inference.inference.QueryExcludedParticipantsResponse.items":
+		list := []*ExcludedParticipant{}
+		return protoreflect.ValueOfList(&_QueryExcludedParticipantsResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryExcludedParticipantsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryExcludedParticipantsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryExcludedParticipantsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryConfirmationPoCEventsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryExcludedParticipantsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -71648,7 +71574,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryExcludedParticipantsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -71659,7 +71585,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryExcludedParticipantsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -71671,7 +71597,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) IsValid() bool {
+func (x *fastReflection_QueryExcludedParticipantsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -71681,9 +71607,9 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryExcludedParticipantsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryConfirmationPoCEventsResponse)
+		x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71695,8 +71621,8 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if len(x.Events) > 0 {
-			for _, e := range x.Events {
+		if len(x.Items) > 0 {
+			for _, e := range x.Items {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -71711,7 +71637,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryConfirmationPoCEventsResponse)
+		x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71730,9 +71656,9 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Events) > 0 {
-			for iNdEx := len(x.Events) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Events[iNdEx])
+		if len(x.Items) > 0 {
+			for iNdEx := len(x.Items) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Items[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71757,7 +71683,7 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryConfirmationPoCEventsResponse)
+		x := input.Message.Interface().(*QueryExcludedParticipantsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -71789,15 +71715,15 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryExcludedParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -71824,8 +71750,8 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Events = append(x.Events, &ConfirmationPoCEvent{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Events[len(x.Events)-1]); err != nil {
+				x.Items = append(x.Items, &ExcludedParticipant{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Items[len(x.Items)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -71864,79 +71790,24 @@ func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *prot
 	}
 }
 
-var _ protoreflect.List = (*_ParticipantWithBalance_2_list)(nil)
-
-type _ParticipantWithBalance_2_list struct {
-	list *[]*v1beta11.Coin
-}
-
-func (x *_ParticipantWithBalance_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_ParticipantWithBalance_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_ParticipantWithBalance_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*v1beta11.Coin)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_ParticipantWithBalance_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*v1beta11.Coin)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_ParticipantWithBalance_2_list) AppendMutable() protoreflect.Value {
-	v := new(v1beta11.Coin)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_ParticipantWithBalance_2_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_ParticipantWithBalance_2_list) NewElement() protoreflect.Value {
-	v := new(v1beta11.Coin)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_ParticipantWithBalance_2_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_ParticipantWithBalance             protoreflect.MessageDescriptor
-	fd_ParticipantWithBalance_participant protoreflect.FieldDescriptor
-	fd_ParticipantWithBalance_balances    protoreflect.FieldDescriptor
+	md_QueryActiveConfirmationPoCEventRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_ParticipantWithBalance = File_inference_inference_query_proto.Messages().ByName("ParticipantWithBalance")
-	fd_ParticipantWithBalance_participant = md_ParticipantWithBalance.Fields().ByName("participant")
-	fd_ParticipantWithBalance_balances = md_ParticipantWithBalance.Fields().ByName("balances")
+	md_QueryActiveConfirmationPoCEventRequest = File_inference_inference_query_proto.Messages().ByName("QueryActiveConfirmationPoCEventRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_ParticipantWithBalance)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryActiveConfirmationPoCEventRequest)(nil)
 
-type fastReflection_ParticipantWithBalance ParticipantWithBalance
+type fastReflection_QueryActiveConfirmationPoCEventRequest QueryActiveConfirmationPoCEventRequest
 
-func (x *ParticipantWithBalance) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_ParticipantWithBalance)(x)
+func (x *QueryActiveConfirmationPoCEventRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryActiveConfirmationPoCEventRequest)(x)
 }
 
-func (x *ParticipantWithBalance) slowProtoReflect() protoreflect.Message {
+func (x *QueryActiveConfirmationPoCEventRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[151]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -71948,43 +71819,43 @@ func (x *ParticipantWithBalance) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_ParticipantWithBalance_messageType fastReflection_ParticipantWithBalance_messageType
-var _ protoreflect.MessageType = fastReflection_ParticipantWithBalance_messageType{}
+var _fastReflection_QueryActiveConfirmationPoCEventRequest_messageType fastReflection_QueryActiveConfirmationPoCEventRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryActiveConfirmationPoCEventRequest_messageType{}
 
-type fastReflection_ParticipantWithBalance_messageType struct{}
+type fastReflection_QueryActiveConfirmationPoCEventRequest_messageType struct{}
 
-func (x fastReflection_ParticipantWithBalance_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_ParticipantWithBalance)(nil)
+func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryActiveConfirmationPoCEventRequest)(nil)
 }
-func (x fastReflection_ParticipantWithBalance_messageType) New() protoreflect.Message {
-	return new(fastReflection_ParticipantWithBalance)
+func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryActiveConfirmationPoCEventRequest)
 }
-func (x fastReflection_ParticipantWithBalance_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_ParticipantWithBalance
+func (x fastReflection_QueryActiveConfirmationPoCEventRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryActiveConfirmationPoCEventRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_ParticipantWithBalance) Descriptor() protoreflect.MessageDescriptor {
-	return md_ParticipantWithBalance
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryActiveConfirmationPoCEventRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_ParticipantWithBalance) Type() protoreflect.MessageType {
-	return _fastReflection_ParticipantWithBalance_messageType
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryActiveConfirmationPoCEventRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_ParticipantWithBalance) New() protoreflect.Message {
-	return new(fastReflection_ParticipantWithBalance)
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryActiveConfirmationPoCEventRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_ParticipantWithBalance) Interface() protoreflect.ProtoMessage {
-	return (*ParticipantWithBalance)(x)
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryActiveConfirmationPoCEventRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -71992,19 +71863,7 @@ func (x *fastReflection_ParticipantWithBalance) Interface() protoreflect.ProtoMe
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_ParticipantWithBalance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Participant != nil {
-		value := protoreflect.ValueOfMessage(x.Participant.ProtoReflect())
-		if !f(fd_ParticipantWithBalance_participant, value) {
-			return
-		}
-	}
-	if len(x.Balances) != 0 {
-		value := protoreflect.ValueOfList(&_ParticipantWithBalance_2_list{list: &x.Balances})
-		if !f(fd_ParticipantWithBalance_balances, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -72018,17 +71877,13 @@ func (x *fastReflection_ParticipantWithBalance) Range(f func(protoreflect.FieldD
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_ParticipantWithBalance) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantWithBalance.participant":
-		return x.Participant != nil
-	case "inference.inference.ParticipantWithBalance.balances":
-		return len(x.Balances) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -72038,17 +71893,13 @@ func (x *fastReflection_ParticipantWithBalance) Has(fd protoreflect.FieldDescrip
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantWithBalance) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantWithBalance.participant":
-		x.Participant = nil
-	case "inference.inference.ParticipantWithBalance.balances":
-		x.Balances = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -72058,22 +71909,13 @@ func (x *fastReflection_ParticipantWithBalance) Clear(fd protoreflect.FieldDescr
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_ParticipantWithBalance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.ParticipantWithBalance.participant":
-		value := x.Participant
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.ParticipantWithBalance.balances":
-		if len(x.Balances) == 0 {
-			return protoreflect.ValueOfList(&_ParticipantWithBalance_2_list{})
-		}
-		listValue := &_ParticipantWithBalance_2_list{list: &x.Balances}
-		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -72087,19 +71929,13 @@ func (x *fastReflection_ParticipantWithBalance) Get(descriptor protoreflect.Fiel
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantWithBalance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantWithBalance.participant":
-		x.Participant = value.Message().Interface().(*Participant)
-	case "inference.inference.ParticipantWithBalance.balances":
-		lv := value.List()
-		clv := lv.(*_ParticipantWithBalance_2_list)
-		x.Balances = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -72113,53 +71949,36 @@ func (x *fastReflection_ParticipantWithBalance) Set(fd protoreflect.FieldDescrip
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantWithBalance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantWithBalance.participant":
-		if x.Participant == nil {
-			x.Participant = new(Participant)
-		}
-		return protoreflect.ValueOfMessage(x.Participant.ProtoReflect())
-	case "inference.inference.ParticipantWithBalance.balances":
-		if x.Balances == nil {
-			x.Balances = []*v1beta11.Coin{}
-		}
-		value := &_ParticipantWithBalance_2_list{list: &x.Balances}
-		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_ParticipantWithBalance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.ParticipantWithBalance.participant":
-		m := new(Participant)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.ParticipantWithBalance.balances":
-		list := []*v1beta11.Coin{}
-		return protoreflect.ValueOfList(&_ParticipantWithBalance_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_ParticipantWithBalance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParticipantWithBalance", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryActiveConfirmationPoCEventRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -72167,7 +71986,7 @@ func (x *fastReflection_ParticipantWithBalance) WhichOneof(d protoreflect.OneofD
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_ParticipantWithBalance) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -72178,7 +71997,7 @@ func (x *fastReflection_ParticipantWithBalance) GetUnknown() protoreflect.RawFie
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_ParticipantWithBalance) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -72190,7 +72009,7 @@ func (x *fastReflection_ParticipantWithBalance) SetUnknown(fields protoreflect.R
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_ParticipantWithBalance) IsValid() bool {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -72200,9 +72019,9 @@ func (x *fastReflection_ParticipantWithBalance) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryActiveConfirmationPoCEventRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*ParticipantWithBalance)
+		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72214,16 +72033,6 @@ func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Metho
 		var n int
 		var l int
 		_ = l
-		if x.Participant != nil {
-			l = options.Size(x.Participant)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.Balances) > 0 {
-			for _, e := range x.Balances {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -72234,7 +72043,7 @@ func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Metho
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*ParticipantWithBalance)
+		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72253,36 +72062,6 @@ func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Metho
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Balances) > 0 {
-			for iNdEx := len(x.Balances) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Balances[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x12
-			}
-		}
-		if x.Participant != nil {
-			encoded, err := options.Marshal(x.Participant)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -72294,7 +72073,7 @@ func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Metho
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*ParticipantWithBalance)
+		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72326,82 +72105,12 @@ func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Metho
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantWithBalance: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantWithBalance: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Participant == nil {
-					x.Participant = &Participant{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Participant); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Balances = append(x.Balances, &v1beta11.Coin{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Balances[len(x.Balances)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -72438,25 +72147,27 @@ func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Metho
 }
 
 var (
-	md_QueryParticipantsWithBalancesRequest            protoreflect.MessageDescriptor
-	fd_QueryParticipantsWithBalancesRequest_pagination protoreflect.FieldDescriptor
+	md_QueryActiveConfirmationPoCEventResponse           protoreflect.MessageDescriptor
+	fd_QueryActiveConfirmationPoCEventResponse_is_active protoreflect.FieldDescriptor
+	fd_QueryActiveConfirmationPoCEventResponse_event     protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryParticipantsWithBalancesRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsWithBalancesRequest")
-	fd_QueryParticipantsWithBalancesRequest_pagination = md_QueryParticipantsWithBalancesRequest.Fields().ByName("pagination")
+	md_QueryActiveConfirmationPoCEventResponse = File_inference_inference_query_proto.Messages().ByName("QueryActiveConfirmationPoCEventResponse")
+	fd_QueryActiveConfirmationPoCEventResponse_is_active = md_QueryActiveConfirmationPoCEventResponse.Fields().ByName("is_active")
+	fd_QueryActiveConfirmationPoCEventResponse_event = md_QueryActiveConfirmationPoCEventResponse.Fields().ByName("event")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryParticipantsWithBalancesRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryActiveConfirmationPoCEventResponse)(nil)
 
-type fastReflection_QueryParticipantsWithBalancesRequest QueryParticipantsWithBalancesRequest
+type fastReflection_QueryActiveConfirmationPoCEventResponse QueryActiveConfirmationPoCEventResponse
 
-func (x *QueryParticipantsWithBalancesRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsWithBalancesRequest)(x)
+func (x *QueryActiveConfirmationPoCEventResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryActiveConfirmationPoCEventResponse)(x)
 }
 
-func (x *QueryParticipantsWithBalancesRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryActiveConfirmationPoCEventResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[152]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -72468,43 +72179,43 @@ func (x *QueryParticipantsWithBalancesRequest) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryParticipantsWithBalancesRequest_messageType fastReflection_QueryParticipantsWithBalancesRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryParticipantsWithBalancesRequest_messageType{}
+var _fastReflection_QueryActiveConfirmationPoCEventResponse_messageType fastReflection_QueryActiveConfirmationPoCEventResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryActiveConfirmationPoCEventResponse_messageType{}
 
-type fastReflection_QueryParticipantsWithBalancesRequest_messageType struct{}
+type fastReflection_QueryActiveConfirmationPoCEventResponse_messageType struct{}
 
-func (x fastReflection_QueryParticipantsWithBalancesRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsWithBalancesRequest)(nil)
+func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryActiveConfirmationPoCEventResponse)(nil)
 }
-func (x fastReflection_QueryParticipantsWithBalancesRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsWithBalancesRequest)
+func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryActiveConfirmationPoCEventResponse)
 }
-func (x fastReflection_QueryParticipantsWithBalancesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsWithBalancesRequest
+func (x fastReflection_QueryActiveConfirmationPoCEventResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryActiveConfirmationPoCEventResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsWithBalancesRequest
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryActiveConfirmationPoCEventResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryParticipantsWithBalancesRequest_messageType
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryActiveConfirmationPoCEventResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsWithBalancesRequest)
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryActiveConfirmationPoCEventResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryParticipantsWithBalancesRequest)(x)
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryActiveConfirmationPoCEventResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -72512,10 +72223,16 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryParticipantsWithBalancesRequest_pagination, value) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.IsActive != false {
+		value := protoreflect.ValueOfBool(x.IsActive)
+		if !f(fd_QueryActiveConfirmationPoCEventResponse_is_active, value) {
+			return
+		}
+	}
+	if x.Event != nil {
+		value := protoreflect.ValueOfMessage(x.Event.ProtoReflect())
+		if !f(fd_QueryActiveConfirmationPoCEventResponse_event, value) {
 			return
 		}
 	}
@@ -72532,15 +72249,17 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
-		return x.Pagination != nil
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+		return x.IsActive != false
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
+		return x.Event != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -72550,15 +72269,17 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
-		x.Pagination = nil
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+		x.IsActive = false
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
+		x.Event = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -72568,16 +72289,19 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
-		value := x.Pagination
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+		value := x.IsActive
+		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
+		value := x.Event
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -72591,15 +72315,17 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+		x.IsActive = value.Bool()
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
+		x.Event = value.Message().Interface().(*ConfirmationPoCEvent)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -72613,44 +72339,48 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageRequest)
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
+		if x.Event == nil {
+			x.Event = new(ConfirmationPoCEvent)
 		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		return protoreflect.ValueOfMessage(x.Event.ProtoReflect())
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+		panic(fmt.Errorf("field is_active of message inference.inference.QueryActiveConfirmationPoCEventResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
-		m := new(v1beta1.PageRequest)
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.is_active":
+		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryActiveConfirmationPoCEventResponse.event":
+		m := new(ConfirmationPoCEvent)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryActiveConfirmationPoCEventResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryActiveConfirmationPoCEventResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsWithBalancesRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryActiveConfirmationPoCEventResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -72658,7 +72388,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -72669,7 +72399,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -72681,7 +72411,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) IsValid() bool {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -72691,9 +72421,9 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryActiveConfirmationPoCEventResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryParticipantsWithBalancesRequest)
+		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72705,8 +72435,11 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 		var n int
 		var l int
 		_ = l
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
+		if x.IsActive {
+			n += 2
+		}
+		if x.Event != nil {
+			l = options.Size(x.Event)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
@@ -72719,7 +72452,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsWithBalancesRequest)
+		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72738,8 +72471,8 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
+		if x.Event != nil {
+			encoded, err := options.Marshal(x.Event)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72750,7 +72483,17 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if x.IsActive {
+			i--
+			if x.IsActive {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -72763,7 +72506,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsWithBalancesRequest)
+		x := input.Message.Interface().(*QueryActiveConfirmationPoCEventResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -72795,15 +72538,35 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.IsActive = bool(v != 0)
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -72830,10 +72593,10 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageRequest{}
+				if x.Event == nil {
+					x.Event = &ConfirmationPoCEvent{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Event); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -72872,81 +72635,26 @@ func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *pr
 	}
 }
 
-var _ protoreflect.List = (*_QueryParticipantsWithBalancesResponse_1_list)(nil)
-
-type _QueryParticipantsWithBalancesResponse_1_list struct {
-	list *[]*ParticipantWithBalance
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ParticipantWithBalance)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*ParticipantWithBalance)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(ParticipantWithBalance)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) NewElement() protoreflect.Value {
-	v := new(ParticipantWithBalance)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_QueryParticipantsWithBalancesResponse_1_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_QueryParticipantsWithBalancesResponse              protoreflect.MessageDescriptor
-	fd_QueryParticipantsWithBalancesResponse_participants protoreflect.FieldDescriptor
-	fd_QueryParticipantsWithBalancesResponse_pagination   protoreflect.FieldDescriptor
-	fd_QueryParticipantsWithBalancesResponse_block_height protoreflect.FieldDescriptor
+	md_QueryConfirmationPoCEventsRequest             protoreflect.MessageDescriptor
+	fd_QueryConfirmationPoCEventsRequest_epoch_index protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryParticipantsWithBalancesResponse = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsWithBalancesResponse")
-	fd_QueryParticipantsWithBalancesResponse_participants = md_QueryParticipantsWithBalancesResponse.Fields().ByName("participants")
-	fd_QueryParticipantsWithBalancesResponse_pagination = md_QueryParticipantsWithBalancesResponse.Fields().ByName("pagination")
-	fd_QueryParticipantsWithBalancesResponse_block_height = md_QueryParticipantsWithBalancesResponse.Fields().ByName("block_height")
+	md_QueryConfirmationPoCEventsRequest = File_inference_inference_query_proto.Messages().ByName("QueryConfirmationPoCEventsRequest")
+	fd_QueryConfirmationPoCEventsRequest_epoch_index = md_QueryConfirmationPoCEventsRequest.Fields().ByName("epoch_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryParticipantsWithBalancesResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryConfirmationPoCEventsRequest)(nil)
 
-type fastReflection_QueryParticipantsWithBalancesResponse QueryParticipantsWithBalancesResponse
+type fastReflection_QueryConfirmationPoCEventsRequest QueryConfirmationPoCEventsRequest
 
-func (x *QueryParticipantsWithBalancesResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsWithBalancesResponse)(x)
+func (x *QueryConfirmationPoCEventsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryConfirmationPoCEventsRequest)(x)
 }
 
-func (x *QueryParticipantsWithBalancesResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryConfirmationPoCEventsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[153]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -72958,43 +72666,43 @@ func (x *QueryParticipantsWithBalancesResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryParticipantsWithBalancesResponse_messageType fastReflection_QueryParticipantsWithBalancesResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryParticipantsWithBalancesResponse_messageType{}
+var _fastReflection_QueryConfirmationPoCEventsRequest_messageType fastReflection_QueryConfirmationPoCEventsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryConfirmationPoCEventsRequest_messageType{}
 
-type fastReflection_QueryParticipantsWithBalancesResponse_messageType struct{}
+type fastReflection_QueryConfirmationPoCEventsRequest_messageType struct{}
 
-func (x fastReflection_QueryParticipantsWithBalancesResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryParticipantsWithBalancesResponse)(nil)
+func (x fastReflection_QueryConfirmationPoCEventsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryConfirmationPoCEventsRequest)(nil)
 }
-func (x fastReflection_QueryParticipantsWithBalancesResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsWithBalancesResponse)
+func (x fastReflection_QueryConfirmationPoCEventsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryConfirmationPoCEventsRequest)
 }
-func (x fastReflection_QueryParticipantsWithBalancesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsWithBalancesResponse
+func (x fastReflection_QueryConfirmationPoCEventsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryConfirmationPoCEventsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryParticipantsWithBalancesResponse
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryConfirmationPoCEventsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryParticipantsWithBalancesResponse_messageType
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryConfirmationPoCEventsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryParticipantsWithBalancesResponse)
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryConfirmationPoCEventsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryParticipantsWithBalancesResponse)(x)
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryConfirmationPoCEventsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -73002,22 +72710,10 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Participants) != 0 {
-		value := protoreflect.ValueOfList(&_QueryParticipantsWithBalancesResponse_1_list{list: &x.Participants})
-		if !f(fd_QueryParticipantsWithBalancesResponse_participants, value) {
-			return
-		}
-	}
-	if x.Pagination != nil {
-		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-		if !f(fd_QueryParticipantsWithBalancesResponse_pagination, value) {
-			return
-		}
-	}
-	if x.BlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.BlockHeight)
-		if !f(fd_QueryParticipantsWithBalancesResponse_block_height, value) {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_QueryConfirmationPoCEventsRequest_epoch_index, value) {
 			return
 		}
 	}
@@ -73034,19 +72730,15 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
-		return len(x.Participants) != 0
-	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
-		return x.Pagination != nil
-	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
-		return x.BlockHeight != int64(0)
+	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -73056,19 +72748,15 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
-		x.Participants = nil
-	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
-		x.Pagination = nil
-	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
-		x.BlockHeight = int64(0)
+	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -73078,25 +72766,16 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
-		if len(x.Participants) == 0 {
-			return protoreflect.ValueOfList(&_QueryParticipantsWithBalancesResponse_1_list{})
-		}
-		listValue := &_QueryParticipantsWithBalancesResponse_1_list{list: &x.Participants}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
-		value := x.Pagination
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
-		value := x.BlockHeight
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -73110,21 +72789,15 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
-		lv := value.List()
-		clv := lv.(*_QueryParticipantsWithBalancesResponse_1_list)
-		x.Participants = *clv.list
-	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
-		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
-	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
-		x.BlockHeight = value.Int()
+	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -73138,57 +72811,40 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
-		if x.Participants == nil {
-			x.Participants = []*ParticipantWithBalance{}
-		}
-		value := &_QueryParticipantsWithBalancesResponse_1_list{list: &x.Participants}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
-		if x.Pagination == nil {
-			x.Pagination = new(v1beta1.PageResponse)
-		}
-		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
-	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
-		panic(fmt.Errorf("field block_height of message inference.inference.QueryParticipantsWithBalancesResponse is not mutable"))
+	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryConfirmationPoCEventsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
-		list := []*ParticipantWithBalance{}
-		return protoreflect.ValueOfList(&_QueryParticipantsWithBalancesResponse_1_list{list: &list})
-	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
-		m := new(v1beta1.PageResponse)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryConfirmationPoCEventsRequest.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsWithBalancesResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryConfirmationPoCEventsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -73196,7 +72852,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -73207,7 +72863,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -73219,7 +72875,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) IsValid() bool {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -73229,9 +72885,9 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryConfirmationPoCEventsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryParticipantsWithBalancesResponse)
+		x := input.Message.Interface().(*QueryConfirmationPoCEventsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -73243,18 +72899,8 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
-		if len(x.Participants) > 0 {
-			for _, e := range x.Participants {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.Pagination != nil {
-			l = options.Size(x.Pagination)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.BlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.BlockHeight))
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -73266,7 +72912,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsWithBalancesResponse)
+		x := input.Message.Interface().(*QueryConfirmationPoCEventsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -73285,40 +72931,10 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.BlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
-			i--
-			dAtA[i] = 0x18
-		}
-		if x.Pagination != nil {
-			encoded, err := options.Marshal(x.Pagination)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
 			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Participants) > 0 {
-			for iNdEx := len(x.Participants) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Participants[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0xa
-			}
+			dAtA[i] = 0x8
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -73331,7 +72947,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryParticipantsWithBalancesResponse)
+		x := input.Message.Interface().(*QueryConfirmationPoCEventsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -73363,87 +72979,17 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Participants = append(x.Participants, &ParticipantWithBalance{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Participants[len(x.Participants)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.Pagination == nil {
-					x.Pagination = &v1beta1.PageResponse{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 3:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 				}
-				x.BlockHeight = 0
+				x.EpochIndex = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -73453,7 +72999,7 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.BlockHeight |= int64(b&0x7F) << shift
+					x.EpochIndex |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -73493,26 +73039,77 @@ func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *p
 	}
 }
 
+var _ protoreflect.List = (*_QueryConfirmationPoCEventsResponse_1_list)(nil)
+
+type _QueryConfirmationPoCEventsResponse_1_list struct {
+	list *[]*ConfirmationPoCEvent
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ConfirmationPoCEvent)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ConfirmationPoCEvent)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ConfirmationPoCEvent)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ConfirmationPoCEvent)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryConfirmationPoCEventsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryRandomSeedsRequest             protoreflect.MessageDescriptor
-	fd_QueryRandomSeedsRequest_epoch_index protoreflect.FieldDescriptor
+	md_QueryConfirmationPoCEventsResponse        protoreflect.MessageDescriptor
+	fd_QueryConfirmationPoCEventsResponse_events protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryRandomSeedsRequest = File_inference_inference_query_proto.Messages().ByName("QueryRandomSeedsRequest")
-	fd_QueryRandomSeedsRequest_epoch_index = md_QueryRandomSeedsRequest.Fields().ByName("epoch_index")
+	md_QueryConfirmationPoCEventsResponse = File_inference_inference_query_proto.Messages().ByName("QueryConfirmationPoCEventsResponse")
+	fd_QueryConfirmationPoCEventsResponse_events = md_QueryConfirmationPoCEventsResponse.Fields().ByName("events")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryRandomSeedsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryConfirmationPoCEventsResponse)(nil)
 
-type fastReflection_QueryRandomSeedsRequest QueryRandomSeedsRequest
+type fastReflection_QueryConfirmationPoCEventsResponse QueryConfirmationPoCEventsResponse
 
-func (x *QueryRandomSeedsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryRandomSeedsRequest)(x)
+func (x *QueryConfirmationPoCEventsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryConfirmationPoCEventsResponse)(x)
 }
 
-func (x *QueryRandomSeedsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryConfirmationPoCEventsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[154]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -73524,43 +73121,43 @@ func (x *QueryRandomSeedsRequest) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryRandomSeedsRequest_messageType fastReflection_QueryRandomSeedsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryRandomSeedsRequest_messageType{}
+var _fastReflection_QueryConfirmationPoCEventsResponse_messageType fastReflection_QueryConfirmationPoCEventsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryConfirmationPoCEventsResponse_messageType{}
 
-type fastReflection_QueryRandomSeedsRequest_messageType struct{}
+type fastReflection_QueryConfirmationPoCEventsResponse_messageType struct{}
 
-func (x fastReflection_QueryRandomSeedsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryRandomSeedsRequest)(nil)
+func (x fastReflection_QueryConfirmationPoCEventsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryConfirmationPoCEventsResponse)(nil)
 }
-func (x fastReflection_QueryRandomSeedsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryRandomSeedsRequest)
+func (x fastReflection_QueryConfirmationPoCEventsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryConfirmationPoCEventsResponse)
 }
-func (x fastReflection_QueryRandomSeedsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryRandomSeedsRequest
+func (x fastReflection_QueryConfirmationPoCEventsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryConfirmationPoCEventsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryRandomSeedsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryRandomSeedsRequest
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryConfirmationPoCEventsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryRandomSeedsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryRandomSeedsRequest_messageType
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryConfirmationPoCEventsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryRandomSeedsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryRandomSeedsRequest)
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryConfirmationPoCEventsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryRandomSeedsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryRandomSeedsRequest)(x)
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryConfirmationPoCEventsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -73568,10 +73165,10 @@ func (x *fastReflection_QueryRandomSeedsRequest) Interface() protoreflect.ProtoM
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryRandomSeedsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryRandomSeedsRequest_epoch_index, value) {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Events) != 0 {
+		value := protoreflect.ValueOfList(&_QueryConfirmationPoCEventsResponse_1_list{list: &x.Events})
+		if !f(fd_QueryConfirmationPoCEventsResponse_events, value) {
 			return
 		}
 	}
@@ -73588,15 +73185,15 @@ func (x *fastReflection_QueryRandomSeedsRequest) Range(f func(protoreflect.Field
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryRandomSeedsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
-		return x.EpochIndex != uint64(0)
+	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+		return len(x.Events) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -73606,15 +73203,15 @@ func (x *fastReflection_QueryRandomSeedsRequest) Has(fd protoreflect.FieldDescri
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
-		x.EpochIndex = uint64(0)
+	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+		x.Events = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -73624,16 +73221,19 @@ func (x *fastReflection_QueryRandomSeedsRequest) Clear(fd protoreflect.FieldDesc
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryRandomSeedsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+		if len(x.Events) == 0 {
+			return protoreflect.ValueOfList(&_QueryConfirmationPoCEventsResponse_1_list{})
+		}
+		listValue := &_QueryConfirmationPoCEventsResponse_1_list{list: &x.Events}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -73647,15 +73247,17 @@ func (x *fastReflection_QueryRandomSeedsRequest) Get(descriptor protoreflect.Fie
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
-		x.EpochIndex = value.Uint()
+	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+		lv := value.List()
+		clv := lv.(*_QueryConfirmationPoCEventsResponse_1_list)
+		x.Events = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -73669,40 +73271,45 @@ func (x *fastReflection_QueryRandomSeedsRequest) Set(fd protoreflect.FieldDescri
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryRandomSeedsRequest is not mutable"))
+	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+		if x.Events == nil {
+			x.Events = []*ConfirmationPoCEvent{}
+		}
+		value := &_QueryConfirmationPoCEventsResponse_1_list{list: &x.Events}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryRandomSeedsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryConfirmationPoCEventsResponse.events":
+		list := []*ConfirmationPoCEvent{}
+		return protoreflect.ValueOfList(&_QueryConfirmationPoCEventsResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryConfirmationPoCEventsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryConfirmationPoCEventsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryRandomSeedsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryRandomSeedsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryConfirmationPoCEventsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -73710,7 +73317,7 @@ func (x *fastReflection_QueryRandomSeedsRequest) WhichOneof(d protoreflect.Oneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryRandomSeedsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -73721,7 +73328,7 @@ func (x *fastReflection_QueryRandomSeedsRequest) GetUnknown() protoreflect.RawFi
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -73733,7 +73340,7 @@ func (x *fastReflection_QueryRandomSeedsRequest) SetUnknown(fields protoreflect.
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryRandomSeedsRequest) IsValid() bool {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -73743,9 +73350,9 @@ func (x *fastReflection_QueryRandomSeedsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryConfirmationPoCEventsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryRandomSeedsRequest)
+		x := input.Message.Interface().(*QueryConfirmationPoCEventsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -73757,8 +73364,11 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 		var n int
 		var l int
 		_ = l
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		if len(x.Events) > 0 {
+			for _, e := range x.Events {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -73770,7 +73380,7 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryRandomSeedsRequest)
+		x := input.Message.Interface().(*QueryConfirmationPoCEventsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -73789,10 +73399,21 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
-			i--
-			dAtA[i] = 0x8
+		if len(x.Events) > 0 {
+			for iNdEx := len(x.Events) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Events[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -73805,7 +73426,7 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryRandomSeedsRequest)
+		x := input.Message.Interface().(*QueryConfirmationPoCEventsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -73837,17 +73458,17 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 				}
-				x.EpochIndex = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -73857,11 +73478,26 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Events = append(x.Events, &ConfirmationPoCEvent{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Events[len(x.Events)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -73897,77 +73533,79 @@ func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Meth
 	}
 }
 
-var _ protoreflect.List = (*_QueryRandomSeedsResponse_1_list)(nil)
+var _ protoreflect.List = (*_ParticipantWithBalance_2_list)(nil)
 
-type _QueryRandomSeedsResponse_1_list struct {
-	list *[]*RandomSeed
+type _ParticipantWithBalance_2_list struct {
+	list *[]*v1beta11.Coin
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) Len() int {
+func (x *_ParticipantWithBalance_2_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) Get(i int) protoreflect.Value {
+func (x *_ParticipantWithBalance_2_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) Set(i int, value protoreflect.Value) {
+func (x *_ParticipantWithBalance_2_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*RandomSeed)
+	concreteValue := valueUnwrapped.Interface().(*v1beta11.Coin)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) Append(value protoreflect.Value) {
+func (x *_ParticipantWithBalance_2_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*RandomSeed)
+	concreteValue := valueUnwrapped.Interface().(*v1beta11.Coin)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) AppendMutable() protoreflect.Value {
-	v := new(RandomSeed)
+func (x *_ParticipantWithBalance_2_list) AppendMutable() protoreflect.Value {
+	v := new(v1beta11.Coin)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) Truncate(n int) {
+func (x *_ParticipantWithBalance_2_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) NewElement() protoreflect.Value {
-	v := new(RandomSeed)
+func (x *_ParticipantWithBalance_2_list) NewElement() protoreflect.Value {
+	v := new(v1beta11.Coin)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_QueryRandomSeedsResponse_1_list) IsValid() bool {
+func (x *_ParticipantWithBalance_2_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_QueryRandomSeedsResponse       protoreflect.MessageDescriptor
-	fd_QueryRandomSeedsResponse_seeds protoreflect.FieldDescriptor
+	md_ParticipantWithBalance             protoreflect.MessageDescriptor
+	fd_ParticipantWithBalance_participant protoreflect.FieldDescriptor
+	fd_ParticipantWithBalance_balances    protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryRandomSeedsResponse = File_inference_inference_query_proto.Messages().ByName("QueryRandomSeedsResponse")
-	fd_QueryRandomSeedsResponse_seeds = md_QueryRandomSeedsResponse.Fields().ByName("seeds")
+	md_ParticipantWithBalance = File_inference_inference_query_proto.Messages().ByName("ParticipantWithBalance")
+	fd_ParticipantWithBalance_participant = md_ParticipantWithBalance.Fields().ByName("participant")
+	fd_ParticipantWithBalance_balances = md_ParticipantWithBalance.Fields().ByName("balances")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryRandomSeedsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_ParticipantWithBalance)(nil)
 
-type fastReflection_QueryRandomSeedsResponse QueryRandomSeedsResponse
+type fastReflection_ParticipantWithBalance ParticipantWithBalance
 
-func (x *QueryRandomSeedsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryRandomSeedsResponse)(x)
+func (x *ParticipantWithBalance) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_ParticipantWithBalance)(x)
 }
 
-func (x *QueryRandomSeedsResponse) slowProtoReflect() protoreflect.Message {
+func (x *ParticipantWithBalance) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[155]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -73979,43 +73617,43 @@ func (x *QueryRandomSeedsResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryRandomSeedsResponse_messageType fastReflection_QueryRandomSeedsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryRandomSeedsResponse_messageType{}
+var _fastReflection_ParticipantWithBalance_messageType fastReflection_ParticipantWithBalance_messageType
+var _ protoreflect.MessageType = fastReflection_ParticipantWithBalance_messageType{}
 
-type fastReflection_QueryRandomSeedsResponse_messageType struct{}
+type fastReflection_ParticipantWithBalance_messageType struct{}
 
-func (x fastReflection_QueryRandomSeedsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryRandomSeedsResponse)(nil)
+func (x fastReflection_ParticipantWithBalance_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_ParticipantWithBalance)(nil)
 }
-func (x fastReflection_QueryRandomSeedsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryRandomSeedsResponse)
+func (x fastReflection_ParticipantWithBalance_messageType) New() protoreflect.Message {
+	return new(fastReflection_ParticipantWithBalance)
 }
-func (x fastReflection_QueryRandomSeedsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryRandomSeedsResponse
+func (x fastReflection_ParticipantWithBalance_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_ParticipantWithBalance
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryRandomSeedsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryRandomSeedsResponse
+func (x *fastReflection_ParticipantWithBalance) Descriptor() protoreflect.MessageDescriptor {
+	return md_ParticipantWithBalance
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryRandomSeedsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryRandomSeedsResponse_messageType
+func (x *fastReflection_ParticipantWithBalance) Type() protoreflect.MessageType {
+	return _fastReflection_ParticipantWithBalance_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryRandomSeedsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryRandomSeedsResponse)
+func (x *fastReflection_ParticipantWithBalance) New() protoreflect.Message {
+	return new(fastReflection_ParticipantWithBalance)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryRandomSeedsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryRandomSeedsResponse)(x)
+func (x *fastReflection_ParticipantWithBalance) Interface() protoreflect.ProtoMessage {
+	return (*ParticipantWithBalance)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -74023,10 +73661,16 @@ func (x *fastReflection_QueryRandomSeedsResponse) Interface() protoreflect.Proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryRandomSeedsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if len(x.Seeds) != 0 {
-		value := protoreflect.ValueOfList(&_QueryRandomSeedsResponse_1_list{list: &x.Seeds})
-		if !f(fd_QueryRandomSeedsResponse_seeds, value) {
+func (x *fastReflection_ParticipantWithBalance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != nil {
+		value := protoreflect.ValueOfMessage(x.Participant.ProtoReflect())
+		if !f(fd_ParticipantWithBalance_participant, value) {
+			return
+		}
+	}
+	if len(x.Balances) != 0 {
+		value := protoreflect.ValueOfList(&_ParticipantWithBalance_2_list{list: &x.Balances})
+		if !f(fd_ParticipantWithBalance_balances, value) {
 			return
 		}
 	}
@@ -74043,15 +73687,17 @@ func (x *fastReflection_QueryRandomSeedsResponse) Range(f func(protoreflect.Fiel
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryRandomSeedsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_ParticipantWithBalance) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsResponse.seeds":
-		return len(x.Seeds) != 0
+	case "inference.inference.ParticipantWithBalance.participant":
+		return x.Participant != nil
+	case "inference.inference.ParticipantWithBalance.balances":
+		return len(x.Balances) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74061,15 +73707,17 @@ func (x *fastReflection_QueryRandomSeedsResponse) Has(fd protoreflect.FieldDescr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_ParticipantWithBalance) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsResponse.seeds":
-		x.Seeds = nil
+	case "inference.inference.ParticipantWithBalance.participant":
+		x.Participant = nil
+	case "inference.inference.ParticipantWithBalance.balances":
+		x.Balances = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74079,19 +73727,22 @@ func (x *fastReflection_QueryRandomSeedsResponse) Clear(fd protoreflect.FieldDes
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryRandomSeedsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantWithBalance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryRandomSeedsResponse.seeds":
-		if len(x.Seeds) == 0 {
-			return protoreflect.ValueOfList(&_QueryRandomSeedsResponse_1_list{})
+	case "inference.inference.ParticipantWithBalance.participant":
+		value := x.Participant
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.ParticipantWithBalance.balances":
+		if len(x.Balances) == 0 {
+			return protoreflect.ValueOfList(&_ParticipantWithBalance_2_list{})
 		}
-		listValue := &_QueryRandomSeedsResponse_1_list{list: &x.Seeds}
+		listValue := &_ParticipantWithBalance_2_list{list: &x.Balances}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -74105,17 +73756,19 @@ func (x *fastReflection_QueryRandomSeedsResponse) Get(descriptor protoreflect.Fi
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_ParticipantWithBalance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsResponse.seeds":
+	case "inference.inference.ParticipantWithBalance.participant":
+		x.Participant = value.Message().Interface().(*Participant)
+	case "inference.inference.ParticipantWithBalance.balances":
 		lv := value.List()
-		clv := lv.(*_QueryRandomSeedsResponse_1_list)
-		x.Seeds = *clv.list
+		clv := lv.(*_ParticipantWithBalance_2_list)
+		x.Balances = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74129,45 +73782,53 @@ func (x *fastReflection_QueryRandomSeedsResponse) Set(fd protoreflect.FieldDescr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantWithBalance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsResponse.seeds":
-		if x.Seeds == nil {
-			x.Seeds = []*RandomSeed{}
+	case "inference.inference.ParticipantWithBalance.participant":
+		if x.Participant == nil {
+			x.Participant = new(Participant)
 		}
-		value := &_QueryRandomSeedsResponse_1_list{list: &x.Seeds}
+		return protoreflect.ValueOfMessage(x.Participant.ProtoReflect())
+	case "inference.inference.ParticipantWithBalance.balances":
+		if x.Balances == nil {
+			x.Balances = []*v1beta11.Coin{}
+		}
+		value := &_ParticipantWithBalance_2_list{list: &x.Balances}
 		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryRandomSeedsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_ParticipantWithBalance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryRandomSeedsResponse.seeds":
-		list := []*RandomSeed{}
-		return protoreflect.ValueOfList(&_QueryRandomSeedsResponse_1_list{list: &list})
+	case "inference.inference.ParticipantWithBalance.participant":
+		m := new(Participant)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.ParticipantWithBalance.balances":
+		list := []*v1beta11.Coin{}
+		return protoreflect.ValueOfList(&_ParticipantWithBalance_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.ParticipantWithBalance"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.ParticipantWithBalance does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryRandomSeedsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_ParticipantWithBalance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryRandomSeedsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.ParticipantWithBalance", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -74175,7 +73836,7 @@ func (x *fastReflection_QueryRandomSeedsResponse) WhichOneof(d protoreflect.Oneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryRandomSeedsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_ParticipantWithBalance) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -74186,7 +73847,7 @@ func (x *fastReflection_QueryRandomSeedsResponse) GetUnknown() protoreflect.RawF
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryRandomSeedsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_ParticipantWithBalance) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -74198,7 +73859,7 @@ func (x *fastReflection_QueryRandomSeedsResponse) SetUnknown(fields protoreflect
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryRandomSeedsResponse) IsValid() bool {
+func (x *fastReflection_ParticipantWithBalance) IsValid() bool {
 	return x != nil
 }
 
@@ -74208,9 +73869,9 @@ func (x *fastReflection_QueryRandomSeedsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_ParticipantWithBalance) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryRandomSeedsResponse)
+		x := input.Message.Interface().(*ParticipantWithBalance)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74222,8 +73883,12 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 		var n int
 		var l int
 		_ = l
-		if len(x.Seeds) > 0 {
-			for _, e := range x.Seeds {
+		if x.Participant != nil {
+			l = options.Size(x.Participant)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Balances) > 0 {
+			for _, e := range x.Balances {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -74238,7 +73903,7 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryRandomSeedsResponse)
+		x := input.Message.Interface().(*ParticipantWithBalance)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74257,9 +73922,9 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Seeds) > 0 {
-			for iNdEx := len(x.Seeds) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Seeds[iNdEx])
+		if len(x.Balances) > 0 {
+			for iNdEx := len(x.Balances) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Balances[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74270,9 +73935,23 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 				copy(dAtA[i:], encoded)
 				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 				i--
-				dAtA[i] = 0xa
+				dAtA[i] = 0x12
 			}
 		}
+		if x.Participant != nil {
+			encoded, err := options.Marshal(x.Participant)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -74284,7 +73963,7 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryRandomSeedsResponse)
+		x := input.Message.Interface().(*ParticipantWithBalance)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74316,15 +73995,15 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantWithBalance: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: ParticipantWithBalance: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Seeds", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -74351,8 +74030,44 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Seeds = append(x.Seeds, &RandomSeed{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Seeds[len(x.Seeds)-1]); err != nil {
+				if x.Participant == nil {
+					x.Participant = &Participant{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Participant); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Balances = append(x.Balances, &v1beta11.Coin{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Balances[len(x.Balances)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -74392,25 +74107,25 @@ func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Met
 }
 
 var (
-	md_QueryPoCValidationSnapshotRequest                        protoreflect.MessageDescriptor
-	fd_QueryPoCValidationSnapshotRequest_poc_stage_start_height protoreflect.FieldDescriptor
+	md_QueryParticipantsWithBalancesRequest            protoreflect.MessageDescriptor
+	fd_QueryParticipantsWithBalancesRequest_pagination protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPoCValidationSnapshotRequest = File_inference_inference_query_proto.Messages().ByName("QueryPoCValidationSnapshotRequest")
-	fd_QueryPoCValidationSnapshotRequest_poc_stage_start_height = md_QueryPoCValidationSnapshotRequest.Fields().ByName("poc_stage_start_height")
+	md_QueryParticipantsWithBalancesRequest = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsWithBalancesRequest")
+	fd_QueryParticipantsWithBalancesRequest_pagination = md_QueryParticipantsWithBalancesRequest.Fields().ByName("pagination")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPoCValidationSnapshotRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryParticipantsWithBalancesRequest)(nil)
 
-type fastReflection_QueryPoCValidationSnapshotRequest QueryPoCValidationSnapshotRequest
+type fastReflection_QueryParticipantsWithBalancesRequest QueryParticipantsWithBalancesRequest
 
-func (x *QueryPoCValidationSnapshotRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPoCValidationSnapshotRequest)(x)
+func (x *QueryParticipantsWithBalancesRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsWithBalancesRequest)(x)
 }
 
-func (x *QueryPoCValidationSnapshotRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryParticipantsWithBalancesRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[156]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -74422,43 +74137,43 @@ func (x *QueryPoCValidationSnapshotRequest) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPoCValidationSnapshotRequest_messageType fastReflection_QueryPoCValidationSnapshotRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPoCValidationSnapshotRequest_messageType{}
+var _fastReflection_QueryParticipantsWithBalancesRequest_messageType fastReflection_QueryParticipantsWithBalancesRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantsWithBalancesRequest_messageType{}
 
-type fastReflection_QueryPoCValidationSnapshotRequest_messageType struct{}
+type fastReflection_QueryParticipantsWithBalancesRequest_messageType struct{}
 
-func (x fastReflection_QueryPoCValidationSnapshotRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPoCValidationSnapshotRequest)(nil)
+func (x fastReflection_QueryParticipantsWithBalancesRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsWithBalancesRequest)(nil)
 }
-func (x fastReflection_QueryPoCValidationSnapshotRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCValidationSnapshotRequest)
+func (x fastReflection_QueryParticipantsWithBalancesRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsWithBalancesRequest)
 }
-func (x fastReflection_QueryPoCValidationSnapshotRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCValidationSnapshotRequest
+func (x fastReflection_QueryParticipantsWithBalancesRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsWithBalancesRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCValidationSnapshotRequest
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsWithBalancesRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPoCValidationSnapshotRequest_messageType
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParticipantsWithBalancesRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCValidationSnapshotRequest)
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsWithBalancesRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPoCValidationSnapshotRequest)(x)
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryParticipantsWithBalancesRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -74466,10 +74181,10 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.PocStageStartHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.PocStageStartHeight)
-		if !f(fd_QueryPoCValidationSnapshotRequest_poc_stage_start_height, value) {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryParticipantsWithBalancesRequest_pagination, value) {
 			return
 		}
 	}
@@ -74486,15 +74201,15 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
-		return x.PocStageStartHeight != int64(0)
+	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
+		return x.Pagination != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74504,15 +74219,15 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
-		x.PocStageStartHeight = int64(0)
+	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
+		x.Pagination = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74522,16 +74237,16 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
-		value := x.PocStageStartHeight
-		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
+		value := x.Pagination
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -74545,15 +74260,15 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
-		x.PocStageStartHeight = value.Int()
+	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageRequest)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74567,40 +74282,44 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
-		panic(fmt.Errorf("field poc_stage_start_height of message inference.inference.QueryPoCValidationSnapshotRequest is not mutable"))
+	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageRequest)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
-		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryParticipantsWithBalancesRequest.pagination":
+		m := new(v1beta1.PageRequest)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCValidationSnapshotRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsWithBalancesRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -74608,7 +74327,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -74619,7 +74338,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -74631,7 +74350,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) IsValid() bool {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -74641,9 +74360,9 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryParticipantsWithBalancesRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPoCValidationSnapshotRequest)
+		x := input.Message.Interface().(*QueryParticipantsWithBalancesRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74655,8 +74374,9 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 		var n int
 		var l int
 		_ = l
-		if x.PocStageStartHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.PocStageStartHeight))
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -74668,7 +74388,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCValidationSnapshotRequest)
+		x := input.Message.Interface().(*QueryParticipantsWithBalancesRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74687,10 +74407,19 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.PocStageStartHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartHeight))
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0x8
+			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -74703,7 +74432,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCValidationSnapshotRequest)
+		x := input.Message.Interface().(*QueryParticipantsWithBalancesRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -74735,17 +74464,17 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartHeight", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 				}
-				x.PocStageStartHeight = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -74755,11 +74484,28 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.PocStageStartHeight |= int64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageRequest{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -74795,28 +74541,81 @@ func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *proto
 	}
 }
 
+var _ protoreflect.List = (*_QueryParticipantsWithBalancesResponse_1_list)(nil)
+
+type _QueryParticipantsWithBalancesResponse_1_list struct {
+	list *[]*ParticipantWithBalance
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ParticipantWithBalance)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ParticipantWithBalance)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ParticipantWithBalance)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ParticipantWithBalance)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryParticipantsWithBalancesResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryPoCValidationSnapshotResponse          protoreflect.MessageDescriptor
-	fd_QueryPoCValidationSnapshotResponse_snapshot protoreflect.FieldDescriptor
-	fd_QueryPoCValidationSnapshotResponse_found    protoreflect.FieldDescriptor
+	md_QueryParticipantsWithBalancesResponse              protoreflect.MessageDescriptor
+	fd_QueryParticipantsWithBalancesResponse_participants protoreflect.FieldDescriptor
+	fd_QueryParticipantsWithBalancesResponse_pagination   protoreflect.FieldDescriptor
+	fd_QueryParticipantsWithBalancesResponse_block_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPoCValidationSnapshotResponse = File_inference_inference_query_proto.Messages().ByName("QueryPoCValidationSnapshotResponse")
-	fd_QueryPoCValidationSnapshotResponse_snapshot = md_QueryPoCValidationSnapshotResponse.Fields().ByName("snapshot")
-	fd_QueryPoCValidationSnapshotResponse_found = md_QueryPoCValidationSnapshotResponse.Fields().ByName("found")
+	md_QueryParticipantsWithBalancesResponse = File_inference_inference_query_proto.Messages().ByName("QueryParticipantsWithBalancesResponse")
+	fd_QueryParticipantsWithBalancesResponse_participants = md_QueryParticipantsWithBalancesResponse.Fields().ByName("participants")
+	fd_QueryParticipantsWithBalancesResponse_pagination = md_QueryParticipantsWithBalancesResponse.Fields().ByName("pagination")
+	fd_QueryParticipantsWithBalancesResponse_block_height = md_QueryParticipantsWithBalancesResponse.Fields().ByName("block_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPoCValidationSnapshotResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryParticipantsWithBalancesResponse)(nil)
 
-type fastReflection_QueryPoCValidationSnapshotResponse QueryPoCValidationSnapshotResponse
+type fastReflection_QueryParticipantsWithBalancesResponse QueryParticipantsWithBalancesResponse
 
-func (x *QueryPoCValidationSnapshotResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPoCValidationSnapshotResponse)(x)
+func (x *QueryParticipantsWithBalancesResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsWithBalancesResponse)(x)
 }
 
-func (x *QueryPoCValidationSnapshotResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryParticipantsWithBalancesResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[157]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -74828,43 +74627,43 @@ func (x *QueryPoCValidationSnapshotResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPoCValidationSnapshotResponse_messageType fastReflection_QueryPoCValidationSnapshotResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPoCValidationSnapshotResponse_messageType{}
+var _fastReflection_QueryParticipantsWithBalancesResponse_messageType fastReflection_QueryParticipantsWithBalancesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryParticipantsWithBalancesResponse_messageType{}
 
-type fastReflection_QueryPoCValidationSnapshotResponse_messageType struct{}
+type fastReflection_QueryParticipantsWithBalancesResponse_messageType struct{}
 
-func (x fastReflection_QueryPoCValidationSnapshotResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPoCValidationSnapshotResponse)(nil)
+func (x fastReflection_QueryParticipantsWithBalancesResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryParticipantsWithBalancesResponse)(nil)
 }
-func (x fastReflection_QueryPoCValidationSnapshotResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCValidationSnapshotResponse)
+func (x fastReflection_QueryParticipantsWithBalancesResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsWithBalancesResponse)
 }
-func (x fastReflection_QueryPoCValidationSnapshotResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCValidationSnapshotResponse
+func (x fastReflection_QueryParticipantsWithBalancesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsWithBalancesResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPoCValidationSnapshotResponse
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryParticipantsWithBalancesResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPoCValidationSnapshotResponse_messageType
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryParticipantsWithBalancesResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPoCValidationSnapshotResponse)
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryParticipantsWithBalancesResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPoCValidationSnapshotResponse)(x)
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryParticipantsWithBalancesResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -74872,16 +74671,22 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Snapshot != nil {
-		value := protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
-		if !f(fd_QueryPoCValidationSnapshotResponse_snapshot, value) {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Participants) != 0 {
+		value := protoreflect.ValueOfList(&_QueryParticipantsWithBalancesResponse_1_list{list: &x.Participants})
+		if !f(fd_QueryParticipantsWithBalancesResponse_participants, value) {
 			return
 		}
 	}
-	if x.Found != false {
-		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryPoCValidationSnapshotResponse_found, value) {
+	if x.Pagination != nil {
+		value := protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+		if !f(fd_QueryParticipantsWithBalancesResponse_pagination, value) {
+			return
+		}
+	}
+	if x.BlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.BlockHeight)
+		if !f(fd_QueryParticipantsWithBalancesResponse_block_height, value) {
 			return
 		}
 	}
@@ -74898,17 +74703,19 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
-		return x.Snapshot != nil
-	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
-		return x.Found != false
+	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
+		return len(x.Participants) != 0
+	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
+		return x.Pagination != nil
+	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
+		return x.BlockHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74918,17 +74725,19 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
-		x.Snapshot = nil
-	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
-		x.Found = false
+	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
+		x.Participants = nil
+	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
+		x.Pagination = nil
+	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
+		x.BlockHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74938,19 +74747,25 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
-		value := x.Snapshot
+	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
+		if len(x.Participants) == 0 {
+			return protoreflect.ValueOfList(&_QueryParticipantsWithBalancesResponse_1_list{})
+		}
+		listValue := &_QueryParticipantsWithBalancesResponse_1_list{list: &x.Participants}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
+		value := x.Pagination
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
-		value := x.Found
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
+		value := x.BlockHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -74964,17 +74779,21 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
-		x.Snapshot = value.Message().Interface().(*PoCValidationSnapshot)
-	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
-		x.Found = value.Bool()
+	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
+		lv := value.List()
+		clv := lv.(*_QueryParticipantsWithBalancesResponse_1_list)
+		x.Participants = *clv.list
+	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
+		x.Pagination = value.Message().Interface().(*v1beta1.PageResponse)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
+		x.BlockHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -74988,48 +74807,57 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
-		if x.Snapshot == nil {
-			x.Snapshot = new(PoCValidationSnapshot)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
+		if x.Participants == nil {
+			x.Participants = []*ParticipantWithBalance{}
 		}
-		return protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
-	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryPoCValidationSnapshotResponse is not mutable"))
+		value := &_QueryParticipantsWithBalancesResponse_1_list{list: &x.Participants}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
+		if x.Pagination == nil {
+			x.Pagination = new(v1beta1.PageResponse)
+		}
+		return protoreflect.ValueOfMessage(x.Pagination.ProtoReflect())
+	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
+		panic(fmt.Errorf("field block_height of message inference.inference.QueryParticipantsWithBalancesResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
-		m := new(PoCValidationSnapshot)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.participants":
+		list := []*ParticipantWithBalance{}
+		return protoreflect.ValueOfList(&_QueryParticipantsWithBalancesResponse_1_list{list: &list})
+	case "inference.inference.QueryParticipantsWithBalancesResponse.pagination":
+		m := new(v1beta1.PageResponse)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryParticipantsWithBalancesResponse.block_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryParticipantsWithBalancesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryParticipantsWithBalancesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCValidationSnapshotResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryParticipantsWithBalancesResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -75037,7 +74865,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -75048,7 +74876,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -75060,7 +74888,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) IsValid() bool {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -75070,9 +74898,9 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryParticipantsWithBalancesResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPoCValidationSnapshotResponse)
+		x := input.Message.Interface().(*QueryParticipantsWithBalancesResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75084,12 +74912,18 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if x.Snapshot != nil {
-			l = options.Size(x.Snapshot)
+		if len(x.Participants) > 0 {
+			for _, e := range x.Participants {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Pagination != nil {
+			l = options.Size(x.Pagination)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Found {
-			n += 2
+		if x.BlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.BlockHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -75101,7 +74935,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCValidationSnapshotResponse)
+		x := input.Message.Interface().(*QueryParticipantsWithBalancesResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75120,18 +74954,13 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Found {
-			i--
-			if x.Found {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
-			}
+		if x.BlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.BlockHeight))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x18
 		}
-		if x.Snapshot != nil {
-			encoded, err := options.Marshal(x.Snapshot)
+		if x.Pagination != nil {
+			encoded, err := options.Marshal(x.Pagination)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75142,7 +74971,23 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 			copy(dAtA[i:], encoded)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x12
+		}
+		if len(x.Participants) > 0 {
+			for iNdEx := len(x.Participants) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Participants[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -75155,7 +75000,7 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPoCValidationSnapshotResponse)
+		x := input.Message.Interface().(*QueryParticipantsWithBalancesResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75187,15 +75032,15 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -75222,18 +75067,52 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Snapshot == nil {
-					x.Snapshot = &PoCValidationSnapshot{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Snapshot); err != nil {
+				x.Participants = append(x.Participants, &ParticipantWithBalance{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Participants[len(x.Participants)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
 			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Pagination == nil {
+					x.Pagination = &v1beta1.PageResponse{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Pagination); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 				}
-				var v int
+				x.BlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -75243,12 +75122,11 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					x.BlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.Found = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -75285,23 +75163,25 @@ func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *prot
 }
 
 var (
-	md_QueryPreservedNodesSnapshotRequest protoreflect.MessageDescriptor
+	md_QueryRandomSeedsRequest             protoreflect.MessageDescriptor
+	fd_QueryRandomSeedsRequest_epoch_index protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPreservedNodesSnapshotRequest = File_inference_inference_query_proto.Messages().ByName("QueryPreservedNodesSnapshotRequest")
+	md_QueryRandomSeedsRequest = File_inference_inference_query_proto.Messages().ByName("QueryRandomSeedsRequest")
+	fd_QueryRandomSeedsRequest_epoch_index = md_QueryRandomSeedsRequest.Fields().ByName("epoch_index")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPreservedNodesSnapshotRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryRandomSeedsRequest)(nil)
 
-type fastReflection_QueryPreservedNodesSnapshotRequest QueryPreservedNodesSnapshotRequest
+type fastReflection_QueryRandomSeedsRequest QueryRandomSeedsRequest
 
-func (x *QueryPreservedNodesSnapshotRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPreservedNodesSnapshotRequest)(x)
+func (x *QueryRandomSeedsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryRandomSeedsRequest)(x)
 }
 
-func (x *QueryPreservedNodesSnapshotRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryRandomSeedsRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[158]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -75313,43 +75193,43 @@ func (x *QueryPreservedNodesSnapshotRequest) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPreservedNodesSnapshotRequest_messageType fastReflection_QueryPreservedNodesSnapshotRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPreservedNodesSnapshotRequest_messageType{}
+var _fastReflection_QueryRandomSeedsRequest_messageType fastReflection_QueryRandomSeedsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryRandomSeedsRequest_messageType{}
 
-type fastReflection_QueryPreservedNodesSnapshotRequest_messageType struct{}
+type fastReflection_QueryRandomSeedsRequest_messageType struct{}
 
-func (x fastReflection_QueryPreservedNodesSnapshotRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPreservedNodesSnapshotRequest)(nil)
+func (x fastReflection_QueryRandomSeedsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryRandomSeedsRequest)(nil)
 }
-func (x fastReflection_QueryPreservedNodesSnapshotRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPreservedNodesSnapshotRequest)
+func (x fastReflection_QueryRandomSeedsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryRandomSeedsRequest)
 }
-func (x fastReflection_QueryPreservedNodesSnapshotRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreservedNodesSnapshotRequest
+func (x fastReflection_QueryRandomSeedsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRandomSeedsRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreservedNodesSnapshotRequest
+func (x *fastReflection_QueryRandomSeedsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRandomSeedsRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPreservedNodesSnapshotRequest_messageType
+func (x *fastReflection_QueryRandomSeedsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryRandomSeedsRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryPreservedNodesSnapshotRequest)
+func (x *fastReflection_QueryRandomSeedsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryRandomSeedsRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryPreservedNodesSnapshotRequest)(x)
+func (x *fastReflection_QueryRandomSeedsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryRandomSeedsRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -75357,7 +75237,13 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_QueryRandomSeedsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_QueryRandomSeedsRequest_epoch_index, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -75371,13 +75257,15 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryRandomSeedsRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
+		return x.EpochIndex != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -75387,13 +75275,15 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryRandomSeedsRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
+		x.EpochIndex = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -75403,13 +75293,16 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryRandomSeedsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -75423,13 +75316,15 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryRandomSeedsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
+		x.EpochIndex = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -75443,36 +75338,40 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryRandomSeedsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryRandomSeedsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryRandomSeedsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.QueryRandomSeedsRequest.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryRandomSeedsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreservedNodesSnapshotRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryRandomSeedsRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -75480,7 +75379,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryRandomSeedsRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -75491,7 +75390,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryRandomSeedsRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -75503,7 +75402,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) IsValid() bool {
+func (x *fastReflection_QueryRandomSeedsRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -75513,9 +75412,9 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryRandomSeedsRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPreservedNodesSnapshotRequest)
+		x := input.Message.Interface().(*QueryRandomSeedsRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75527,6 +75426,9 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -75537,7 +75439,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreservedNodesSnapshotRequest)
+		x := input.Message.Interface().(*QueryRandomSeedsRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75556,6 +75458,11 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x8
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -75567,7 +75474,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreservedNodesSnapshotRequest)
+		x := input.Message.Interface().(*QueryRandomSeedsRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75599,12 +75506,31 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				}
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -75640,28 +75566,77 @@ func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *prot
 	}
 }
 
+var _ protoreflect.List = (*_QueryRandomSeedsResponse_1_list)(nil)
+
+type _QueryRandomSeedsResponse_1_list struct {
+	list *[]*RandomSeed
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RandomSeed)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*RandomSeed)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(RandomSeed)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(RandomSeed)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryRandomSeedsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_QueryPreservedNodesSnapshotResponse          protoreflect.MessageDescriptor
-	fd_QueryPreservedNodesSnapshotResponse_snapshot protoreflect.FieldDescriptor
-	fd_QueryPreservedNodesSnapshotResponse_found    protoreflect.FieldDescriptor
+	md_QueryRandomSeedsResponse       protoreflect.MessageDescriptor
+	fd_QueryRandomSeedsResponse_seeds protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryPreservedNodesSnapshotResponse = File_inference_inference_query_proto.Messages().ByName("QueryPreservedNodesSnapshotResponse")
-	fd_QueryPreservedNodesSnapshotResponse_snapshot = md_QueryPreservedNodesSnapshotResponse.Fields().ByName("snapshot")
-	fd_QueryPreservedNodesSnapshotResponse_found = md_QueryPreservedNodesSnapshotResponse.Fields().ByName("found")
+	md_QueryRandomSeedsResponse = File_inference_inference_query_proto.Messages().ByName("QueryRandomSeedsResponse")
+	fd_QueryRandomSeedsResponse_seeds = md_QueryRandomSeedsResponse.Fields().ByName("seeds")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryPreservedNodesSnapshotResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryRandomSeedsResponse)(nil)
 
-type fastReflection_QueryPreservedNodesSnapshotResponse QueryPreservedNodesSnapshotResponse
+type fastReflection_QueryRandomSeedsResponse QueryRandomSeedsResponse
 
-func (x *QueryPreservedNodesSnapshotResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryPreservedNodesSnapshotResponse)(x)
+func (x *QueryRandomSeedsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryRandomSeedsResponse)(x)
 }
 
-func (x *QueryPreservedNodesSnapshotResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryRandomSeedsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[159]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -75673,43 +75648,43 @@ func (x *QueryPreservedNodesSnapshotResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryPreservedNodesSnapshotResponse_messageType fastReflection_QueryPreservedNodesSnapshotResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryPreservedNodesSnapshotResponse_messageType{}
+var _fastReflection_QueryRandomSeedsResponse_messageType fastReflection_QueryRandomSeedsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryRandomSeedsResponse_messageType{}
 
-type fastReflection_QueryPreservedNodesSnapshotResponse_messageType struct{}
+type fastReflection_QueryRandomSeedsResponse_messageType struct{}
 
-func (x fastReflection_QueryPreservedNodesSnapshotResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryPreservedNodesSnapshotResponse)(nil)
+func (x fastReflection_QueryRandomSeedsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryRandomSeedsResponse)(nil)
 }
-func (x fastReflection_QueryPreservedNodesSnapshotResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryPreservedNodesSnapshotResponse)
+func (x fastReflection_QueryRandomSeedsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryRandomSeedsResponse)
 }
-func (x fastReflection_QueryPreservedNodesSnapshotResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreservedNodesSnapshotResponse
+func (x fastReflection_QueryRandomSeedsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRandomSeedsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryPreservedNodesSnapshotResponse
+func (x *fastReflection_QueryRandomSeedsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryRandomSeedsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryPreservedNodesSnapshotResponse_messageType
+func (x *fastReflection_QueryRandomSeedsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryRandomSeedsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryPreservedNodesSnapshotResponse)
+func (x *fastReflection_QueryRandomSeedsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryRandomSeedsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryPreservedNodesSnapshotResponse)(x)
+func (x *fastReflection_QueryRandomSeedsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryRandomSeedsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -75717,16 +75692,10 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Snapshot != nil {
-		value := protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
-		if !f(fd_QueryPreservedNodesSnapshotResponse_snapshot, value) {
-			return
-		}
-	}
-	if x.Found != false {
-		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryPreservedNodesSnapshotResponse_found, value) {
+func (x *fastReflection_QueryRandomSeedsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Seeds) != 0 {
+		value := protoreflect.ValueOfList(&_QueryRandomSeedsResponse_1_list{list: &x.Seeds})
+		if !f(fd_QueryRandomSeedsResponse_seeds, value) {
 			return
 		}
 	}
@@ -75743,17 +75712,15 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryRandomSeedsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
-		return x.Snapshot != nil
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
-		return x.Found != false
+	case "inference.inference.QueryRandomSeedsResponse.seeds":
+		return len(x.Seeds) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -75763,17 +75730,15 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryRandomSeedsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
-		x.Snapshot = nil
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
-		x.Found = false
+	case "inference.inference.QueryRandomSeedsResponse.seeds":
+		x.Seeds = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -75783,19 +75748,19 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryRandomSeedsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
-		value := x.Snapshot
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
-		value := x.Found
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryRandomSeedsResponse.seeds":
+		if len(x.Seeds) == 0 {
+			return protoreflect.ValueOfList(&_QueryRandomSeedsResponse_1_list{})
+		}
+		listValue := &_QueryRandomSeedsResponse_1_list{list: &x.Seeds}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -75809,17 +75774,17 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryRandomSeedsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
-		x.Snapshot = value.Message().Interface().(*PreservedNodesSnapshot)
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
-		x.Found = value.Bool()
+	case "inference.inference.QueryRandomSeedsResponse.seeds":
+		lv := value.List()
+		clv := lv.(*_QueryRandomSeedsResponse_1_list)
+		x.Seeds = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -75833,48 +75798,45 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryRandomSeedsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
-		if x.Snapshot == nil {
-			x.Snapshot = new(PreservedNodesSnapshot)
+	case "inference.inference.QueryRandomSeedsResponse.seeds":
+		if x.Seeds == nil {
+			x.Seeds = []*RandomSeed{}
 		}
-		return protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryPreservedNodesSnapshotResponse is not mutable"))
+		value := &_QueryRandomSeedsResponse_1_list{list: &x.Seeds}
+		return protoreflect.ValueOfList(value)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryRandomSeedsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
-		m := new(PreservedNodesSnapshot)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryRandomSeedsResponse.seeds":
+		list := []*RandomSeed{}
+		return protoreflect.ValueOfList(&_QueryRandomSeedsResponse_1_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryRandomSeedsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryRandomSeedsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryRandomSeedsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreservedNodesSnapshotResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryRandomSeedsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -75882,7 +75844,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryRandomSeedsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -75893,7 +75855,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryRandomSeedsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -75905,7 +75867,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) IsValid() bool {
+func (x *fastReflection_QueryRandomSeedsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -75915,9 +75877,9 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryRandomSeedsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryPreservedNodesSnapshotResponse)
+		x := input.Message.Interface().(*QueryRandomSeedsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75929,12 +75891,11 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 		var n int
 		var l int
 		_ = l
-		if x.Snapshot != nil {
-			l = options.Size(x.Snapshot)
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.Found {
-			n += 2
+		if len(x.Seeds) > 0 {
+			for _, e := range x.Seeds {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -75946,7 +75907,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreservedNodesSnapshotResponse)
+		x := input.Message.Interface().(*QueryRandomSeedsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -75965,29 +75926,21 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Found {
-			i--
-			if x.Found {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
-			}
-			i--
-			dAtA[i] = 0x10
-		}
-		if x.Snapshot != nil {
-			encoded, err := options.Marshal(x.Snapshot)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
+		if len(x.Seeds) > 0 {
+			for iNdEx := len(x.Seeds) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Seeds[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
 			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0xa
 		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
@@ -76000,7 +75953,7 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryPreservedNodesSnapshotResponse)
+		x := input.Message.Interface().(*QueryRandomSeedsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76032,15 +75985,15 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryRandomSeedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Seeds", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -76067,33 +76020,11 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Snapshot == nil {
-					x.Snapshot = &PreservedNodesSnapshot{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Snapshot); err != nil {
+				x.Seeds = append(x.Seeds, &RandomSeed{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Seeds[len(x.Seeds)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
-				}
-				var v int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				x.Found = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -76130,25 +76061,25 @@ func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *pro
 }
 
 var (
-	md_QueryGetDevshardEscrowRequest    protoreflect.MessageDescriptor
-	fd_QueryGetDevshardEscrowRequest_id protoreflect.FieldDescriptor
+	md_QueryPoCValidationSnapshotRequest                        protoreflect.MessageDescriptor
+	fd_QueryPoCValidationSnapshotRequest_poc_stage_start_height protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetDevshardEscrowRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardEscrowRequest")
-	fd_QueryGetDevshardEscrowRequest_id = md_QueryGetDevshardEscrowRequest.Fields().ByName("id")
+	md_QueryPoCValidationSnapshotRequest = File_inference_inference_query_proto.Messages().ByName("QueryPoCValidationSnapshotRequest")
+	fd_QueryPoCValidationSnapshotRequest_poc_stage_start_height = md_QueryPoCValidationSnapshotRequest.Fields().ByName("poc_stage_start_height")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetDevshardEscrowRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPoCValidationSnapshotRequest)(nil)
 
-type fastReflection_QueryGetDevshardEscrowRequest QueryGetDevshardEscrowRequest
+type fastReflection_QueryPoCValidationSnapshotRequest QueryPoCValidationSnapshotRequest
 
-func (x *QueryGetDevshardEscrowRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardEscrowRequest)(x)
+func (x *QueryPoCValidationSnapshotRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPoCValidationSnapshotRequest)(x)
 }
 
-func (x *QueryGetDevshardEscrowRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPoCValidationSnapshotRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[160]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -76160,43 +76091,43 @@ func (x *QueryGetDevshardEscrowRequest) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetDevshardEscrowRequest_messageType fastReflection_QueryGetDevshardEscrowRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetDevshardEscrowRequest_messageType{}
+var _fastReflection_QueryPoCValidationSnapshotRequest_messageType fastReflection_QueryPoCValidationSnapshotRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPoCValidationSnapshotRequest_messageType{}
 
-type fastReflection_QueryGetDevshardEscrowRequest_messageType struct{}
+type fastReflection_QueryPoCValidationSnapshotRequest_messageType struct{}
 
-func (x fastReflection_QueryGetDevshardEscrowRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardEscrowRequest)(nil)
+func (x fastReflection_QueryPoCValidationSnapshotRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPoCValidationSnapshotRequest)(nil)
 }
-func (x fastReflection_QueryGetDevshardEscrowRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardEscrowRequest)
+func (x fastReflection_QueryPoCValidationSnapshotRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCValidationSnapshotRequest)
 }
-func (x fastReflection_QueryGetDevshardEscrowRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardEscrowRequest
+func (x fastReflection_QueryPoCValidationSnapshotRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCValidationSnapshotRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardEscrowRequest
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCValidationSnapshotRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetDevshardEscrowRequest_messageType
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPoCValidationSnapshotRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardEscrowRequest)
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCValidationSnapshotRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetDevshardEscrowRequest)(x)
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPoCValidationSnapshotRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -76204,10 +76135,10 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Id != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Id)
-		if !f(fd_QueryGetDevshardEscrowRequest_id, value) {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.PocStageStartHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.PocStageStartHeight)
+		if !f(fd_QueryPoCValidationSnapshotRequest_poc_stage_start_height, value) {
 			return
 		}
 	}
@@ -76224,15 +76155,15 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowRequest.id":
-		return x.Id != uint64(0)
+	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
+		return x.PocStageStartHeight != int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -76242,15 +76173,15 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowRequest.id":
-		x.Id = uint64(0)
+	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
+		x.PocStageStartHeight = int64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -76260,16 +76191,16 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowRequest.id":
-		value := x.Id
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
+		value := x.PocStageStartHeight
+		return protoreflect.ValueOfInt64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -76283,15 +76214,15 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowRequest.id":
-		x.Id = value.Uint()
+	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
+		x.PocStageStartHeight = value.Int()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -76305,40 +76236,40 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowRequest.id":
-		panic(fmt.Errorf("field id of message inference.inference.QueryGetDevshardEscrowRequest is not mutable"))
+	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
+		panic(fmt.Errorf("field poc_stage_start_height of message inference.inference.QueryPoCValidationSnapshotRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowRequest.id":
-		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryPoCValidationSnapshotRequest.poc_stage_start_height":
+		return protoreflect.ValueOfInt64(int64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardEscrowRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCValidationSnapshotRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -76346,7 +76277,7 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -76357,7 +76288,7 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -76369,7 +76300,7 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) IsValid() bool {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -76379,9 +76310,9 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPoCValidationSnapshotRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetDevshardEscrowRequest)
+		x := input.Message.Interface().(*QueryPoCValidationSnapshotRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76393,8 +76324,8 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		if x.Id != 0 {
-			n += 1 + runtime.Sov(uint64(x.Id))
+		if x.PocStageStartHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.PocStageStartHeight))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -76406,7 +76337,7 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardEscrowRequest)
+		x := input.Message.Interface().(*QueryPoCValidationSnapshotRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76425,8 +76356,8 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Id != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
+		if x.PocStageStartHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartHeight))
 			i--
 			dAtA[i] = 0x8
 		}
@@ -76441,7 +76372,7 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardEscrowRequest)
+		x := input.Message.Interface().(*QueryPoCValidationSnapshotRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76473,17 +76404,17 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartHeight", wireType)
 				}
-				x.Id = 0
+				x.PocStageStartHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -76493,7 +76424,7 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Id |= uint64(b&0x7F) << shift
+					x.PocStageStartHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -76534,27 +76465,27 @@ func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoifac
 }
 
 var (
-	md_QueryGetDevshardEscrowResponse        protoreflect.MessageDescriptor
-	fd_QueryGetDevshardEscrowResponse_escrow protoreflect.FieldDescriptor
-	fd_QueryGetDevshardEscrowResponse_found  protoreflect.FieldDescriptor
+	md_QueryPoCValidationSnapshotResponse          protoreflect.MessageDescriptor
+	fd_QueryPoCValidationSnapshotResponse_snapshot protoreflect.FieldDescriptor
+	fd_QueryPoCValidationSnapshotResponse_found    protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetDevshardEscrowResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardEscrowResponse")
-	fd_QueryGetDevshardEscrowResponse_escrow = md_QueryGetDevshardEscrowResponse.Fields().ByName("escrow")
-	fd_QueryGetDevshardEscrowResponse_found = md_QueryGetDevshardEscrowResponse.Fields().ByName("found")
+	md_QueryPoCValidationSnapshotResponse = File_inference_inference_query_proto.Messages().ByName("QueryPoCValidationSnapshotResponse")
+	fd_QueryPoCValidationSnapshotResponse_snapshot = md_QueryPoCValidationSnapshotResponse.Fields().ByName("snapshot")
+	fd_QueryPoCValidationSnapshotResponse_found = md_QueryPoCValidationSnapshotResponse.Fields().ByName("found")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetDevshardEscrowResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPoCValidationSnapshotResponse)(nil)
 
-type fastReflection_QueryGetDevshardEscrowResponse QueryGetDevshardEscrowResponse
+type fastReflection_QueryPoCValidationSnapshotResponse QueryPoCValidationSnapshotResponse
 
-func (x *QueryGetDevshardEscrowResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardEscrowResponse)(x)
+func (x *QueryPoCValidationSnapshotResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPoCValidationSnapshotResponse)(x)
 }
 
-func (x *QueryGetDevshardEscrowResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryPoCValidationSnapshotResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[161]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -76566,43 +76497,43 @@ func (x *QueryGetDevshardEscrowResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetDevshardEscrowResponse_messageType fastReflection_QueryGetDevshardEscrowResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetDevshardEscrowResponse_messageType{}
+var _fastReflection_QueryPoCValidationSnapshotResponse_messageType fastReflection_QueryPoCValidationSnapshotResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPoCValidationSnapshotResponse_messageType{}
 
-type fastReflection_QueryGetDevshardEscrowResponse_messageType struct{}
+type fastReflection_QueryPoCValidationSnapshotResponse_messageType struct{}
 
-func (x fastReflection_QueryGetDevshardEscrowResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardEscrowResponse)(nil)
+func (x fastReflection_QueryPoCValidationSnapshotResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPoCValidationSnapshotResponse)(nil)
 }
-func (x fastReflection_QueryGetDevshardEscrowResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardEscrowResponse)
+func (x fastReflection_QueryPoCValidationSnapshotResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCValidationSnapshotResponse)
 }
-func (x fastReflection_QueryGetDevshardEscrowResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardEscrowResponse
+func (x fastReflection_QueryPoCValidationSnapshotResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCValidationSnapshotResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardEscrowResponse
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPoCValidationSnapshotResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetDevshardEscrowResponse_messageType
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPoCValidationSnapshotResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardEscrowResponse)
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPoCValidationSnapshotResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetDevshardEscrowResponse)(x)
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPoCValidationSnapshotResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -76610,16 +76541,16 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) Interface() protoreflect
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Escrow != nil {
-		value := protoreflect.ValueOfMessage(x.Escrow.ProtoReflect())
-		if !f(fd_QueryGetDevshardEscrowResponse_escrow, value) {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Snapshot != nil {
+		value := protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
+		if !f(fd_QueryPoCValidationSnapshotResponse_snapshot, value) {
 			return
 		}
 	}
 	if x.Found != false {
 		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryGetDevshardEscrowResponse_found, value) {
+		if !f(fd_QueryPoCValidationSnapshotResponse_found, value) {
 			return
 		}
 	}
@@ -76636,17 +76567,17 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) Range(f func(protoreflec
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
-		return x.Escrow != nil
-	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
+		return x.Snapshot != nil
+	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
 		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -76656,17 +76587,17 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) Has(fd protoreflect.Fiel
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
-		x.Escrow = nil
-	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
+		x.Snapshot = nil
+	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
 		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -76676,19 +76607,19 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) Clear(fd protoreflect.Fi
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
-		value := x.Escrow
+	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
+		value := x.Snapshot
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
 		value := x.Found
 		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -76702,17 +76633,17 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) Get(descriptor protorefl
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
-		x.Escrow = value.Message().Interface().(*DevshardEscrow)
-	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
+		x.Snapshot = value.Message().Interface().(*PoCValidationSnapshot)
+	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
 		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -76726,48 +76657,48 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) Set(fd protoreflect.Fiel
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
-		if x.Escrow == nil {
-			x.Escrow = new(DevshardEscrow)
+	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
+		if x.Snapshot == nil {
+			x.Snapshot = new(PoCValidationSnapshot)
 		}
-		return protoreflect.ValueOfMessage(x.Escrow.ProtoReflect())
-	case "inference.inference.QueryGetDevshardEscrowResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryGetDevshardEscrowResponse is not mutable"))
+		return protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
+	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryPoCValidationSnapshotResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
-		m := new(DevshardEscrow)
+	case "inference.inference.QueryPoCValidationSnapshotResponse.snapshot":
+		m := new(PoCValidationSnapshot)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+	case "inference.inference.QueryPoCValidationSnapshotResponse.found":
 		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPoCValidationSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPoCValidationSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardEscrowResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPoCValidationSnapshotResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -76775,7 +76706,7 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) WhichOneof(d protoreflec
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -76786,7 +76717,7 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) GetUnknown() protoreflec
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -76798,7 +76729,7 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) SetUnknown(fields protor
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) IsValid() bool {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -76808,9 +76739,9 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPoCValidationSnapshotResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetDevshardEscrowResponse)
+		x := input.Message.Interface().(*QueryPoCValidationSnapshotResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76822,8 +76753,8 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 		var n int
 		var l int
 		_ = l
-		if x.Escrow != nil {
-			l = options.Size(x.Escrow)
+		if x.Snapshot != nil {
+			l = options.Size(x.Snapshot)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.Found {
@@ -76839,7 +76770,7 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardEscrowResponse)
+		x := input.Message.Interface().(*QueryPoCValidationSnapshotResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76868,8 +76799,8 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 			i--
 			dAtA[i] = 0x10
 		}
-		if x.Escrow != nil {
-			encoded, err := options.Marshal(x.Escrow)
+		if x.Snapshot != nil {
+			encoded, err := options.Marshal(x.Snapshot)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76893,7 +76824,7 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardEscrowResponse)
+		x := input.Message.Interface().(*QueryPoCValidationSnapshotResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -76925,15 +76856,15 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Escrow", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -76960,10 +76891,10 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Escrow == nil {
-					x.Escrow = &DevshardEscrow{}
+				if x.Snapshot == nil {
+					x.Snapshot = &PoCValidationSnapshot{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Escrow); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Snapshot); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -77023,27 +76954,23 @@ func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoifa
 }
 
 var (
-	md_QueryGetDevshardHostEpochStatsRequest             protoreflect.MessageDescriptor
-	fd_QueryGetDevshardHostEpochStatsRequest_epoch_index protoreflect.FieldDescriptor
-	fd_QueryGetDevshardHostEpochStatsRequest_participant protoreflect.FieldDescriptor
+	md_QueryPreservedNodesSnapshotRequest protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetDevshardHostEpochStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardHostEpochStatsRequest")
-	fd_QueryGetDevshardHostEpochStatsRequest_epoch_index = md_QueryGetDevshardHostEpochStatsRequest.Fields().ByName("epoch_index")
-	fd_QueryGetDevshardHostEpochStatsRequest_participant = md_QueryGetDevshardHostEpochStatsRequest.Fields().ByName("participant")
+	md_QueryPreservedNodesSnapshotRequest = File_inference_inference_query_proto.Messages().ByName("QueryPreservedNodesSnapshotRequest")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetDevshardHostEpochStatsRequest)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPreservedNodesSnapshotRequest)(nil)
 
-type fastReflection_QueryGetDevshardHostEpochStatsRequest QueryGetDevshardHostEpochStatsRequest
+type fastReflection_QueryPreservedNodesSnapshotRequest QueryPreservedNodesSnapshotRequest
 
-func (x *QueryGetDevshardHostEpochStatsRequest) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardHostEpochStatsRequest)(x)
+func (x *QueryPreservedNodesSnapshotRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPreservedNodesSnapshotRequest)(x)
 }
 
-func (x *QueryGetDevshardHostEpochStatsRequest) slowProtoReflect() protoreflect.Message {
+func (x *QueryPreservedNodesSnapshotRequest) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[162]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -77055,43 +76982,43 @@ func (x *QueryGetDevshardHostEpochStatsRequest) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType{}
+var _fastReflection_QueryPreservedNodesSnapshotRequest_messageType fastReflection_QueryPreservedNodesSnapshotRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPreservedNodesSnapshotRequest_messageType{}
 
-type fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType struct{}
+type fastReflection_QueryPreservedNodesSnapshotRequest_messageType struct{}
 
-func (x fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardHostEpochStatsRequest)(nil)
+func (x fastReflection_QueryPreservedNodesSnapshotRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPreservedNodesSnapshotRequest)(nil)
 }
-func (x fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardHostEpochStatsRequest)
+func (x fastReflection_QueryPreservedNodesSnapshotRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPreservedNodesSnapshotRequest)
 }
-func (x fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardHostEpochStatsRequest
+func (x fastReflection_QueryPreservedNodesSnapshotRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreservedNodesSnapshotRequest
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardHostEpochStatsRequest
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreservedNodesSnapshotRequest
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPreservedNodesSnapshotRequest_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardHostEpochStatsRequest)
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryPreservedNodesSnapshotRequest)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetDevshardHostEpochStatsRequest)(x)
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryPreservedNodesSnapshotRequest)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -77099,19 +77026,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_QueryGetDevshardHostEpochStatsRequest_epoch_index, value) {
-			return
-		}
-	}
-	if x.Participant != "" {
-		value := protoreflect.ValueOfString(x.Participant)
-		if !f(fd_QueryGetDevshardHostEpochStatsRequest_participant, value) {
-			return
-		}
-	}
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -77125,17 +77040,13 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
-		return x.EpochIndex != uint64(0)
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
-		return x.Participant != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -77145,17 +77056,13 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
-		x.EpochIndex = uint64(0)
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
-		x.Participant = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -77165,19 +77072,13 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
-		value := x.Participant
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -77191,17 +77092,13 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
-		x.EpochIndex = value.Uint()
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
-		x.Participant = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -77215,44 +77112,36 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryGetDevshardHostEpochStatsRequest is not mutable"))
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
-		panic(fmt.Errorf("field participant of message inference.inference.QueryGetDevshardHostEpochStatsRequest is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotRequest"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotRequest does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardHostEpochStatsRequest", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreservedNodesSnapshotRequest", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -77260,7 +77149,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -77271,7 +77160,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -77283,7 +77172,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) IsValid() bool {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) IsValid() bool {
 	return x != nil
 }
 
@@ -77293,9 +77182,9 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPreservedNodesSnapshotRequest) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsRequest)
+		x := input.Message.Interface().(*QueryPreservedNodesSnapshotRequest)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77307,13 +77196,6 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *p
 		var n int
 		var l int
 		_ = l
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
-		}
-		l = len(x.Participant)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -77324,7 +77206,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsRequest)
+		x := input.Message.Interface().(*QueryPreservedNodesSnapshotRequest)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77343,18 +77225,6 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *p
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Participant) > 0 {
-			i -= len(x.Participant)
-			copy(dAtA[i:], x.Participant)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
-			i--
-			dAtA[i] = 0x8
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -77366,7 +77236,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsRequest)
+		x := input.Message.Interface().(*QueryPreservedNodesSnapshotRequest)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77398,63 +77268,12 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-				}
-				x.EpochIndex = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Participant = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -77491,27 +77310,27 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *p
 }
 
 var (
-	md_QueryGetDevshardHostEpochStatsResponse       protoreflect.MessageDescriptor
-	fd_QueryGetDevshardHostEpochStatsResponse_stats protoreflect.FieldDescriptor
-	fd_QueryGetDevshardHostEpochStatsResponse_found protoreflect.FieldDescriptor
+	md_QueryPreservedNodesSnapshotResponse          protoreflect.MessageDescriptor
+	fd_QueryPreservedNodesSnapshotResponse_snapshot protoreflect.FieldDescriptor
+	fd_QueryPreservedNodesSnapshotResponse_found    protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_query_proto_init()
-	md_QueryGetDevshardHostEpochStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardHostEpochStatsResponse")
-	fd_QueryGetDevshardHostEpochStatsResponse_stats = md_QueryGetDevshardHostEpochStatsResponse.Fields().ByName("stats")
-	fd_QueryGetDevshardHostEpochStatsResponse_found = md_QueryGetDevshardHostEpochStatsResponse.Fields().ByName("found")
+	md_QueryPreservedNodesSnapshotResponse = File_inference_inference_query_proto.Messages().ByName("QueryPreservedNodesSnapshotResponse")
+	fd_QueryPreservedNodesSnapshotResponse_snapshot = md_QueryPreservedNodesSnapshotResponse.Fields().ByName("snapshot")
+	fd_QueryPreservedNodesSnapshotResponse_found = md_QueryPreservedNodesSnapshotResponse.Fields().ByName("found")
 }
 
-var _ protoreflect.Message = (*fastReflection_QueryGetDevshardHostEpochStatsResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_QueryPreservedNodesSnapshotResponse)(nil)
 
-type fastReflection_QueryGetDevshardHostEpochStatsResponse QueryGetDevshardHostEpochStatsResponse
+type fastReflection_QueryPreservedNodesSnapshotResponse QueryPreservedNodesSnapshotResponse
 
-func (x *QueryGetDevshardHostEpochStatsResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardHostEpochStatsResponse)(x)
+func (x *QueryPreservedNodesSnapshotResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryPreservedNodesSnapshotResponse)(x)
 }
 
-func (x *QueryGetDevshardHostEpochStatsResponse) slowProtoReflect() protoreflect.Message {
+func (x *QueryPreservedNodesSnapshotResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_query_proto_msgTypes[163]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -77523,43 +77342,43 @@ func (x *QueryGetDevshardHostEpochStatsResponse) slowProtoReflect() protoreflect
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType
-var _ protoreflect.MessageType = fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType{}
+var _fastReflection_QueryPreservedNodesSnapshotResponse_messageType fastReflection_QueryPreservedNodesSnapshotResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryPreservedNodesSnapshotResponse_messageType{}
 
-type fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType struct{}
+type fastReflection_QueryPreservedNodesSnapshotResponse_messageType struct{}
 
-func (x fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_QueryGetDevshardHostEpochStatsResponse)(nil)
+func (x fastReflection_QueryPreservedNodesSnapshotResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryPreservedNodesSnapshotResponse)(nil)
 }
-func (x fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardHostEpochStatsResponse)
+func (x fastReflection_QueryPreservedNodesSnapshotResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryPreservedNodesSnapshotResponse)
 }
-func (x fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardHostEpochStatsResponse
+func (x fastReflection_QueryPreservedNodesSnapshotResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreservedNodesSnapshotResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_QueryGetDevshardHostEpochStatsResponse
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryPreservedNodesSnapshotResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Type() protoreflect.MessageType {
-	return _fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryPreservedNodesSnapshotResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) New() protoreflect.Message {
-	return new(fastReflection_QueryGetDevshardHostEpochStatsResponse)
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryPreservedNodesSnapshotResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Interface() protoreflect.ProtoMessage {
-	return (*QueryGetDevshardHostEpochStatsResponse)(x)
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryPreservedNodesSnapshotResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -77567,16 +77386,16 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Interface() prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Stats != nil {
-		value := protoreflect.ValueOfMessage(x.Stats.ProtoReflect())
-		if !f(fd_QueryGetDevshardHostEpochStatsResponse_stats, value) {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Snapshot != nil {
+		value := protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
+		if !f(fd_QueryPreservedNodesSnapshotResponse_snapshot, value) {
 			return
 		}
 	}
 	if x.Found != false {
 		value := protoreflect.ValueOfBool(x.Found)
-		if !f(fd_QueryGetDevshardHostEpochStatsResponse_found, value) {
+		if !f(fd_QueryPreservedNodesSnapshotResponse_found, value) {
 			return
 		}
 	}
@@ -77593,17 +77412,17 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Range(f func(pro
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
-		return x.Stats != nil
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
+		return x.Snapshot != nil
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
 		return x.Found != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -77613,17 +77432,17 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Has(fd protorefl
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
-		x.Stats = nil
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
+		x.Snapshot = nil
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
 		x.Found = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -77633,19 +77452,19 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Clear(fd protore
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
-		value := x.Stats
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
+		value := x.Snapshot
 		return protoreflect.ValueOfMessage(value.ProtoReflect())
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
 		value := x.Found
 		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -77659,17 +77478,17 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Get(descriptor p
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
-		x.Stats = value.Message().Interface().(*DevshardHostEpochStats)
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
+		x.Snapshot = value.Message().Interface().(*PreservedNodesSnapshot)
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
 		x.Found = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -77683,48 +77502,48 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Set(fd protorefl
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
-		if x.Stats == nil {
-			x.Stats = new(DevshardHostEpochStats)
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
+		if x.Snapshot == nil {
+			x.Snapshot = new(PreservedNodesSnapshot)
 		}
-		return protoreflect.ValueOfMessage(x.Stats.ProtoReflect())
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
-		panic(fmt.Errorf("field found of message inference.inference.QueryGetDevshardHostEpochStatsResponse is not mutable"))
+		return protoreflect.ValueOfMessage(x.Snapshot.ProtoReflect())
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryPreservedNodesSnapshotResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
-		m := new(DevshardHostEpochStats)
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.snapshot":
+		m := new(PreservedNodesSnapshot)
 		return protoreflect.ValueOfMessage(m.ProtoReflect())
-	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+	case "inference.inference.QueryPreservedNodesSnapshotResponse.found":
 		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryPreservedNodesSnapshotResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.QueryPreservedNodesSnapshotResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardHostEpochStatsResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryPreservedNodesSnapshotResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -77732,7 +77551,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) WhichOneof(d pro
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -77743,7 +77562,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) GetUnknown() pro
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -77755,7 +77574,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) SetUnknown(field
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) IsValid() bool {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -77765,9 +77584,9 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_QueryPreservedNodesSnapshotResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsResponse)
+		x := input.Message.Interface().(*QueryPreservedNodesSnapshotResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77779,8 +77598,8 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 		var n int
 		var l int
 		_ = l
-		if x.Stats != nil {
-			l = options.Size(x.Stats)
+		if x.Snapshot != nil {
+			l = options.Size(x.Snapshot)
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.Found {
@@ -77796,7 +77615,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsResponse)
+		x := input.Message.Interface().(*QueryPreservedNodesSnapshotResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77825,8 +77644,8 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 			i--
 			dAtA[i] = 0x10
 		}
-		if x.Stats != nil {
-			encoded, err := options.Marshal(x.Stats)
+		if x.Snapshot != nil {
+			encoded, err := options.Marshal(x.Snapshot)
 			if err != nil {
 				return protoiface.MarshalOutput{
 					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77850,7 +77669,7 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsResponse)
+		x := input.Message.Interface().(*QueryPreservedNodesSnapshotResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -77882,15 +77701,15 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -77917,10 +77736,10 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if x.Stats == nil {
-					x.Stats = &DevshardHostEpochStats{}
+				if x.Snapshot == nil {
+					x.Snapshot = &PreservedNodesSnapshot{}
 				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats); err != nil {
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Snapshot); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -77979,302 +77798,9084 @@ func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *
 	}
 }
 
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.27.0
-// 	protoc        (unknown)
-// source: inference/inference/query.proto
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+var (
+	md_QueryGetDevshardEscrowRequest    protoreflect.MessageDescriptor
+	fd_QueryGetDevshardEscrowRequest_id protoreflect.FieldDescriptor
 )
 
-// QueryParamsRequest is request type for the Query/Params RPC method.
-type QueryParamsRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *QueryParamsRequest) Reset() {
-	*x = QueryParamsRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *QueryParamsRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetDevshardEscrowRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardEscrowRequest")
+	fd_QueryGetDevshardEscrowRequest_id = md_QueryGetDevshardEscrowRequest.Fields().ByName("id")
 }
 
-func (*QueryParamsRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryParamsRequest.ProtoReflect.Descriptor instead.
-func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{0}
-}
+var _ protoreflect.Message = (*fastReflection_QueryGetDevshardEscrowRequest)(nil)
 
-// QueryParamsResponse is response type for the Query/Params RPC method.
-type QueryParamsResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
+type fastReflection_QueryGetDevshardEscrowRequest QueryGetDevshardEscrowRequest
 
-	// params holds all the parameters of this module.
-	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+func (x *QueryGetDevshardEscrowRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardEscrowRequest)(x)
 }
 
-func (x *QueryParamsResponse) Reset() {
-	*x = QueryParamsResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[1]
+func (x *QueryGetDevshardEscrowRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[164]
+	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
 	}
+	return mi.MessageOf(x)
 }
 
-func (x *QueryParamsResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
+var _fastReflection_QueryGetDevshardEscrowRequest_messageType fastReflection_QueryGetDevshardEscrowRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetDevshardEscrowRequest_messageType{}
 
-func (*QueryParamsResponse) ProtoMessage() {}
+type fastReflection_QueryGetDevshardEscrowRequest_messageType struct{}
 
-// Deprecated: Use QueryParamsResponse.ProtoReflect.Descriptor instead.
-func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{1}
+func (x fastReflection_QueryGetDevshardEscrowRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardEscrowRequest)(nil)
 }
-
-func (x *QueryParamsResponse) GetParams() *Params {
-	if x != nil {
-		return x.Params
-	}
-	return nil
+func (x fastReflection_QueryGetDevshardEscrowRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardEscrowRequest)
 }
-
-type QueryGetInferenceRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+func (x fastReflection_QueryGetDevshardEscrowRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardEscrowRequest
 }
 
-func (x *QueryGetInferenceRequest) Reset() {
-	*x = QueryGetInferenceRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardEscrowRequest
 }
 
-func (x *QueryGetInferenceRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetDevshardEscrowRequest_messageType
 }
 
-func (*QueryGetInferenceRequest) ProtoMessage() {}
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardEscrowRequest)
+}
 
-// Deprecated: Use QueryGetInferenceRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{2}
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetDevshardEscrowRequest)(x)
 }
 
-func (x *QueryGetInferenceRequest) GetIndex() string {
-	if x != nil {
-		return x.Index
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Id != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Id)
+		if !f(fd_QueryGetDevshardEscrowRequest_id, value) {
+			return
+		}
 	}
-	return ""
 }
 
-type QueryGetInferenceResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Inference *Inference `protobuf:"bytes,1,opt,name=inference,proto3" json:"inference,omitempty"`
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowRequest.id":
+		return x.Id != uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+	}
 }
 
-func (x *QueryGetInferenceResponse) Reset() {
-	*x = QueryGetInferenceResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowRequest.id":
+		x.Id = uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
 	}
 }
 
-func (x *QueryGetInferenceResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowRequest.id":
+		value := x.Id
+		return protoreflect.ValueOfUint64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", descriptor.FullName()))
+	}
 }
 
-func (*QueryGetInferenceResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryGetInferenceResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{3}
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowRequest.id":
+		x.Id = value.Uint()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+	}
 }
 
-func (x *QueryGetInferenceResponse) GetInference() *Inference {
-	if x != nil {
-		return x.Inference
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowRequest.id":
+		panic(fmt.Errorf("field id of message inference.inference.QueryGetDevshardEscrowRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
 	}
-	return nil
 }
 
-type QueryAllInferenceRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowRequest.id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowRequest does not contain field %s", fd.FullName()))
+	}
 }
 
-func (x *QueryAllInferenceRequest) Reset() {
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardEscrowRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryGetDevshardEscrowRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryGetDevshardEscrowRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Id != 0 {
+			n += 1 + runtime.Sov(uint64(x.Id))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardEscrowRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Id != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardEscrowRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+				}
+				x.Id = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Id |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryGetDevshardEscrowResponse        protoreflect.MessageDescriptor
+	fd_QueryGetDevshardEscrowResponse_escrow protoreflect.FieldDescriptor
+	fd_QueryGetDevshardEscrowResponse_found  protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetDevshardEscrowResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardEscrowResponse")
+	fd_QueryGetDevshardEscrowResponse_escrow = md_QueryGetDevshardEscrowResponse.Fields().ByName("escrow")
+	fd_QueryGetDevshardEscrowResponse_found = md_QueryGetDevshardEscrowResponse.Fields().ByName("found")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetDevshardEscrowResponse)(nil)
+
+type fastReflection_QueryGetDevshardEscrowResponse QueryGetDevshardEscrowResponse
+
+func (x *QueryGetDevshardEscrowResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardEscrowResponse)(x)
+}
+
+func (x *QueryGetDevshardEscrowResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[165]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetDevshardEscrowResponse_messageType fastReflection_QueryGetDevshardEscrowResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetDevshardEscrowResponse_messageType{}
+
+type fastReflection_QueryGetDevshardEscrowResponse_messageType struct{}
+
+func (x fastReflection_QueryGetDevshardEscrowResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardEscrowResponse)(nil)
+}
+func (x fastReflection_QueryGetDevshardEscrowResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardEscrowResponse)
+}
+func (x fastReflection_QueryGetDevshardEscrowResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardEscrowResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardEscrowResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetDevshardEscrowResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardEscrowResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetDevshardEscrowResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Escrow != nil {
+		value := protoreflect.ValueOfMessage(x.Escrow.ProtoReflect())
+		if !f(fd_QueryGetDevshardEscrowResponse_escrow, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryGetDevshardEscrowResponse_found, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
+		return x.Escrow != nil
+	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+		return x.Found != false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
+		x.Escrow = nil
+	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+		x.Found = false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
+		value := x.Escrow
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
+		x.Escrow = value.Message().Interface().(*DevshardEscrow)
+	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+		x.Found = value.Bool()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
+		if x.Escrow == nil {
+			x.Escrow = new(DevshardEscrow)
+		}
+		return protoreflect.ValueOfMessage(x.Escrow.ProtoReflect())
+	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryGetDevshardEscrowResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardEscrowResponse.escrow":
+		m := new(DevshardEscrow)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetDevshardEscrowResponse.found":
+		return protoreflect.ValueOfBool(false)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardEscrowResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardEscrowResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardEscrowResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryGetDevshardEscrowResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryGetDevshardEscrowResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Escrow != nil {
+			l = options.Size(x.Escrow)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Found {
+			n += 2
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardEscrowResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.Escrow != nil {
+			encoded, err := options.Marshal(x.Escrow)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardEscrowResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Escrow", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Escrow == nil {
+					x.Escrow = &DevshardEscrow{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Escrow); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Found = bool(v != 0)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryGetDevshardHostEpochStatsRequest             protoreflect.MessageDescriptor
+	fd_QueryGetDevshardHostEpochStatsRequest_epoch_index protoreflect.FieldDescriptor
+	fd_QueryGetDevshardHostEpochStatsRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetDevshardHostEpochStatsRequest = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardHostEpochStatsRequest")
+	fd_QueryGetDevshardHostEpochStatsRequest_epoch_index = md_QueryGetDevshardHostEpochStatsRequest.Fields().ByName("epoch_index")
+	fd_QueryGetDevshardHostEpochStatsRequest_participant = md_QueryGetDevshardHostEpochStatsRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetDevshardHostEpochStatsRequest)(nil)
+
+type fastReflection_QueryGetDevshardHostEpochStatsRequest QueryGetDevshardHostEpochStatsRequest
+
+func (x *QueryGetDevshardHostEpochStatsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardHostEpochStatsRequest)(x)
+}
+
+func (x *QueryGetDevshardHostEpochStatsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[166]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType{}
+
+type fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType struct{}
+
+func (x fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardHostEpochStatsRequest)(nil)
+}
+func (x fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardHostEpochStatsRequest)
+}
+func (x fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardHostEpochStatsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardHostEpochStatsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetDevshardHostEpochStatsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardHostEpochStatsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetDevshardHostEpochStatsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_QueryGetDevshardHostEpochStatsRequest_epoch_index, value) {
+			return
+		}
+	}
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryGetDevshardHostEpochStatsRequest_participant, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
+		return x.EpochIndex != uint64(0)
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
+		return x.Participant != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
+		x.EpochIndex = uint64(0)
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
+		x.Participant = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
+		x.EpochIndex = value.Uint()
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
+		x.Participant = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.QueryGetDevshardHostEpochStatsRequest is not mutable"))
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryGetDevshardHostEpochStatsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryGetDevshardHostEpochStatsRequest.participant":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardHostEpochStatsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				}
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryGetDevshardHostEpochStatsResponse       protoreflect.MessageDescriptor
+	fd_QueryGetDevshardHostEpochStatsResponse_stats protoreflect.FieldDescriptor
+	fd_QueryGetDevshardHostEpochStatsResponse_found protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryGetDevshardHostEpochStatsResponse = File_inference_inference_query_proto.Messages().ByName("QueryGetDevshardHostEpochStatsResponse")
+	fd_QueryGetDevshardHostEpochStatsResponse_stats = md_QueryGetDevshardHostEpochStatsResponse.Fields().ByName("stats")
+	fd_QueryGetDevshardHostEpochStatsResponse_found = md_QueryGetDevshardHostEpochStatsResponse.Fields().ByName("found")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryGetDevshardHostEpochStatsResponse)(nil)
+
+type fastReflection_QueryGetDevshardHostEpochStatsResponse QueryGetDevshardHostEpochStatsResponse
+
+func (x *QueryGetDevshardHostEpochStatsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardHostEpochStatsResponse)(x)
+}
+
+func (x *QueryGetDevshardHostEpochStatsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[167]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType{}
+
+type fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType struct{}
+
+func (x fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryGetDevshardHostEpochStatsResponse)(nil)
+}
+func (x fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardHostEpochStatsResponse)
+}
+func (x fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardHostEpochStatsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryGetDevshardHostEpochStatsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryGetDevshardHostEpochStatsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryGetDevshardHostEpochStatsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryGetDevshardHostEpochStatsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Stats != nil {
+		value := protoreflect.ValueOfMessage(x.Stats.ProtoReflect())
+		if !f(fd_QueryGetDevshardHostEpochStatsResponse_stats, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryGetDevshardHostEpochStatsResponse_found, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
+		return x.Stats != nil
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+		return x.Found != false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
+		x.Stats = nil
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+		x.Found = false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
+		value := x.Stats
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
+		x.Stats = value.Message().Interface().(*DevshardHostEpochStats)
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+		x.Found = value.Bool()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
+		if x.Stats == nil {
+			x.Stats = new(DevshardHostEpochStats)
+		}
+		return protoreflect.ValueOfMessage(x.Stats.ProtoReflect())
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryGetDevshardHostEpochStatsResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.stats":
+		m := new(DevshardHostEpochStats)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryGetDevshardHostEpochStatsResponse.found":
+		return protoreflect.ValueOfBool(false)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryGetDevshardHostEpochStatsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryGetDevshardHostEpochStatsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryGetDevshardHostEpochStatsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryGetDevshardHostEpochStatsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Stats != nil {
+			l = options.Size(x.Stats)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Found {
+			n += 2
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.Stats != nil {
+			encoded, err := options.Marshal(x.Stats)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryGetDevshardHostEpochStatsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Stats == nil {
+					x.Stats = &DevshardHostEpochStats{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Stats); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Found = bool(v != 0)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceCreditRequest             protoreflect.MessageDescriptor
+	fd_QueryMaintenanceCreditRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceCreditRequest = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceCreditRequest")
+	fd_QueryMaintenanceCreditRequest_participant = md_QueryMaintenanceCreditRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceCreditRequest)(nil)
+
+type fastReflection_QueryMaintenanceCreditRequest QueryMaintenanceCreditRequest
+
+func (x *QueryMaintenanceCreditRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceCreditRequest)(x)
+}
+
+func (x *QueryMaintenanceCreditRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[168]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceCreditRequest_messageType fastReflection_QueryMaintenanceCreditRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceCreditRequest_messageType{}
+
+type fastReflection_QueryMaintenanceCreditRequest_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceCreditRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceCreditRequest)(nil)
+}
+func (x fastReflection_QueryMaintenanceCreditRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceCreditRequest)
+}
+func (x fastReflection_QueryMaintenanceCreditRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceCreditRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceCreditRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceCreditRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceCreditRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceCreditRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceCreditRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryMaintenanceCreditRequest_participant, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditRequest.participant":
+		return x.Participant != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditRequest.participant":
+		x.Participant = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceCreditRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditRequest.participant":
+		x.Participant = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryMaintenanceCreditRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceCreditRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditRequest.participant":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceCreditRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceCreditRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceCreditRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceCreditRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceCreditRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceCreditRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceCreditRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceCreditRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceCreditRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceCreditRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceCreditResponse               protoreflect.MessageDescriptor
+	fd_QueryMaintenanceCreditResponse_credit_blocks protoreflect.FieldDescriptor
+	fd_QueryMaintenanceCreditResponse_found         protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceCreditResponse = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceCreditResponse")
+	fd_QueryMaintenanceCreditResponse_credit_blocks = md_QueryMaintenanceCreditResponse.Fields().ByName("credit_blocks")
+	fd_QueryMaintenanceCreditResponse_found = md_QueryMaintenanceCreditResponse.Fields().ByName("found")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceCreditResponse)(nil)
+
+type fastReflection_QueryMaintenanceCreditResponse QueryMaintenanceCreditResponse
+
+func (x *QueryMaintenanceCreditResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceCreditResponse)(x)
+}
+
+func (x *QueryMaintenanceCreditResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[169]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceCreditResponse_messageType fastReflection_QueryMaintenanceCreditResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceCreditResponse_messageType{}
+
+type fastReflection_QueryMaintenanceCreditResponse_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceCreditResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceCreditResponse)(nil)
+}
+func (x fastReflection_QueryMaintenanceCreditResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceCreditResponse)
+}
+func (x fastReflection_QueryMaintenanceCreditResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceCreditResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceCreditResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceCreditResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceCreditResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceCreditResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceCreditResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.CreditBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.CreditBlocks)
+		if !f(fd_QueryMaintenanceCreditResponse_credit_blocks, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryMaintenanceCreditResponse_found, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditResponse.credit_blocks":
+		return x.CreditBlocks != uint64(0)
+	case "inference.inference.QueryMaintenanceCreditResponse.found":
+		return x.Found != false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditResponse.credit_blocks":
+		x.CreditBlocks = uint64(0)
+	case "inference.inference.QueryMaintenanceCreditResponse.found":
+		x.Found = false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceCreditResponse.credit_blocks":
+		value := x.CreditBlocks
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.QueryMaintenanceCreditResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditResponse.credit_blocks":
+		x.CreditBlocks = value.Uint()
+	case "inference.inference.QueryMaintenanceCreditResponse.found":
+		x.Found = value.Bool()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditResponse.credit_blocks":
+		panic(fmt.Errorf("field credit_blocks of message inference.inference.QueryMaintenanceCreditResponse is not mutable"))
+	case "inference.inference.QueryMaintenanceCreditResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryMaintenanceCreditResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceCreditResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceCreditResponse.credit_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.QueryMaintenanceCreditResponse.found":
+		return protoreflect.ValueOfBool(false)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceCreditResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceCreditResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceCreditResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceCreditResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceCreditResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceCreditResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceCreditResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceCreditResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceCreditResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.CreditBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.CreditBlocks))
+		}
+		if x.Found {
+			n += 2
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceCreditResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.CreditBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CreditBlocks))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceCreditResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceCreditResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceCreditResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreditBlocks", wireType)
+				}
+				x.CreditBlocks = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.CreditBlocks |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Found = bool(v != 0)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceScheduledRequest             protoreflect.MessageDescriptor
+	fd_QueryMaintenanceScheduledRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceScheduledRequest = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceScheduledRequest")
+	fd_QueryMaintenanceScheduledRequest_participant = md_QueryMaintenanceScheduledRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceScheduledRequest)(nil)
+
+type fastReflection_QueryMaintenanceScheduledRequest QueryMaintenanceScheduledRequest
+
+func (x *QueryMaintenanceScheduledRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceScheduledRequest)(x)
+}
+
+func (x *QueryMaintenanceScheduledRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[170]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceScheduledRequest_messageType fastReflection_QueryMaintenanceScheduledRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceScheduledRequest_messageType{}
+
+type fastReflection_QueryMaintenanceScheduledRequest_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceScheduledRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceScheduledRequest)(nil)
+}
+func (x fastReflection_QueryMaintenanceScheduledRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceScheduledRequest)
+}
+func (x fastReflection_QueryMaintenanceScheduledRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceScheduledRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceScheduledRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceScheduledRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceScheduledRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceScheduledRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryMaintenanceScheduledRequest_participant, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledRequest.participant":
+		return x.Participant != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledRequest.participant":
+		x.Participant = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledRequest.participant":
+		x.Participant = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryMaintenanceScheduledRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledRequest.participant":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceScheduledRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceScheduledRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceScheduledRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceScheduledRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceScheduledRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceScheduledRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceScheduledRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceScheduledResponse             protoreflect.MessageDescriptor
+	fd_QueryMaintenanceScheduledResponse_reservation protoreflect.FieldDescriptor
+	fd_QueryMaintenanceScheduledResponse_found       protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceScheduledResponse = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceScheduledResponse")
+	fd_QueryMaintenanceScheduledResponse_reservation = md_QueryMaintenanceScheduledResponse.Fields().ByName("reservation")
+	fd_QueryMaintenanceScheduledResponse_found = md_QueryMaintenanceScheduledResponse.Fields().ByName("found")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceScheduledResponse)(nil)
+
+type fastReflection_QueryMaintenanceScheduledResponse QueryMaintenanceScheduledResponse
+
+func (x *QueryMaintenanceScheduledResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceScheduledResponse)(x)
+}
+
+func (x *QueryMaintenanceScheduledResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[171]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceScheduledResponse_messageType fastReflection_QueryMaintenanceScheduledResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceScheduledResponse_messageType{}
+
+type fastReflection_QueryMaintenanceScheduledResponse_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceScheduledResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceScheduledResponse)(nil)
+}
+func (x fastReflection_QueryMaintenanceScheduledResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceScheduledResponse)
+}
+func (x fastReflection_QueryMaintenanceScheduledResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceScheduledResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceScheduledResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceScheduledResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceScheduledResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceScheduledResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Reservation != nil {
+		value := protoreflect.ValueOfMessage(x.Reservation.ProtoReflect())
+		if !f(fd_QueryMaintenanceScheduledResponse_reservation, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryMaintenanceScheduledResponse_found, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledResponse.reservation":
+		return x.Reservation != nil
+	case "inference.inference.QueryMaintenanceScheduledResponse.found":
+		return x.Found != false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledResponse.reservation":
+		x.Reservation = nil
+	case "inference.inference.QueryMaintenanceScheduledResponse.found":
+		x.Found = false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledResponse.reservation":
+		value := x.Reservation
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryMaintenanceScheduledResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledResponse.reservation":
+		x.Reservation = value.Message().Interface().(*MaintenanceReservation)
+	case "inference.inference.QueryMaintenanceScheduledResponse.found":
+		x.Found = value.Bool()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledResponse.reservation":
+		if x.Reservation == nil {
+			x.Reservation = new(MaintenanceReservation)
+		}
+		return protoreflect.ValueOfMessage(x.Reservation.ProtoReflect())
+	case "inference.inference.QueryMaintenanceScheduledResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryMaintenanceScheduledResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceScheduledResponse.reservation":
+		m := new(MaintenanceReservation)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryMaintenanceScheduledResponse.found":
+		return protoreflect.ValueOfBool(false)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceScheduledResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceScheduledResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceScheduledResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceScheduledResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceScheduledResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Reservation != nil {
+			l = options.Size(x.Reservation)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Found {
+			n += 2
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceScheduledResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.Reservation != nil {
+			encoded, err := options.Marshal(x.Reservation)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceScheduledResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceScheduledResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceScheduledResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reservation", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.Reservation == nil {
+					x.Reservation = &MaintenanceReservation{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Reservation); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Found = bool(v != 0)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceActiveRequest protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceActiveRequest = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceActiveRequest")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceActiveRequest)(nil)
+
+type fastReflection_QueryMaintenanceActiveRequest QueryMaintenanceActiveRequest
+
+func (x *QueryMaintenanceActiveRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceActiveRequest)(x)
+}
+
+func (x *QueryMaintenanceActiveRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[172]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceActiveRequest_messageType fastReflection_QueryMaintenanceActiveRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceActiveRequest_messageType{}
+
+type fastReflection_QueryMaintenanceActiveRequest_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceActiveRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceActiveRequest)(nil)
+}
+func (x fastReflection_QueryMaintenanceActiveRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceActiveRequest)
+}
+func (x fastReflection_QueryMaintenanceActiveRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceActiveRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceActiveRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceActiveRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceActiveRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceActiveRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceActiveRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceActiveRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceActiveRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceActiveRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceActiveRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceActiveRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceActiveRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceActiveRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceActiveRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceActiveRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceActiveRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceActiveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryMaintenanceActiveResponse_1_list)(nil)
+
+type _QueryMaintenanceActiveResponse_1_list struct {
+	list *[]*MaintenanceReservation
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MaintenanceReservation)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MaintenanceReservation)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(MaintenanceReservation)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) NewElement() protoreflect.Value {
+	v := new(MaintenanceReservation)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryMaintenanceActiveResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryMaintenanceActiveResponse              protoreflect.MessageDescriptor
+	fd_QueryMaintenanceActiveResponse_reservations protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceActiveResponse = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceActiveResponse")
+	fd_QueryMaintenanceActiveResponse_reservations = md_QueryMaintenanceActiveResponse.Fields().ByName("reservations")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceActiveResponse)(nil)
+
+type fastReflection_QueryMaintenanceActiveResponse QueryMaintenanceActiveResponse
+
+func (x *QueryMaintenanceActiveResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceActiveResponse)(x)
+}
+
+func (x *QueryMaintenanceActiveResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[173]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceActiveResponse_messageType fastReflection_QueryMaintenanceActiveResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceActiveResponse_messageType{}
+
+type fastReflection_QueryMaintenanceActiveResponse_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceActiveResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceActiveResponse)(nil)
+}
+func (x fastReflection_QueryMaintenanceActiveResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceActiveResponse)
+}
+func (x fastReflection_QueryMaintenanceActiveResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceActiveResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceActiveResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceActiveResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceActiveResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceActiveResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceActiveResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Reservations) != 0 {
+		value := protoreflect.ValueOfList(&_QueryMaintenanceActiveResponse_1_list{list: &x.Reservations})
+		if !f(fd_QueryMaintenanceActiveResponse_reservations, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceActiveResponse.reservations":
+		return len(x.Reservations) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceActiveResponse.reservations":
+		x.Reservations = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceActiveResponse.reservations":
+		if len(x.Reservations) == 0 {
+			return protoreflect.ValueOfList(&_QueryMaintenanceActiveResponse_1_list{})
+		}
+		listValue := &_QueryMaintenanceActiveResponse_1_list{list: &x.Reservations}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceActiveResponse.reservations":
+		lv := value.List()
+		clv := lv.(*_QueryMaintenanceActiveResponse_1_list)
+		x.Reservations = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceActiveResponse.reservations":
+		if x.Reservations == nil {
+			x.Reservations = []*MaintenanceReservation{}
+		}
+		value := &_QueryMaintenanceActiveResponse_1_list{list: &x.Reservations}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceActiveResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceActiveResponse.reservations":
+		list := []*MaintenanceReservation{}
+		return protoreflect.ValueOfList(&_QueryMaintenanceActiveResponse_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceActiveResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceActiveResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceActiveResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceActiveResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceActiveResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceActiveResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceActiveResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceActiveResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceActiveResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Reservations) > 0 {
+			for _, e := range x.Reservations {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceActiveResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Reservations) > 0 {
+			for iNdEx := len(x.Reservations) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Reservations[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceActiveResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceActiveResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceActiveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reservations", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Reservations = append(x.Reservations, &MaintenanceReservation{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Reservations[len(x.Reservations)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceStatusRequest             protoreflect.MessageDescriptor
+	fd_QueryMaintenanceStatusRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceStatusRequest = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceStatusRequest")
+	fd_QueryMaintenanceStatusRequest_participant = md_QueryMaintenanceStatusRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceStatusRequest)(nil)
+
+type fastReflection_QueryMaintenanceStatusRequest QueryMaintenanceStatusRequest
+
+func (x *QueryMaintenanceStatusRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceStatusRequest)(x)
+}
+
+func (x *QueryMaintenanceStatusRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[174]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceStatusRequest_messageType fastReflection_QueryMaintenanceStatusRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceStatusRequest_messageType{}
+
+type fastReflection_QueryMaintenanceStatusRequest_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceStatusRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceStatusRequest)(nil)
+}
+func (x fastReflection_QueryMaintenanceStatusRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceStatusRequest)
+}
+func (x fastReflection_QueryMaintenanceStatusRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceStatusRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceStatusRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceStatusRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceStatusRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceStatusRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceStatusRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryMaintenanceStatusRequest_participant, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusRequest.participant":
+		return x.Participant != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusRequest.participant":
+		x.Participant = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceStatusRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusRequest.participant":
+		x.Participant = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryMaintenanceStatusRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceStatusRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusRequest.participant":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceStatusRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceStatusRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceStatusRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceStatusRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceStatusRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceStatusRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceStatusRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceStatusRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceStatusRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceStatusResponse                       protoreflect.MessageDescriptor
+	fd_QueryMaintenanceStatusResponse_state                 protoreflect.FieldDescriptor
+	fd_QueryMaintenanceStatusResponse_active_reservation    protoreflect.FieldDescriptor
+	fd_QueryMaintenanceStatusResponse_scheduled_reservation protoreflect.FieldDescriptor
+	fd_QueryMaintenanceStatusResponse_found                 protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceStatusResponse = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceStatusResponse")
+	fd_QueryMaintenanceStatusResponse_state = md_QueryMaintenanceStatusResponse.Fields().ByName("state")
+	fd_QueryMaintenanceStatusResponse_active_reservation = md_QueryMaintenanceStatusResponse.Fields().ByName("active_reservation")
+	fd_QueryMaintenanceStatusResponse_scheduled_reservation = md_QueryMaintenanceStatusResponse.Fields().ByName("scheduled_reservation")
+	fd_QueryMaintenanceStatusResponse_found = md_QueryMaintenanceStatusResponse.Fields().ByName("found")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceStatusResponse)(nil)
+
+type fastReflection_QueryMaintenanceStatusResponse QueryMaintenanceStatusResponse
+
+func (x *QueryMaintenanceStatusResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceStatusResponse)(x)
+}
+
+func (x *QueryMaintenanceStatusResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[175]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceStatusResponse_messageType fastReflection_QueryMaintenanceStatusResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceStatusResponse_messageType{}
+
+type fastReflection_QueryMaintenanceStatusResponse_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceStatusResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceStatusResponse)(nil)
+}
+func (x fastReflection_QueryMaintenanceStatusResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceStatusResponse)
+}
+func (x fastReflection_QueryMaintenanceStatusResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceStatusResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceStatusResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceStatusResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceStatusResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceStatusResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceStatusResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.State != nil {
+		value := protoreflect.ValueOfMessage(x.State.ProtoReflect())
+		if !f(fd_QueryMaintenanceStatusResponse_state, value) {
+			return
+		}
+	}
+	if x.ActiveReservation != nil {
+		value := protoreflect.ValueOfMessage(x.ActiveReservation.ProtoReflect())
+		if !f(fd_QueryMaintenanceStatusResponse_active_reservation, value) {
+			return
+		}
+	}
+	if x.ScheduledReservation != nil {
+		value := protoreflect.ValueOfMessage(x.ScheduledReservation.ProtoReflect())
+		if !f(fd_QueryMaintenanceStatusResponse_scheduled_reservation, value) {
+			return
+		}
+	}
+	if x.Found != false {
+		value := protoreflect.ValueOfBool(x.Found)
+		if !f(fd_QueryMaintenanceStatusResponse_found, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusResponse.state":
+		return x.State != nil
+	case "inference.inference.QueryMaintenanceStatusResponse.active_reservation":
+		return x.ActiveReservation != nil
+	case "inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation":
+		return x.ScheduledReservation != nil
+	case "inference.inference.QueryMaintenanceStatusResponse.found":
+		return x.Found != false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusResponse.state":
+		x.State = nil
+	case "inference.inference.QueryMaintenanceStatusResponse.active_reservation":
+		x.ActiveReservation = nil
+	case "inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation":
+		x.ScheduledReservation = nil
+	case "inference.inference.QueryMaintenanceStatusResponse.found":
+		x.Found = false
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceStatusResponse.state":
+		value := x.State
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.active_reservation":
+		value := x.ActiveReservation
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation":
+		value := x.ScheduledReservation
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.found":
+		value := x.Found
+		return protoreflect.ValueOfBool(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusResponse.state":
+		x.State = value.Message().Interface().(*MaintenanceState)
+	case "inference.inference.QueryMaintenanceStatusResponse.active_reservation":
+		x.ActiveReservation = value.Message().Interface().(*MaintenanceReservation)
+	case "inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation":
+		x.ScheduledReservation = value.Message().Interface().(*MaintenanceReservation)
+	case "inference.inference.QueryMaintenanceStatusResponse.found":
+		x.Found = value.Bool()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusResponse.state":
+		if x.State == nil {
+			x.State = new(MaintenanceState)
+		}
+		return protoreflect.ValueOfMessage(x.State.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.active_reservation":
+		if x.ActiveReservation == nil {
+			x.ActiveReservation = new(MaintenanceReservation)
+		}
+		return protoreflect.ValueOfMessage(x.ActiveReservation.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation":
+		if x.ScheduledReservation == nil {
+			x.ScheduledReservation = new(MaintenanceReservation)
+		}
+		return protoreflect.ValueOfMessage(x.ScheduledReservation.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.found":
+		panic(fmt.Errorf("field found of message inference.inference.QueryMaintenanceStatusResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceStatusResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceStatusResponse.state":
+		m := new(MaintenanceState)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.active_reservation":
+		m := new(MaintenanceReservation)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation":
+		m := new(MaintenanceReservation)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
+	case "inference.inference.QueryMaintenanceStatusResponse.found":
+		return protoreflect.ValueOfBool(false)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceStatusResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceStatusResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceStatusResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceStatusResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceStatusResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceStatusResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceStatusResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceStatusResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceStatusResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.State != nil {
+			l = options.Size(x.State)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.ActiveReservation != nil {
+			l = options.Size(x.ActiveReservation)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.ScheduledReservation != nil {
+			l = options.Size(x.ScheduledReservation)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Found {
+			n += 2
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceStatusResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Found {
+			i--
+			if x.Found {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x20
+		}
+		if x.ScheduledReservation != nil {
+			encoded, err := options.Marshal(x.ScheduledReservation)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.ActiveReservation != nil {
+			encoded, err := options.Marshal(x.ActiveReservation)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.State != nil {
+			encoded, err := options.Marshal(x.State)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceStatusResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceStatusResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.State == nil {
+					x.State = &MaintenanceState{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.State); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ActiveReservation", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.ActiveReservation == nil {
+					x.ActiveReservation = &MaintenanceReservation{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ActiveReservation); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ScheduledReservation", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.ScheduledReservation == nil {
+					x.ScheduledReservation = &MaintenanceReservation{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ScheduledReservation); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Found = bool(v != 0)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceConcurrencyRequest        protoreflect.MessageDescriptor
+	fd_QueryMaintenanceConcurrencyRequest_height protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceConcurrencyRequest = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceConcurrencyRequest")
+	fd_QueryMaintenanceConcurrencyRequest_height = md_QueryMaintenanceConcurrencyRequest.Fields().ByName("height")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceConcurrencyRequest)(nil)
+
+type fastReflection_QueryMaintenanceConcurrencyRequest QueryMaintenanceConcurrencyRequest
+
+func (x *QueryMaintenanceConcurrencyRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceConcurrencyRequest)(x)
+}
+
+func (x *QueryMaintenanceConcurrencyRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[176]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceConcurrencyRequest_messageType fastReflection_QueryMaintenanceConcurrencyRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceConcurrencyRequest_messageType{}
+
+type fastReflection_QueryMaintenanceConcurrencyRequest_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceConcurrencyRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceConcurrencyRequest)(nil)
+}
+func (x fastReflection_QueryMaintenanceConcurrencyRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceConcurrencyRequest)
+}
+func (x fastReflection_QueryMaintenanceConcurrencyRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceConcurrencyRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceConcurrencyRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceConcurrencyRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceConcurrencyRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceConcurrencyRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Height != int64(0) {
+		value := protoreflect.ValueOfInt64(x.Height)
+		if !f(fd_QueryMaintenanceConcurrencyRequest_height, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyRequest.height":
+		return x.Height != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyRequest.height":
+		x.Height = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyRequest.height":
+		value := x.Height
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyRequest.height":
+		x.Height = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyRequest.height":
+		panic(fmt.Errorf("field height of message inference.inference.QueryMaintenanceConcurrencyRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyRequest.height":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceConcurrencyRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceConcurrencyRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceConcurrencyRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Height != 0 {
+			n += 1 + runtime.Sov(uint64(x.Height))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceConcurrencyRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.Height != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Height))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceConcurrencyRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceConcurrencyRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceConcurrencyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+				}
+				x.Height = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Height |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceConcurrencyResponse                      protoreflect.MessageDescriptor
+	fd_QueryMaintenanceConcurrencyResponse_concurrent_count     protoreflect.FieldDescriptor
+	fd_QueryMaintenanceConcurrencyResponse_concurrent_power_bps protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceConcurrencyResponse = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceConcurrencyResponse")
+	fd_QueryMaintenanceConcurrencyResponse_concurrent_count = md_QueryMaintenanceConcurrencyResponse.Fields().ByName("concurrent_count")
+	fd_QueryMaintenanceConcurrencyResponse_concurrent_power_bps = md_QueryMaintenanceConcurrencyResponse.Fields().ByName("concurrent_power_bps")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceConcurrencyResponse)(nil)
+
+type fastReflection_QueryMaintenanceConcurrencyResponse QueryMaintenanceConcurrencyResponse
+
+func (x *QueryMaintenanceConcurrencyResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceConcurrencyResponse)(x)
+}
+
+func (x *QueryMaintenanceConcurrencyResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[177]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceConcurrencyResponse_messageType fastReflection_QueryMaintenanceConcurrencyResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceConcurrencyResponse_messageType{}
+
+type fastReflection_QueryMaintenanceConcurrencyResponse_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceConcurrencyResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceConcurrencyResponse)(nil)
+}
+func (x fastReflection_QueryMaintenanceConcurrencyResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceConcurrencyResponse)
+}
+func (x fastReflection_QueryMaintenanceConcurrencyResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceConcurrencyResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceConcurrencyResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceConcurrencyResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceConcurrencyResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceConcurrencyResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ConcurrentCount != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.ConcurrentCount)
+		if !f(fd_QueryMaintenanceConcurrencyResponse_concurrent_count, value) {
+			return
+		}
+	}
+	if x.ConcurrentPowerBps != int64(0) {
+		value := protoreflect.ValueOfInt64(x.ConcurrentPowerBps)
+		if !f(fd_QueryMaintenanceConcurrencyResponse_concurrent_power_bps, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_count":
+		return x.ConcurrentCount != uint32(0)
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_power_bps":
+		return x.ConcurrentPowerBps != int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_count":
+		x.ConcurrentCount = uint32(0)
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_power_bps":
+		x.ConcurrentPowerBps = int64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_count":
+		value := x.ConcurrentCount
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_power_bps":
+		value := x.ConcurrentPowerBps
+		return protoreflect.ValueOfInt64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_count":
+		x.ConcurrentCount = uint32(value.Uint())
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_power_bps":
+		x.ConcurrentPowerBps = value.Int()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_count":
+		panic(fmt.Errorf("field concurrent_count of message inference.inference.QueryMaintenanceConcurrencyResponse is not mutable"))
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_power_bps":
+		panic(fmt.Errorf("field concurrent_power_bps of message inference.inference.QueryMaintenanceConcurrencyResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_count":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.QueryMaintenanceConcurrencyResponse.concurrent_power_bps":
+		return protoreflect.ValueOfInt64(int64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceConcurrencyResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceConcurrencyResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceConcurrencyResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceConcurrencyResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceConcurrencyResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.ConcurrentCount != 0 {
+			n += 1 + runtime.Sov(uint64(x.ConcurrentCount))
+		}
+		if x.ConcurrentPowerBps != 0 {
+			n += 1 + runtime.Sov(uint64(x.ConcurrentPowerBps))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceConcurrencyResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.ConcurrentPowerBps != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ConcurrentPowerBps))
+			i--
+			dAtA[i] = 0x10
+		}
+		if x.ConcurrentCount != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ConcurrentCount))
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceConcurrencyResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceConcurrencyResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceConcurrencyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConcurrentCount", wireType)
+				}
+				x.ConcurrentCount = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ConcurrentCount |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConcurrentPowerBps", wireType)
+				}
+				x.ConcurrentPowerBps = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ConcurrentPowerBps |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceSchedulabilityRequest                 protoreflect.MessageDescriptor
+	fd_QueryMaintenanceSchedulabilityRequest_participant     protoreflect.FieldDescriptor
+	fd_QueryMaintenanceSchedulabilityRequest_start_height    protoreflect.FieldDescriptor
+	fd_QueryMaintenanceSchedulabilityRequest_duration_blocks protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceSchedulabilityRequest = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceSchedulabilityRequest")
+	fd_QueryMaintenanceSchedulabilityRequest_participant = md_QueryMaintenanceSchedulabilityRequest.Fields().ByName("participant")
+	fd_QueryMaintenanceSchedulabilityRequest_start_height = md_QueryMaintenanceSchedulabilityRequest.Fields().ByName("start_height")
+	fd_QueryMaintenanceSchedulabilityRequest_duration_blocks = md_QueryMaintenanceSchedulabilityRequest.Fields().ByName("duration_blocks")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceSchedulabilityRequest)(nil)
+
+type fastReflection_QueryMaintenanceSchedulabilityRequest QueryMaintenanceSchedulabilityRequest
+
+func (x *QueryMaintenanceSchedulabilityRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceSchedulabilityRequest)(x)
+}
+
+func (x *QueryMaintenanceSchedulabilityRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[178]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceSchedulabilityRequest_messageType fastReflection_QueryMaintenanceSchedulabilityRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceSchedulabilityRequest_messageType{}
+
+type fastReflection_QueryMaintenanceSchedulabilityRequest_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceSchedulabilityRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceSchedulabilityRequest)(nil)
+}
+func (x fastReflection_QueryMaintenanceSchedulabilityRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceSchedulabilityRequest)
+}
+func (x fastReflection_QueryMaintenanceSchedulabilityRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceSchedulabilityRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceSchedulabilityRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceSchedulabilityRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceSchedulabilityRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceSchedulabilityRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryMaintenanceSchedulabilityRequest_participant, value) {
+			return
+		}
+	}
+	if x.StartHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.StartHeight)
+		if !f(fd_QueryMaintenanceSchedulabilityRequest_start_height, value) {
+			return
+		}
+	}
+	if x.DurationBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.DurationBlocks)
+		if !f(fd_QueryMaintenanceSchedulabilityRequest_duration_blocks, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.participant":
+		return x.Participant != ""
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.start_height":
+		return x.StartHeight != int64(0)
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.duration_blocks":
+		return x.DurationBlocks != uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.participant":
+		x.Participant = ""
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.start_height":
+		x.StartHeight = int64(0)
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.duration_blocks":
+		x.DurationBlocks = uint64(0)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.start_height":
+		value := x.StartHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.duration_blocks":
+		value := x.DurationBlocks
+		return protoreflect.ValueOfUint64(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.start_height":
+		x.StartHeight = value.Int()
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.duration_blocks":
+		x.DurationBlocks = value.Uint()
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryMaintenanceSchedulabilityRequest is not mutable"))
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.start_height":
+		panic(fmt.Errorf("field start_height of message inference.inference.QueryMaintenanceSchedulabilityRequest is not mutable"))
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.duration_blocks":
+		panic(fmt.Errorf("field duration_blocks of message inference.inference.QueryMaintenanceSchedulabilityRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.participant":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.start_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.QueryMaintenanceSchedulabilityRequest.duration_blocks":
+		return protoreflect.ValueOfUint64(uint64(0))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceSchedulabilityRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceSchedulabilityRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceSchedulabilityRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.StartHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.StartHeight))
+		}
+		if x.DurationBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.DurationBlocks))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceSchedulabilityRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if x.DurationBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.DurationBlocks))
+			i--
+			dAtA[i] = 0x18
+		}
+		if x.StartHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.StartHeight))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceSchedulabilityRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceSchedulabilityRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceSchedulabilityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
+				}
+				x.StartHeight = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.StartHeight |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DurationBlocks", wireType)
+				}
+				x.DurationBlocks = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.DurationBlocks |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryMaintenanceSchedulabilityResponse                  protoreflect.MessageDescriptor
+	fd_QueryMaintenanceSchedulabilityResponse_schedulable      protoreflect.FieldDescriptor
+	fd_QueryMaintenanceSchedulabilityResponse_rejection_reason protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryMaintenanceSchedulabilityResponse = File_inference_inference_query_proto.Messages().ByName("QueryMaintenanceSchedulabilityResponse")
+	fd_QueryMaintenanceSchedulabilityResponse_schedulable = md_QueryMaintenanceSchedulabilityResponse.Fields().ByName("schedulable")
+	fd_QueryMaintenanceSchedulabilityResponse_rejection_reason = md_QueryMaintenanceSchedulabilityResponse.Fields().ByName("rejection_reason")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryMaintenanceSchedulabilityResponse)(nil)
+
+type fastReflection_QueryMaintenanceSchedulabilityResponse QueryMaintenanceSchedulabilityResponse
+
+func (x *QueryMaintenanceSchedulabilityResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceSchedulabilityResponse)(x)
+}
+
+func (x *QueryMaintenanceSchedulabilityResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[179]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryMaintenanceSchedulabilityResponse_messageType fastReflection_QueryMaintenanceSchedulabilityResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryMaintenanceSchedulabilityResponse_messageType{}
+
+type fastReflection_QueryMaintenanceSchedulabilityResponse_messageType struct{}
+
+func (x fastReflection_QueryMaintenanceSchedulabilityResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryMaintenanceSchedulabilityResponse)(nil)
+}
+func (x fastReflection_QueryMaintenanceSchedulabilityResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceSchedulabilityResponse)
+}
+func (x fastReflection_QueryMaintenanceSchedulabilityResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceSchedulabilityResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryMaintenanceSchedulabilityResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryMaintenanceSchedulabilityResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryMaintenanceSchedulabilityResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryMaintenanceSchedulabilityResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Schedulable != false {
+		value := protoreflect.ValueOfBool(x.Schedulable)
+		if !f(fd_QueryMaintenanceSchedulabilityResponse_schedulable, value) {
+			return
+		}
+	}
+	if x.RejectionReason != "" {
+		value := protoreflect.ValueOfString(x.RejectionReason)
+		if !f(fd_QueryMaintenanceSchedulabilityResponse_rejection_reason, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.schedulable":
+		return x.Schedulable != false
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.rejection_reason":
+		return x.RejectionReason != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.schedulable":
+		x.Schedulable = false
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.rejection_reason":
+		x.RejectionReason = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.schedulable":
+		value := x.Schedulable
+		return protoreflect.ValueOfBool(value)
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.rejection_reason":
+		value := x.RejectionReason
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.schedulable":
+		x.Schedulable = value.Bool()
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.rejection_reason":
+		x.RejectionReason = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.schedulable":
+		panic(fmt.Errorf("field schedulable of message inference.inference.QueryMaintenanceSchedulabilityResponse is not mutable"))
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.rejection_reason":
+		panic(fmt.Errorf("field rejection_reason of message inference.inference.QueryMaintenanceSchedulabilityResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.schedulable":
+		return protoreflect.ValueOfBool(false)
+	case "inference.inference.QueryMaintenanceSchedulabilityResponse.rejection_reason":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryMaintenanceSchedulabilityResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryMaintenanceSchedulabilityResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryMaintenanceSchedulabilityResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryMaintenanceSchedulabilityResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryMaintenanceSchedulabilityResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.Schedulable {
+			n += 2
+		}
+		l = len(x.RejectionReason)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceSchedulabilityResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.RejectionReason) > 0 {
+			i -= len(x.RejectionReason)
+			copy(dAtA[i:], x.RejectionReason)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RejectionReason)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if x.Schedulable {
+			i--
+			if x.Schedulable {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x8
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryMaintenanceSchedulabilityResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceSchedulabilityResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryMaintenanceSchedulabilityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Schedulable", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Schedulable = bool(v != 0)
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RejectionReason", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.RejectionReason = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_QueryListClaimRecipientsRequest             protoreflect.MessageDescriptor
+	fd_QueryListClaimRecipientsRequest_participant protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryListClaimRecipientsRequest = File_inference_inference_query_proto.Messages().ByName("QueryListClaimRecipientsRequest")
+	fd_QueryListClaimRecipientsRequest_participant = md_QueryListClaimRecipientsRequest.Fields().ByName("participant")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryListClaimRecipientsRequest)(nil)
+
+type fastReflection_QueryListClaimRecipientsRequest QueryListClaimRecipientsRequest
+
+func (x *QueryListClaimRecipientsRequest) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryListClaimRecipientsRequest)(x)
+}
+
+func (x *QueryListClaimRecipientsRequest) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[180]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryListClaimRecipientsRequest_messageType fastReflection_QueryListClaimRecipientsRequest_messageType
+var _ protoreflect.MessageType = fastReflection_QueryListClaimRecipientsRequest_messageType{}
+
+type fastReflection_QueryListClaimRecipientsRequest_messageType struct{}
+
+func (x fastReflection_QueryListClaimRecipientsRequest_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryListClaimRecipientsRequest)(nil)
+}
+func (x fastReflection_QueryListClaimRecipientsRequest_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryListClaimRecipientsRequest)
+}
+func (x fastReflection_QueryListClaimRecipientsRequest_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryListClaimRecipientsRequest
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryListClaimRecipientsRequest
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Type() protoreflect.MessageType {
+	return _fastReflection_QueryListClaimRecipientsRequest_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryListClaimRecipientsRequest) New() protoreflect.Message {
+	return new(fastReflection_QueryListClaimRecipientsRequest)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Interface() protoreflect.ProtoMessage {
+	return (*QueryListClaimRecipientsRequest)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_QueryListClaimRecipientsRequest_participant, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsRequest.participant":
+		return x.Participant != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsRequest.participant":
+		x.Participant = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryListClaimRecipientsRequest.participant":
+		value := x.Participant
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsRequest does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsRequest.participant":
+		x.Participant = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsRequest.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.QueryListClaimRecipientsRequest is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryListClaimRecipientsRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsRequest.participant":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsRequest"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsRequest does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryListClaimRecipientsRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryListClaimRecipientsRequest", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryListClaimRecipientsRequest) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsRequest) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryListClaimRecipientsRequest) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryListClaimRecipientsRequest) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryListClaimRecipientsRequest)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Participant)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryListClaimRecipientsRequest)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryListClaimRecipientsRequest)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryListClaimRecipientsRequest: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryListClaimRecipientsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Participant = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_QueryListClaimRecipientsResponse_1_list)(nil)
+
+type _QueryListClaimRecipientsResponse_1_list struct {
+	list *[]*ClaimRecipientEntry
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ClaimRecipientEntry)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ClaimRecipientEntry)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) AppendMutable() protoreflect.Value {
+	v := new(ClaimRecipientEntry)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) NewElement() protoreflect.Value {
+	v := new(ClaimRecipientEntry)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_QueryListClaimRecipientsResponse_1_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_QueryListClaimRecipientsResponse         protoreflect.MessageDescriptor
+	fd_QueryListClaimRecipientsResponse_entries protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_query_proto_init()
+	md_QueryListClaimRecipientsResponse = File_inference_inference_query_proto.Messages().ByName("QueryListClaimRecipientsResponse")
+	fd_QueryListClaimRecipientsResponse_entries = md_QueryListClaimRecipientsResponse.Fields().ByName("entries")
+}
+
+var _ protoreflect.Message = (*fastReflection_QueryListClaimRecipientsResponse)(nil)
+
+type fastReflection_QueryListClaimRecipientsResponse QueryListClaimRecipientsResponse
+
+func (x *QueryListClaimRecipientsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_QueryListClaimRecipientsResponse)(x)
+}
+
+func (x *QueryListClaimRecipientsResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_query_proto_msgTypes[181]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_QueryListClaimRecipientsResponse_messageType fastReflection_QueryListClaimRecipientsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_QueryListClaimRecipientsResponse_messageType{}
+
+type fastReflection_QueryListClaimRecipientsResponse_messageType struct{}
+
+func (x fastReflection_QueryListClaimRecipientsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_QueryListClaimRecipientsResponse)(nil)
+}
+func (x fastReflection_QueryListClaimRecipientsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_QueryListClaimRecipientsResponse)
+}
+func (x fastReflection_QueryListClaimRecipientsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryListClaimRecipientsResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_QueryListClaimRecipientsResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_QueryListClaimRecipientsResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_QueryListClaimRecipientsResponse) New() protoreflect.Message {
+	return new(fastReflection_QueryListClaimRecipientsResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Interface() protoreflect.ProtoMessage {
+	return (*QueryListClaimRecipientsResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if len(x.Entries) != 0 {
+		value := protoreflect.ValueOfList(&_QueryListClaimRecipientsResponse_1_list{list: &x.Entries})
+		if !f(fd_QueryListClaimRecipientsResponse_entries, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsResponse.entries":
+		return len(x.Entries) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsResponse.entries":
+		x.Entries = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.QueryListClaimRecipientsResponse.entries":
+		if len(x.Entries) == 0 {
+			return protoreflect.ValueOfList(&_QueryListClaimRecipientsResponse_1_list{})
+		}
+		listValue := &_QueryListClaimRecipientsResponse_1_list{list: &x.Entries}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsResponse.entries":
+		lv := value.List()
+		clv := lv.(*_QueryListClaimRecipientsResponse_1_list)
+		x.Entries = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsResponse.entries":
+		if x.Entries == nil {
+			x.Entries = []*ClaimRecipientEntry{}
+		}
+		value := &_QueryListClaimRecipientsResponse_1_list{list: &x.Entries}
+		return protoreflect.ValueOfList(value)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_QueryListClaimRecipientsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.QueryListClaimRecipientsResponse.entries":
+		list := []*ClaimRecipientEntry{}
+		return protoreflect.ValueOfList(&_QueryListClaimRecipientsResponse_1_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.QueryListClaimRecipientsResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.QueryListClaimRecipientsResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_QueryListClaimRecipientsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.QueryListClaimRecipientsResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_QueryListClaimRecipientsResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_QueryListClaimRecipientsResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_QueryListClaimRecipientsResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_QueryListClaimRecipientsResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*QueryListClaimRecipientsResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if len(x.Entries) > 0 {
+			for _, e := range x.Entries {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*QueryListClaimRecipientsResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Entries) > 0 {
+			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Entries[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0xa
+			}
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*QueryListClaimRecipientsResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryListClaimRecipientsResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryListClaimRecipientsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Entries = append(x.Entries, &ClaimRecipientEntry{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.0
+// 	protoc        (unknown)
+// source: inference/inference/query.proto
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// QueryParamsRequest is request type for the Query/Params RPC method.
+type QueryParamsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *QueryParamsRequest) Reset() {
+	*x = QueryParamsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryParamsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryParamsRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryParamsRequest.ProtoReflect.Descriptor instead.
+func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{0}
+}
+
+// QueryParamsResponse is response type for the Query/Params RPC method.
+type QueryParamsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// params holds all the parameters of this module.
+	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (x *QueryParamsResponse) Reset() {
+	*x = QueryParamsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryParamsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryParamsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryParamsResponse.ProtoReflect.Descriptor instead.
+func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *QueryParamsResponse) GetParams() *Params {
+	if x != nil {
+		return x.Params
+	}
+	return nil
+}
+
+type QueryGetInferenceRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+}
+
+func (x *QueryGetInferenceRequest) Reset() {
+	*x = QueryGetInferenceRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetInferenceRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetInferenceRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryGetInferenceRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *QueryGetInferenceRequest) GetIndex() string {
+	if x != nil {
+		return x.Index
+	}
+	return ""
+}
+
+type QueryGetInferenceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Inference *Inference `protobuf:"bytes,1,opt,name=inference,proto3" json:"inference,omitempty"`
+}
+
+func (x *QueryGetInferenceResponse) Reset() {
+	*x = QueryGetInferenceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetInferenceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetInferenceResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetInferenceResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *QueryGetInferenceResponse) GetInference() *Inference {
+	if x != nil {
+		return x.Inference
+	}
+	return nil
+}
+
+type QueryAllInferenceRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllInferenceRequest) Reset() {
 	*x = QueryAllInferenceRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[4]
+		mi := &file_inference_inference_query_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAllInferenceRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllInferenceRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllInferenceRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllInferenceRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *QueryAllInferenceRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryAllInferenceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Inference  []*Inference          `protobuf:"bytes,1,rep,name=inference,proto3" json:"inference,omitempty"`
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllInferenceResponse) Reset() {
+	*x = QueryAllInferenceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAllInferenceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllInferenceResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryAllInferenceResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllInferenceResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *QueryAllInferenceResponse) GetInference() []*Inference {
+	if x != nil {
+		return x.Inference
+	}
+	return nil
+}
+
+func (x *QueryAllInferenceResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryGetParticipantRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+}
+
+func (x *QueryGetParticipantRequest) Reset() {
+	*x = QueryGetParticipantRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetParticipantRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetParticipantRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryGetParticipantRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetParticipantRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *QueryGetParticipantRequest) GetIndex() string {
+	if x != nil {
+		return x.Index
+	}
+	return ""
+}
+
+type QueryGetParticipantResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Participant *Participant `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+}
+
+func (x *QueryGetParticipantResponse) Reset() {
+	*x = QueryGetParticipantResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetParticipantResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetParticipantResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetParticipantResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetParticipantResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *QueryGetParticipantResponse) GetParticipant() *Participant {
+	if x != nil {
+		return x.Participant
+	}
+	return nil
+}
+
+type QueryAllParticipantRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllParticipantRequest) Reset() {
+	*x = QueryAllParticipantRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAllParticipantRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllParticipantRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllParticipantRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllParticipantRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *QueryAllParticipantRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryAllParticipantResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Participant []*Participant        `protobuf:"bytes,1,rep,name=participant,proto3" json:"participant,omitempty"`
+	Pagination  *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	BlockHeight int64                 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+}
+
+func (x *QueryAllParticipantResponse) Reset() {
+	*x = QueryAllParticipantResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[9]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAllParticipantResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllParticipantResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryAllParticipantResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllParticipantResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *QueryAllParticipantResponse) GetParticipant() []*Participant {
+	if x != nil {
+		return x.Participant
+	}
+	return nil
+}
+
+func (x *QueryAllParticipantResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+func (x *QueryAllParticipantResponse) GetBlockHeight() int64 {
+	if x != nil {
+		return x.BlockHeight
+	}
+	return 0
+}
+
+type QueryAccountByAddressRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+}
+
+func (x *QueryAccountByAddressRequest) Reset() {
+	*x = QueryAccountByAddressRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[10]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAccountByAddressRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAccountByAddressRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAccountByAddressRequest.ProtoReflect.Descriptor instead.
+func (*QueryAccountByAddressRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *QueryAccountByAddressRequest) GetAddress() string {
+	if x != nil {
+		return x.Address
+	}
+	return ""
+}
+
+type QueryAccountByAddressResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Pubkey  string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
+	Balance int64  `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"`
+	Denom   string `protobuf:"bytes,3,opt,name=denom,proto3" json:"denom,omitempty"`
+}
+
+func (x *QueryAccountByAddressResponse) Reset() {
+	*x = QueryAccountByAddressResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[11]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAccountByAddressResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAccountByAddressResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryAccountByAddressResponse.ProtoReflect.Descriptor instead.
+func (*QueryAccountByAddressResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *QueryAccountByAddressResponse) GetPubkey() string {
+	if x != nil {
+		return x.Pubkey
+	}
+	return ""
+}
+
+func (x *QueryAccountByAddressResponse) GetBalance() int64 {
+	if x != nil {
+		return x.Balance
+	}
+	return 0
+}
+
+func (x *QueryAccountByAddressResponse) GetDenom() string {
+	if x != nil {
+		return x.Denom
+	}
+	return ""
+}
+
+type QueryGetRandomExecutorRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Model string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
+}
+
+func (x *QueryGetRandomExecutorRequest) Reset() {
+	*x = QueryGetRandomExecutorRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetRandomExecutorRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetRandomExecutorRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryGetRandomExecutorRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetRandomExecutorRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *QueryGetRandomExecutorRequest) GetModel() string {
+	if x != nil {
+		return x.Model
+	}
+	return ""
+}
+
+type QueryGetRandomExecutorResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Executor *Participant `protobuf:"bytes,1,opt,name=executor,proto3" json:"executor,omitempty"`
+}
+
+func (x *QueryGetRandomExecutorResponse) Reset() {
+	*x = QueryGetRandomExecutorResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetRandomExecutorResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetRandomExecutorResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetRandomExecutorResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetRandomExecutorResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *QueryGetRandomExecutorResponse) GetExecutor() *Participant {
+	if x != nil {
+		return x.Executor
+	}
+	return nil
+}
+
+type QueryGetEpochGroupDataRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	ModelId    string `protobuf:"bytes,2,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+}
+
+func (x *QueryGetEpochGroupDataRequest) Reset() {
+	*x = QueryGetEpochGroupDataRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllInferenceRequest) String() string {
+func (x *QueryGetEpochGroupDataRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllInferenceRequest) ProtoMessage() {}
+func (*QueryGetEpochGroupDataRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllInferenceRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllInferenceRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{4}
+// Deprecated: Use QueryGetEpochGroupDataRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetEpochGroupDataRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{14}
 }
 
-func (x *QueryAllInferenceRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryGetEpochGroupDataRequest) GetEpochIndex() uint64 {
+	if x != nil {
+		return x.EpochIndex
+	}
+	return 0
+}
+
+func (x *QueryGetEpochGroupDataRequest) GetModelId() string {
+	if x != nil {
+		return x.ModelId
+	}
+	return ""
+}
+
+type QueryGetEpochGroupDataResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	EpochGroupData *EpochGroupData `protobuf:"bytes,1,opt,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
+}
+
+func (x *QueryGetEpochGroupDataResponse) Reset() {
+	*x = QueryGetEpochGroupDataResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[15]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetEpochGroupDataResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetEpochGroupDataResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetEpochGroupDataResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetEpochGroupDataResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *QueryGetEpochGroupDataResponse) GetEpochGroupData() *EpochGroupData {
+	if x != nil {
+		return x.EpochGroupData
+	}
+	return nil
+}
+
+type QueryAllEpochGroupDataRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+}
+
+func (x *QueryAllEpochGroupDataRequest) Reset() {
+	*x = QueryAllEpochGroupDataRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryAllEpochGroupDataRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryAllEpochGroupDataRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllEpochGroupDataRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllEpochGroupDataRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *QueryAllEpochGroupDataRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
 		return x.Pagination
 	}
 	return nil
 }
 
-type QueryAllInferenceResponse struct {
+type QueryAllEpochGroupDataResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Inference  []*Inference          `protobuf:"bytes,1,rep,name=inference,proto3" json:"inference,omitempty"`
-	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	EpochGroupData []*EpochGroupData     `protobuf:"bytes,1,rep,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
+	Pagination     *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryAllInferenceResponse) Reset() {
-	*x = QueryAllInferenceResponse{}
+func (x *QueryAllEpochGroupDataResponse) Reset() {
+	*x = QueryAllEpochGroupDataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[5]
+		mi := &file_inference_inference_query_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllInferenceResponse) String() string {
+func (x *QueryAllEpochGroupDataResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllInferenceResponse) ProtoMessage() {}
+func (*QueryAllEpochGroupDataResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllInferenceResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllInferenceResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{5}
+// Deprecated: Use QueryAllEpochGroupDataResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllEpochGroupDataResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{17}
 }
 
-func (x *QueryAllInferenceResponse) GetInference() []*Inference {
+func (x *QueryAllEpochGroupDataResponse) GetEpochGroupData() []*EpochGroupData {
 	if x != nil {
-		return x.Inference
+		return x.EpochGroupData
 	}
 	return nil
 }
 
-func (x *QueryAllInferenceResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryAllEpochGroupDataResponse) GetPagination() *v1beta1.PageResponse {
 	if x != nil {
 		return x.Pagination
 	}
 	return nil
 }
 
-type QueryGetParticipantRequest struct {
+type QueryGetSettleAmountRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryGetParticipantRequest) Reset() {
-	*x = QueryGetParticipantRequest{}
+func (x *QueryGetSettleAmountRequest) Reset() {
+	*x = QueryGetSettleAmountRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[6]
+		mi := &file_inference_inference_query_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetParticipantRequest) String() string {
+func (x *QueryGetSettleAmountRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetParticipantRequest) ProtoMessage() {}
+func (*QueryGetSettleAmountRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetParticipantRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetParticipantRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{6}
+// Deprecated: Use QueryGetSettleAmountRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetSettleAmountRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{18}
 }
 
-func (x *QueryGetParticipantRequest) GetIndex() string {
+func (x *QueryGetSettleAmountRequest) GetParticipant() string {
 	if x != nil {
-		return x.Index
+		return x.Participant
 	}
 	return ""
 }
 
-type QueryGetParticipantResponse struct {
+type QueryGetSettleAmountResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant *Participant `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	SettleAmount *SettleAmount `protobuf:"bytes,1,opt,name=settle_amount,json=settleAmount,proto3" json:"settle_amount,omitempty"`
 }
 
-func (x *QueryGetParticipantResponse) Reset() {
-	*x = QueryGetParticipantResponse{}
+func (x *QueryGetSettleAmountResponse) Reset() {
+	*x = QueryGetSettleAmountResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[7]
+		mi := &file_inference_inference_query_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetParticipantResponse) String() string {
+func (x *QueryGetSettleAmountResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetParticipantResponse) ProtoMessage() {}
+func (*QueryGetSettleAmountResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetParticipantResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetParticipantResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{7}
+// Deprecated: Use QueryGetSettleAmountResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetSettleAmountResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{19}
 }
 
-func (x *QueryGetParticipantResponse) GetParticipant() *Participant {
+func (x *QueryGetSettleAmountResponse) GetSettleAmount() *SettleAmount {
 	if x != nil {
-		return x.Participant
+		return x.SettleAmount
 	}
 	return nil
 }
 
-type QueryAllParticipantRequest struct {
+type QueryAllSettleAmountRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -78282,6094 +86883,6317 @@ type QueryAllParticipantRequest struct {
 	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryAllParticipantRequest) Reset() {
-	*x = QueryAllParticipantRequest{}
+func (x *QueryAllSettleAmountRequest) Reset() {
+	*x = QueryAllSettleAmountRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[8]
+		mi := &file_inference_inference_query_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllParticipantRequest) String() string {
+func (x *QueryAllSettleAmountRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllParticipantRequest) ProtoMessage() {}
+func (*QueryAllSettleAmountRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllParticipantRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllParticipantRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{8}
+// Deprecated: Use QueryAllSettleAmountRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllSettleAmountRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{20}
 }
 
-func (x *QueryAllParticipantRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryAllSettleAmountRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
 		return x.Pagination
 	}
 	return nil
 }
 
-type QueryAllParticipantResponse struct {
+type QueryAllSettleAmountResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant []*Participant        `protobuf:"bytes,1,rep,name=participant,proto3" json:"participant,omitempty"`
-	Pagination  *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-	BlockHeight int64                 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	SettleAmount []*SettleAmount       `protobuf:"bytes,1,rep,name=settle_amount,json=settleAmount,proto3" json:"settle_amount,omitempty"`
+	Pagination   *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryAllParticipantResponse) Reset() {
-	*x = QueryAllParticipantResponse{}
+func (x *QueryAllSettleAmountResponse) Reset() {
+	*x = QueryAllSettleAmountResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[9]
+		mi := &file_inference_inference_query_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllParticipantResponse) String() string {
+func (x *QueryAllSettleAmountResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllParticipantResponse) ProtoMessage() {}
+func (*QueryAllSettleAmountResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllParticipantResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllParticipantResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{9}
+// Deprecated: Use QueryAllSettleAmountResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllSettleAmountResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{21}
 }
 
-func (x *QueryAllParticipantResponse) GetParticipant() []*Participant {
+func (x *QueryAllSettleAmountResponse) GetSettleAmount() []*SettleAmount {
 	if x != nil {
-		return x.Participant
+		return x.SettleAmount
 	}
 	return nil
 }
 
-func (x *QueryAllParticipantResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryAllSettleAmountResponse) GetPagination() *v1beta1.PageResponse {
 	if x != nil {
 		return x.Pagination
 	}
 	return nil
 }
 
-func (x *QueryAllParticipantResponse) GetBlockHeight() int64 {
+type QueryEstimateBitcoinRewardRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+}
+
+func (x *QueryEstimateBitcoinRewardRequest) Reset() {
+	*x = QueryEstimateBitcoinRewardRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryEstimateBitcoinRewardRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryEstimateBitcoinRewardRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryEstimateBitcoinRewardRequest.ProtoReflect.Descriptor instead.
+func (*QueryEstimateBitcoinRewardRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *QueryEstimateBitcoinRewardRequest) GetParticipant() string {
 	if x != nil {
-		return x.BlockHeight
+		return x.Participant
 	}
-	return 0
+	return ""
 }
 
-type QueryAccountByAddressRequest struct {
+type QueryEstimateBitcoinRewardResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	SettleAmount *SettleAmount `protobuf:"bytes,1,opt,name=settle_amount,json=settleAmount,proto3" json:"settle_amount,omitempty"`
 }
 
-func (x *QueryAccountByAddressRequest) Reset() {
-	*x = QueryAccountByAddressRequest{}
+func (x *QueryEstimateBitcoinRewardResponse) Reset() {
+	*x = QueryEstimateBitcoinRewardResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[10]
+		mi := &file_inference_inference_query_proto_msgTypes[23]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAccountByAddressRequest) String() string {
+func (x *QueryEstimateBitcoinRewardResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAccountByAddressRequest) ProtoMessage() {}
+func (*QueryEstimateBitcoinRewardResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAccountByAddressRequest.ProtoReflect.Descriptor instead.
-func (*QueryAccountByAddressRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{10}
+// Deprecated: Use QueryEstimateBitcoinRewardResponse.ProtoReflect.Descriptor instead.
+func (*QueryEstimateBitcoinRewardResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{23}
 }
 
-func (x *QueryAccountByAddressRequest) GetAddress() string {
+func (x *QueryEstimateBitcoinRewardResponse) GetSettleAmount() *SettleAmount {
 	if x != nil {
-		return x.Address
+		return x.SettleAmount
 	}
-	return ""
+	return nil
 }
 
-type QueryAccountByAddressResponse struct {
+type QueryGetEpochGroupValidationsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pubkey  string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
-	Balance int64  `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"`
-	Denom   string `protobuf:"bytes,3,opt,name=denom,proto3" json:"denom,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	EpochIndex  uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *QueryAccountByAddressResponse) Reset() {
-	*x = QueryAccountByAddressResponse{}
+func (x *QueryGetEpochGroupValidationsRequest) Reset() {
+	*x = QueryGetEpochGroupValidationsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[11]
+		mi := &file_inference_inference_query_proto_msgTypes[24]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAccountByAddressResponse) String() string {
+func (x *QueryGetEpochGroupValidationsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAccountByAddressResponse) ProtoMessage() {}
+func (*QueryGetEpochGroupValidationsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAccountByAddressResponse.ProtoReflect.Descriptor instead.
-func (*QueryAccountByAddressResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{11}
+// Deprecated: Use QueryGetEpochGroupValidationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetEpochGroupValidationsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{24}
 }
 
-func (x *QueryAccountByAddressResponse) GetPubkey() string {
+func (x *QueryGetEpochGroupValidationsRequest) GetParticipant() string {
 	if x != nil {
-		return x.Pubkey
+		return x.Participant
 	}
 	return ""
 }
 
-func (x *QueryAccountByAddressResponse) GetBalance() int64 {
+func (x *QueryGetEpochGroupValidationsRequest) GetEpochIndex() uint64 {
 	if x != nil {
-		return x.Balance
+		return x.EpochIndex
 	}
 	return 0
 }
 
-func (x *QueryAccountByAddressResponse) GetDenom() string {
+type QueryGetEpochGroupValidationsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	EpochGroupValidations *EpochGroupValidations `protobuf:"bytes,1,opt,name=epoch_group_validations,json=epochGroupValidations,proto3" json:"epoch_group_validations,omitempty"`
+}
+
+func (x *QueryGetEpochGroupValidationsResponse) Reset() {
+	*x = QueryGetEpochGroupValidationsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryGetEpochGroupValidationsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetEpochGroupValidationsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetEpochGroupValidationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetEpochGroupValidationsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *QueryGetEpochGroupValidationsResponse) GetEpochGroupValidations() *EpochGroupValidations {
 	if x != nil {
-		return x.Denom
+		return x.EpochGroupValidations
 	}
-	return ""
+	return nil
 }
 
-type QueryGetRandomExecutorRequest struct {
+type QueryAllEpochGroupValidationsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Model string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryGetRandomExecutorRequest) Reset() {
-	*x = QueryGetRandomExecutorRequest{}
+func (x *QueryAllEpochGroupValidationsRequest) Reset() {
+	*x = QueryAllEpochGroupValidationsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[12]
+		mi := &file_inference_inference_query_proto_msgTypes[26]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetRandomExecutorRequest) String() string {
+func (x *QueryAllEpochGroupValidationsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetRandomExecutorRequest) ProtoMessage() {}
+func (*QueryAllEpochGroupValidationsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetRandomExecutorRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetRandomExecutorRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{12}
+// Deprecated: Use QueryAllEpochGroupValidationsRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllEpochGroupValidationsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{26}
 }
 
-func (x *QueryGetRandomExecutorRequest) GetModel() string {
+func (x *QueryAllEpochGroupValidationsRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.Model
+		return x.Pagination
 	}
-	return ""
+	return nil
 }
 
-type QueryGetRandomExecutorResponse struct {
+type QueryAllEpochGroupValidationsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Executor *Participant `protobuf:"bytes,1,opt,name=executor,proto3" json:"executor,omitempty"`
+	EpochGroupValidations []*EpochGroupValidations `protobuf:"bytes,1,rep,name=epoch_group_validations,json=epochGroupValidations,proto3" json:"epoch_group_validations,omitempty"`
+	Pagination            *v1beta1.PageResponse    `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryGetRandomExecutorResponse) Reset() {
-	*x = QueryGetRandomExecutorResponse{}
+func (x *QueryAllEpochGroupValidationsResponse) Reset() {
+	*x = QueryAllEpochGroupValidationsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[13]
+		mi := &file_inference_inference_query_proto_msgTypes[27]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetRandomExecutorResponse) String() string {
+func (x *QueryAllEpochGroupValidationsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetRandomExecutorResponse) ProtoMessage() {}
+func (*QueryAllEpochGroupValidationsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetRandomExecutorResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetRandomExecutorResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{13}
+// Deprecated: Use QueryAllEpochGroupValidationsResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllEpochGroupValidationsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{27}
 }
 
-func (x *QueryGetRandomExecutorResponse) GetExecutor() *Participant {
+func (x *QueryAllEpochGroupValidationsResponse) GetEpochGroupValidations() []*EpochGroupValidations {
 	if x != nil {
-		return x.Executor
+		return x.EpochGroupValidations
 	}
 	return nil
 }
 
-type QueryGetEpochGroupDataRequest struct {
+func (x *QueryAllEpochGroupValidationsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryPocBatchesForStageRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
-	ModelId    string `protobuf:"bytes,2,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	BlockHeight int64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *QueryGetEpochGroupDataRequest) Reset() {
-	*x = QueryGetEpochGroupDataRequest{}
+func (x *QueryPocBatchesForStageRequest) Reset() {
+	*x = QueryPocBatchesForStageRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[14]
+		mi := &file_inference_inference_query_proto_msgTypes[28]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetEpochGroupDataRequest) String() string {
+func (x *QueryPocBatchesForStageRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetEpochGroupDataRequest) ProtoMessage() {}
+func (*QueryPocBatchesForStageRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetEpochGroupDataRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetEpochGroupDataRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{14}
+// Deprecated: Use QueryPocBatchesForStageRequest.ProtoReflect.Descriptor instead.
+func (*QueryPocBatchesForStageRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *QueryPocBatchesForStageRequest) GetBlockHeight() int64 {
+	if x != nil {
+		return x.BlockHeight
+	}
+	return 0
+}
+
+type QueryPocBatchesForStageResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	PocBatch []*PoCBatchesWithParticipants `protobuf:"bytes,1,rep,name=poc_batch,json=pocBatch,proto3" json:"poc_batch,omitempty"`
+}
+
+func (x *QueryPocBatchesForStageResponse) Reset() {
+	*x = QueryPocBatchesForStageResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *QueryPocBatchesForStageResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryPocBatchesForStageResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryPocBatchesForStageResponse.ProtoReflect.Descriptor instead.
+func (*QueryPocBatchesForStageResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *QueryPocBatchesForStageResponse) GetPocBatch() []*PoCBatchesWithParticipants {
+	if x != nil {
+		return x.PocBatch
+	}
+	return nil
+}
+
+type PoCBatchesWithParticipants struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Participant string      `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	PubKey      string      `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	HexPubKey   string      `protobuf:"bytes,3,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
+	PocBatch    []*PoCBatch `protobuf:"bytes,4,rep,name=poc_batch,json=pocBatch,proto3" json:"poc_batch,omitempty"`
+}
+
+func (x *PoCBatchesWithParticipants) Reset() {
+	*x = PoCBatchesWithParticipants{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *PoCBatchesWithParticipants) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PoCBatchesWithParticipants) ProtoMessage() {}
+
+// Deprecated: Use PoCBatchesWithParticipants.ProtoReflect.Descriptor instead.
+func (*PoCBatchesWithParticipants) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *PoCBatchesWithParticipants) GetParticipant() string {
+	if x != nil {
+		return x.Participant
+	}
+	return ""
 }
 
-func (x *QueryGetEpochGroupDataRequest) GetEpochIndex() uint64 {
+func (x *PoCBatchesWithParticipants) GetPubKey() string {
 	if x != nil {
-		return x.EpochIndex
+		return x.PubKey
 	}
-	return 0
+	return ""
 }
 
-func (x *QueryGetEpochGroupDataRequest) GetModelId() string {
+func (x *PoCBatchesWithParticipants) GetHexPubKey() string {
 	if x != nil {
-		return x.ModelId
+		return x.HexPubKey
 	}
 	return ""
 }
 
-type QueryGetEpochGroupDataResponse struct {
+func (x *PoCBatchesWithParticipants) GetPocBatch() []*PoCBatch {
+	if x != nil {
+		return x.PocBatch
+	}
+	return nil
+}
+
+type QueryPocValidationsForStageRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochGroupData *EpochGroupData `protobuf:"bytes,1,opt,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
+	BlockHeight int64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *QueryGetEpochGroupDataResponse) Reset() {
-	*x = QueryGetEpochGroupDataResponse{}
+func (x *QueryPocValidationsForStageRequest) Reset() {
+	*x = QueryPocValidationsForStageRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[15]
+		mi := &file_inference_inference_query_proto_msgTypes[31]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetEpochGroupDataResponse) String() string {
+func (x *QueryPocValidationsForStageRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetEpochGroupDataResponse) ProtoMessage() {}
+func (*QueryPocValidationsForStageRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetEpochGroupDataResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetEpochGroupDataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{15}
+// Deprecated: Use QueryPocValidationsForStageRequest.ProtoReflect.Descriptor instead.
+func (*QueryPocValidationsForStageRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{31}
 }
 
-func (x *QueryGetEpochGroupDataResponse) GetEpochGroupData() *EpochGroupData {
+func (x *QueryPocValidationsForStageRequest) GetBlockHeight() int64 {
 	if x != nil {
-		return x.EpochGroupData
+		return x.BlockHeight
 	}
-	return nil
+	return 0
 }
 
-type QueryAllEpochGroupDataRequest struct {
+type QueryPocValidationsForStageResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	PocValidation []*PoCValidationsWithParticipants `protobuf:"bytes,1,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
 }
 
-func (x *QueryAllEpochGroupDataRequest) Reset() {
-	*x = QueryAllEpochGroupDataRequest{}
+func (x *QueryPocValidationsForStageResponse) Reset() {
+	*x = QueryPocValidationsForStageResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[16]
+		mi := &file_inference_inference_query_proto_msgTypes[32]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllEpochGroupDataRequest) String() string {
+func (x *QueryPocValidationsForStageResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllEpochGroupDataRequest) ProtoMessage() {}
+func (*QueryPocValidationsForStageResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllEpochGroupDataRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllEpochGroupDataRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{16}
+// Deprecated: Use QueryPocValidationsForStageResponse.ProtoReflect.Descriptor instead.
+func (*QueryPocValidationsForStageResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{32}
 }
 
-func (x *QueryAllEpochGroupDataRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryPocValidationsForStageResponse) GetPocValidation() []*PoCValidationsWithParticipants {
 	if x != nil {
-		return x.Pagination
+		return x.PocValidation
 	}
 	return nil
 }
 
-type QueryAllEpochGroupDataResponse struct {
+type PoCValidationsWithParticipants struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochGroupData []*EpochGroupData     `protobuf:"bytes,1,rep,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
-	Pagination     *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Participant   string           `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	PubKey        string           `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	HexPubKey     string           `protobuf:"bytes,3,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
+	PocValidation []*PoCValidation `protobuf:"bytes,4,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
 }
 
-func (x *QueryAllEpochGroupDataResponse) Reset() {
-	*x = QueryAllEpochGroupDataResponse{}
+func (x *PoCValidationsWithParticipants) Reset() {
+	*x = PoCValidationsWithParticipants{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[17]
+		mi := &file_inference_inference_query_proto_msgTypes[33]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllEpochGroupDataResponse) String() string {
+func (x *PoCValidationsWithParticipants) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllEpochGroupDataResponse) ProtoMessage() {}
+func (*PoCValidationsWithParticipants) ProtoMessage() {}
 
-// Deprecated: Use QueryAllEpochGroupDataResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllEpochGroupDataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{17}
+// Deprecated: Use PoCValidationsWithParticipants.ProtoReflect.Descriptor instead.
+func (*PoCValidationsWithParticipants) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{33}
 }
 
-func (x *QueryAllEpochGroupDataResponse) GetEpochGroupData() []*EpochGroupData {
+func (x *PoCValidationsWithParticipants) GetParticipant() string {
 	if x != nil {
-		return x.EpochGroupData
+		return x.Participant
 	}
-	return nil
+	return ""
 }
 
-func (x *QueryAllEpochGroupDataResponse) GetPagination() *v1beta1.PageResponse {
+func (x *PoCValidationsWithParticipants) GetPubKey() string {
 	if x != nil {
-		return x.Pagination
+		return x.PubKey
+	}
+	return ""
+}
+
+func (x *PoCValidationsWithParticipants) GetHexPubKey() string {
+	if x != nil {
+		return x.HexPubKey
+	}
+	return ""
+}
+
+func (x *PoCValidationsWithParticipants) GetPocValidation() []*PoCValidation {
+	if x != nil {
+		return x.PocValidation
 	}
 	return nil
 }
 
-type QueryGetSettleAmountRequest struct {
+type QueryPocV2ValidationsForStageRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	BlockHeight int64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *QueryGetSettleAmountRequest) Reset() {
-	*x = QueryGetSettleAmountRequest{}
+func (x *QueryPocV2ValidationsForStageRequest) Reset() {
+	*x = QueryPocV2ValidationsForStageRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[18]
+		mi := &file_inference_inference_query_proto_msgTypes[34]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetSettleAmountRequest) String() string {
+func (x *QueryPocV2ValidationsForStageRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetSettleAmountRequest) ProtoMessage() {}
+func (*QueryPocV2ValidationsForStageRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetSettleAmountRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetSettleAmountRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{18}
+// Deprecated: Use QueryPocV2ValidationsForStageRequest.ProtoReflect.Descriptor instead.
+func (*QueryPocV2ValidationsForStageRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{34}
 }
 
-func (x *QueryGetSettleAmountRequest) GetParticipant() string {
+func (x *QueryPocV2ValidationsForStageRequest) GetBlockHeight() int64 {
 	if x != nil {
-		return x.Participant
+		return x.BlockHeight
 	}
-	return ""
+	return 0
 }
 
-type QueryGetSettleAmountResponse struct {
+type QueryPocV2ValidationsForStageResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	SettleAmount *SettleAmount `protobuf:"bytes,1,opt,name=settle_amount,json=settleAmount,proto3" json:"settle_amount,omitempty"`
+	PocValidation []*PoCValidationsWithParticipantsV2 `protobuf:"bytes,1,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
 }
 
-func (x *QueryGetSettleAmountResponse) Reset() {
-	*x = QueryGetSettleAmountResponse{}
+func (x *QueryPocV2ValidationsForStageResponse) Reset() {
+	*x = QueryPocV2ValidationsForStageResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[19]
+		mi := &file_inference_inference_query_proto_msgTypes[35]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetSettleAmountResponse) String() string {
+func (x *QueryPocV2ValidationsForStageResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetSettleAmountResponse) ProtoMessage() {}
+func (*QueryPocV2ValidationsForStageResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetSettleAmountResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetSettleAmountResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{19}
+// Deprecated: Use QueryPocV2ValidationsForStageResponse.ProtoReflect.Descriptor instead.
+func (*QueryPocV2ValidationsForStageResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{35}
 }
 
-func (x *QueryGetSettleAmountResponse) GetSettleAmount() *SettleAmount {
+func (x *QueryPocV2ValidationsForStageResponse) GetPocValidation() []*PoCValidationsWithParticipantsV2 {
 	if x != nil {
-		return x.SettleAmount
+		return x.PocValidation
 	}
 	return nil
 }
 
-type QueryAllSettleAmountRequest struct {
+type PoCValidationsWithParticipantsV2 struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Participant   string             `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	PubKey        string             `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	HexPubKey     string             `protobuf:"bytes,3,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
+	PocValidation []*PoCValidationV2 `protobuf:"bytes,4,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
+	ModelId       string             `protobuf:"bytes,5,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryAllSettleAmountRequest) Reset() {
-	*x = QueryAllSettleAmountRequest{}
+func (x *PoCValidationsWithParticipantsV2) Reset() {
+	*x = PoCValidationsWithParticipantsV2{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[20]
+		mi := &file_inference_inference_query_proto_msgTypes[36]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllSettleAmountRequest) String() string {
+func (x *PoCValidationsWithParticipantsV2) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllSettleAmountRequest) ProtoMessage() {}
+func (*PoCValidationsWithParticipantsV2) ProtoMessage() {}
 
-// Deprecated: Use QueryAllSettleAmountRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllSettleAmountRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{20}
+// Deprecated: Use PoCValidationsWithParticipantsV2.ProtoReflect.Descriptor instead.
+func (*PoCValidationsWithParticipantsV2) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{36}
 }
 
-func (x *QueryAllSettleAmountRequest) GetPagination() *v1beta1.PageRequest {
+func (x *PoCValidationsWithParticipantsV2) GetParticipant() string {
 	if x != nil {
-		return x.Pagination
+		return x.Participant
 	}
-	return nil
-}
-
-type QueryAllSettleAmountResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	SettleAmount []*SettleAmount       `protobuf:"bytes,1,rep,name=settle_amount,json=settleAmount,proto3" json:"settle_amount,omitempty"`
-	Pagination   *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	return ""
 }
 
-func (x *QueryAllSettleAmountResponse) Reset() {
-	*x = QueryAllSettleAmountResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[21]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+func (x *PoCValidationsWithParticipantsV2) GetPubKey() string {
+	if x != nil {
+		return x.PubKey
 	}
+	return ""
 }
 
-func (x *QueryAllSettleAmountResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*QueryAllSettleAmountResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryAllSettleAmountResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllSettleAmountResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{21}
+func (x *PoCValidationsWithParticipantsV2) GetHexPubKey() string {
+	if x != nil {
+		return x.HexPubKey
+	}
+	return ""
 }
 
-func (x *QueryAllSettleAmountResponse) GetSettleAmount() []*SettleAmount {
+func (x *PoCValidationsWithParticipantsV2) GetPocValidation() []*PoCValidationV2 {
 	if x != nil {
-		return x.SettleAmount
+		return x.PocValidation
 	}
 	return nil
 }
 
-func (x *QueryAllSettleAmountResponse) GetPagination() *v1beta1.PageResponse {
+func (x *PoCValidationsWithParticipantsV2) GetModelId() string {
 	if x != nil {
-		return x.Pagination
+		return x.ModelId
 	}
-	return nil
+	return ""
 }
 
-type QueryGetEpochGroupValidationsRequest struct {
+// PoC v2 off-chain commit query messages
+type QueryPoCV2StoreCommitRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
-	EpochIndex  uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	PocStageStartBlockHeight int64  `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
+	ParticipantAddress       string `protobuf:"bytes,2,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
+	ModelId                  string `protobuf:"bytes,3,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryGetEpochGroupValidationsRequest) Reset() {
-	*x = QueryGetEpochGroupValidationsRequest{}
+func (x *QueryPoCV2StoreCommitRequest) Reset() {
+	*x = QueryPoCV2StoreCommitRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[22]
+		mi := &file_inference_inference_query_proto_msgTypes[37]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetEpochGroupValidationsRequest) String() string {
+func (x *QueryPoCV2StoreCommitRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetEpochGroupValidationsRequest) ProtoMessage() {}
+func (*QueryPoCV2StoreCommitRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetEpochGroupValidationsRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetEpochGroupValidationsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{22}
+// Deprecated: Use QueryPoCV2StoreCommitRequest.ProtoReflect.Descriptor instead.
+func (*QueryPoCV2StoreCommitRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{37}
 }
 
-func (x *QueryGetEpochGroupValidationsRequest) GetParticipant() string {
+func (x *QueryPoCV2StoreCommitRequest) GetPocStageStartBlockHeight() int64 {
 	if x != nil {
-		return x.Participant
+		return x.PocStageStartBlockHeight
+	}
+	return 0
+}
+
+func (x *QueryPoCV2StoreCommitRequest) GetParticipantAddress() string {
+	if x != nil {
+		return x.ParticipantAddress
 	}
 	return ""
 }
 
-func (x *QueryGetEpochGroupValidationsRequest) GetEpochIndex() uint64 {
+func (x *QueryPoCV2StoreCommitRequest) GetModelId() string {
 	if x != nil {
-		return x.EpochIndex
+		return x.ModelId
 	}
-	return 0
+	return ""
 }
 
-type QueryGetEpochGroupValidationsResponse struct {
+type QueryPoCV2StoreCommitResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochGroupValidations *EpochGroupValidations `protobuf:"bytes,1,opt,name=epoch_group_validations,json=epochGroupValidations,proto3" json:"epoch_group_validations,omitempty"`
+	Count    uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	RootHash []byte `protobuf:"bytes,2,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
+	Found    bool   `protobuf:"varint,3,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryGetEpochGroupValidationsResponse) Reset() {
-	*x = QueryGetEpochGroupValidationsResponse{}
+func (x *QueryPoCV2StoreCommitResponse) Reset() {
+	*x = QueryPoCV2StoreCommitResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[23]
+		mi := &file_inference_inference_query_proto_msgTypes[38]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetEpochGroupValidationsResponse) String() string {
+func (x *QueryPoCV2StoreCommitResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetEpochGroupValidationsResponse) ProtoMessage() {}
+func (*QueryPoCV2StoreCommitResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetEpochGroupValidationsResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetEpochGroupValidationsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{23}
+// Deprecated: Use QueryPoCV2StoreCommitResponse.ProtoReflect.Descriptor instead.
+func (*QueryPoCV2StoreCommitResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{38}
 }
 
-func (x *QueryGetEpochGroupValidationsResponse) GetEpochGroupValidations() *EpochGroupValidations {
+func (x *QueryPoCV2StoreCommitResponse) GetCount() uint32 {
 	if x != nil {
-		return x.EpochGroupValidations
+		return x.Count
+	}
+	return 0
+}
+
+func (x *QueryPoCV2StoreCommitResponse) GetRootHash() []byte {
+	if x != nil {
+		return x.RootHash
 	}
 	return nil
 }
 
-type QueryAllEpochGroupValidationsRequest struct {
+func (x *QueryPoCV2StoreCommitResponse) GetFound() bool {
+	if x != nil {
+		return x.Found
+	}
+	return false
+}
+
+type QueryMLNodeWeightDistributionRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	PocStageStartBlockHeight int64  `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
+	ParticipantAddress       string `protobuf:"bytes,2,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
+	ModelId                  string `protobuf:"bytes,3,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryAllEpochGroupValidationsRequest) Reset() {
-	*x = QueryAllEpochGroupValidationsRequest{}
+func (x *QueryMLNodeWeightDistributionRequest) Reset() {
+	*x = QueryMLNodeWeightDistributionRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[24]
+		mi := &file_inference_inference_query_proto_msgTypes[39]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllEpochGroupValidationsRequest) String() string {
+func (x *QueryMLNodeWeightDistributionRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllEpochGroupValidationsRequest) ProtoMessage() {}
+func (*QueryMLNodeWeightDistributionRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllEpochGroupValidationsRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllEpochGroupValidationsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{24}
+// Deprecated: Use QueryMLNodeWeightDistributionRequest.ProtoReflect.Descriptor instead.
+func (*QueryMLNodeWeightDistributionRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{39}
 }
 
-func (x *QueryAllEpochGroupValidationsRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryMLNodeWeightDistributionRequest) GetPocStageStartBlockHeight() int64 {
 	if x != nil {
-		return x.Pagination
+		return x.PocStageStartBlockHeight
 	}
-	return nil
+	return 0
 }
 
-type QueryAllEpochGroupValidationsResponse struct {
+func (x *QueryMLNodeWeightDistributionRequest) GetParticipantAddress() string {
+	if x != nil {
+		return x.ParticipantAddress
+	}
+	return ""
+}
+
+func (x *QueryMLNodeWeightDistributionRequest) GetModelId() string {
+	if x != nil {
+		return x.ModelId
+	}
+	return ""
+}
+
+type QueryMLNodeWeightDistributionResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochGroupValidations []*EpochGroupValidations `protobuf:"bytes,1,rep,name=epoch_group_validations,json=epochGroupValidations,proto3" json:"epoch_group_validations,omitempty"`
-	Pagination            *v1beta1.PageResponse    `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Weights []*MLNodeWeight `protobuf:"bytes,1,rep,name=weights,proto3" json:"weights,omitempty"`
+	Found   bool            `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryAllEpochGroupValidationsResponse) Reset() {
-	*x = QueryAllEpochGroupValidationsResponse{}
+func (x *QueryMLNodeWeightDistributionResponse) Reset() {
+	*x = QueryMLNodeWeightDistributionResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[25]
+		mi := &file_inference_inference_query_proto_msgTypes[40]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllEpochGroupValidationsResponse) String() string {
+func (x *QueryMLNodeWeightDistributionResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllEpochGroupValidationsResponse) ProtoMessage() {}
+func (*QueryMLNodeWeightDistributionResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllEpochGroupValidationsResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllEpochGroupValidationsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{25}
+// Deprecated: Use QueryMLNodeWeightDistributionResponse.ProtoReflect.Descriptor instead.
+func (*QueryMLNodeWeightDistributionResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{40}
 }
 
-func (x *QueryAllEpochGroupValidationsResponse) GetEpochGroupValidations() []*EpochGroupValidations {
+func (x *QueryMLNodeWeightDistributionResponse) GetWeights() []*MLNodeWeight {
 	if x != nil {
-		return x.EpochGroupValidations
+		return x.Weights
 	}
 	return nil
 }
 
-func (x *QueryAllEpochGroupValidationsResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryMLNodeWeightDistributionResponse) GetFound() bool {
 	if x != nil {
-		return x.Pagination
+		return x.Found
 	}
-	return nil
+	return false
 }
 
-type QueryPocBatchesForStageRequest struct {
+type QueryAllPoCV2StoreCommitsForStageRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BlockHeight int64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	PocStageStartBlockHeight int64 `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
 }
 
-func (x *QueryPocBatchesForStageRequest) Reset() {
-	*x = QueryPocBatchesForStageRequest{}
+func (x *QueryAllPoCV2StoreCommitsForStageRequest) Reset() {
+	*x = QueryAllPoCV2StoreCommitsForStageRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[26]
+		mi := &file_inference_inference_query_proto_msgTypes[41]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPocBatchesForStageRequest) String() string {
+func (x *QueryAllPoCV2StoreCommitsForStageRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPocBatchesForStageRequest) ProtoMessage() {}
+func (*QueryAllPoCV2StoreCommitsForStageRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryPocBatchesForStageRequest.ProtoReflect.Descriptor instead.
-func (*QueryPocBatchesForStageRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{26}
+// Deprecated: Use QueryAllPoCV2StoreCommitsForStageRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllPoCV2StoreCommitsForStageRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{41}
 }
 
-func (x *QueryPocBatchesForStageRequest) GetBlockHeight() int64 {
+func (x *QueryAllPoCV2StoreCommitsForStageRequest) GetPocStageStartBlockHeight() int64 {
 	if x != nil {
-		return x.BlockHeight
+		return x.PocStageStartBlockHeight
 	}
 	return 0
 }
 
-type QueryPocBatchesForStageResponse struct {
+type QueryAllPoCV2StoreCommitsForStageResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocBatch []*PoCBatchesWithParticipants `protobuf:"bytes,1,rep,name=poc_batch,json=pocBatch,proto3" json:"poc_batch,omitempty"`
+	Commits []*PoCV2StoreCommitWithAddress `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
 }
 
-func (x *QueryPocBatchesForStageResponse) Reset() {
-	*x = QueryPocBatchesForStageResponse{}
+func (x *QueryAllPoCV2StoreCommitsForStageResponse) Reset() {
+	*x = QueryAllPoCV2StoreCommitsForStageResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[27]
+		mi := &file_inference_inference_query_proto_msgTypes[42]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPocBatchesForStageResponse) String() string {
+func (x *QueryAllPoCV2StoreCommitsForStageResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPocBatchesForStageResponse) ProtoMessage() {}
+func (*QueryAllPoCV2StoreCommitsForStageResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryPocBatchesForStageResponse.ProtoReflect.Descriptor instead.
-func (*QueryPocBatchesForStageResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{27}
+// Deprecated: Use QueryAllPoCV2StoreCommitsForStageResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllPoCV2StoreCommitsForStageResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{42}
 }
 
-func (x *QueryPocBatchesForStageResponse) GetPocBatch() []*PoCBatchesWithParticipants {
+func (x *QueryAllPoCV2StoreCommitsForStageResponse) GetCommits() []*PoCV2StoreCommitWithAddress {
 	if x != nil {
-		return x.PocBatch
+		return x.Commits
 	}
 	return nil
 }
 
-type PoCBatchesWithParticipants struct {
+type PoCV2StoreCommitWithAddress struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant string      `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
-	PubKey      string      `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
-	HexPubKey   string      `protobuf:"bytes,3,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
-	PocBatch    []*PoCBatch `protobuf:"bytes,4,rep,name=poc_batch,json=pocBatch,proto3" json:"poc_batch,omitempty"`
+	ParticipantAddress string `protobuf:"bytes,1,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
+	Count              uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
+	RootHash           []byte `protobuf:"bytes,3,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
+	HexPubKey          string `protobuf:"bytes,4,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
+	ModelId            string `protobuf:"bytes,5,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *PoCBatchesWithParticipants) Reset() {
-	*x = PoCBatchesWithParticipants{}
+func (x *PoCV2StoreCommitWithAddress) Reset() {
+	*x = PoCV2StoreCommitWithAddress{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[28]
+		mi := &file_inference_inference_query_proto_msgTypes[43]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *PoCBatchesWithParticipants) String() string {
+func (x *PoCV2StoreCommitWithAddress) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PoCBatchesWithParticipants) ProtoMessage() {}
+func (*PoCV2StoreCommitWithAddress) ProtoMessage() {}
 
-// Deprecated: Use PoCBatchesWithParticipants.ProtoReflect.Descriptor instead.
-func (*PoCBatchesWithParticipants) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{28}
+// Deprecated: Use PoCV2StoreCommitWithAddress.ProtoReflect.Descriptor instead.
+func (*PoCV2StoreCommitWithAddress) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{43}
 }
 
-func (x *PoCBatchesWithParticipants) GetParticipant() string {
+func (x *PoCV2StoreCommitWithAddress) GetParticipantAddress() string {
 	if x != nil {
-		return x.Participant
+		return x.ParticipantAddress
 	}
 	return ""
 }
 
-func (x *PoCBatchesWithParticipants) GetPubKey() string {
+func (x *PoCV2StoreCommitWithAddress) GetCount() uint32 {
 	if x != nil {
-		return x.PubKey
+		return x.Count
 	}
-	return ""
+	return 0
 }
 
-func (x *PoCBatchesWithParticipants) GetHexPubKey() string {
+func (x *PoCV2StoreCommitWithAddress) GetRootHash() []byte {
+	if x != nil {
+		return x.RootHash
+	}
+	return nil
+}
+
+func (x *PoCV2StoreCommitWithAddress) GetHexPubKey() string {
 	if x != nil {
 		return x.HexPubKey
 	}
 	return ""
 }
 
-func (x *PoCBatchesWithParticipants) GetPocBatch() []*PoCBatch {
+func (x *PoCV2StoreCommitWithAddress) GetModelId() string {
 	if x != nil {
-		return x.PocBatch
+		return x.ModelId
 	}
-	return nil
+	return ""
 }
 
-type QueryPocValidationsForStageRequest struct {
+type QueryAllMLNodeWeightDistributionsForStageRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BlockHeight int64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	PocStageStartBlockHeight int64 `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
 }
 
-func (x *QueryPocValidationsForStageRequest) Reset() {
-	*x = QueryPocValidationsForStageRequest{}
+func (x *QueryAllMLNodeWeightDistributionsForStageRequest) Reset() {
+	*x = QueryAllMLNodeWeightDistributionsForStageRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[29]
+		mi := &file_inference_inference_query_proto_msgTypes[44]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPocValidationsForStageRequest) String() string {
+func (x *QueryAllMLNodeWeightDistributionsForStageRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPocValidationsForStageRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryPocValidationsForStageRequest.ProtoReflect.Descriptor instead.
-func (*QueryPocValidationsForStageRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{29}
+func (*QueryAllMLNodeWeightDistributionsForStageRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryAllMLNodeWeightDistributionsForStageRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllMLNodeWeightDistributionsForStageRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{44}
 }
 
-func (x *QueryPocValidationsForStageRequest) GetBlockHeight() int64 {
+func (x *QueryAllMLNodeWeightDistributionsForStageRequest) GetPocStageStartBlockHeight() int64 {
 	if x != nil {
-		return x.BlockHeight
+		return x.PocStageStartBlockHeight
 	}
 	return 0
 }
 
-type QueryPocValidationsForStageResponse struct {
+type QueryAllMLNodeWeightDistributionsForStageResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocValidation []*PoCValidationsWithParticipants `protobuf:"bytes,1,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
+	Distributions []*MLNodeWeightDistributionWithAddress `protobuf:"bytes,1,rep,name=distributions,proto3" json:"distributions,omitempty"`
 }
 
-func (x *QueryPocValidationsForStageResponse) Reset() {
-	*x = QueryPocValidationsForStageResponse{}
+func (x *QueryAllMLNodeWeightDistributionsForStageResponse) Reset() {
+	*x = QueryAllMLNodeWeightDistributionsForStageResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[30]
+		mi := &file_inference_inference_query_proto_msgTypes[45]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPocValidationsForStageResponse) String() string {
+func (x *QueryAllMLNodeWeightDistributionsForStageResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPocValidationsForStageResponse) ProtoMessage() {}
+func (*QueryAllMLNodeWeightDistributionsForStageResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryPocValidationsForStageResponse.ProtoReflect.Descriptor instead.
-func (*QueryPocValidationsForStageResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{30}
+// Deprecated: Use QueryAllMLNodeWeightDistributionsForStageResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllMLNodeWeightDistributionsForStageResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{45}
 }
 
-func (x *QueryPocValidationsForStageResponse) GetPocValidation() []*PoCValidationsWithParticipants {
+func (x *QueryAllMLNodeWeightDistributionsForStageResponse) GetDistributions() []*MLNodeWeightDistributionWithAddress {
 	if x != nil {
-		return x.PocValidation
+		return x.Distributions
 	}
 	return nil
 }
 
-type PoCValidationsWithParticipants struct {
+type MLNodeWeightDistributionWithAddress struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant   string           `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
-	PubKey        string           `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
-	HexPubKey     string           `protobuf:"bytes,3,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
-	PocValidation []*PoCValidation `protobuf:"bytes,4,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
+	ParticipantAddress string          `protobuf:"bytes,1,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
+	Weights            []*MLNodeWeight `protobuf:"bytes,2,rep,name=weights,proto3" json:"weights,omitempty"`
+	ModelId            string          `protobuf:"bytes,3,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *PoCValidationsWithParticipants) Reset() {
-	*x = PoCValidationsWithParticipants{}
+func (x *MLNodeWeightDistributionWithAddress) Reset() {
+	*x = MLNodeWeightDistributionWithAddress{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[31]
+		mi := &file_inference_inference_query_proto_msgTypes[46]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *PoCValidationsWithParticipants) String() string {
+func (x *MLNodeWeightDistributionWithAddress) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PoCValidationsWithParticipants) ProtoMessage() {}
+func (*MLNodeWeightDistributionWithAddress) ProtoMessage() {}
 
-// Deprecated: Use PoCValidationsWithParticipants.ProtoReflect.Descriptor instead.
-func (*PoCValidationsWithParticipants) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{31}
+// Deprecated: Use MLNodeWeightDistributionWithAddress.ProtoReflect.Descriptor instead.
+func (*MLNodeWeightDistributionWithAddress) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{46}
 }
 
-func (x *PoCValidationsWithParticipants) GetParticipant() string {
+func (x *MLNodeWeightDistributionWithAddress) GetParticipantAddress() string {
 	if x != nil {
-		return x.Participant
+		return x.ParticipantAddress
 	}
 	return ""
 }
 
-func (x *PoCValidationsWithParticipants) GetPubKey() string {
+func (x *MLNodeWeightDistributionWithAddress) GetWeights() []*MLNodeWeight {
 	if x != nil {
-		return x.PubKey
+		return x.Weights
 	}
-	return ""
+	return nil
 }
 
-func (x *PoCValidationsWithParticipants) GetHexPubKey() string {
+func (x *MLNodeWeightDistributionWithAddress) GetModelId() string {
 	if x != nil {
-		return x.HexPubKey
+		return x.ModelId
 	}
 	return ""
 }
 
-func (x *PoCValidationsWithParticipants) GetPocValidation() []*PoCValidation {
-	if x != nil {
-		return x.PocValidation
-	}
-	return nil
-}
-
-type QueryPocV2ValidationsForStageRequest struct {
+type QueryGetCurrentEpochRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	BlockHeight int64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *QueryPocV2ValidationsForStageRequest) Reset() {
-	*x = QueryPocV2ValidationsForStageRequest{}
+func (x *QueryGetCurrentEpochRequest) Reset() {
+	*x = QueryGetCurrentEpochRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[32]
+		mi := &file_inference_inference_query_proto_msgTypes[47]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPocV2ValidationsForStageRequest) String() string {
+func (x *QueryGetCurrentEpochRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPocV2ValidationsForStageRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryPocV2ValidationsForStageRequest.ProtoReflect.Descriptor instead.
-func (*QueryPocV2ValidationsForStageRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{32}
-}
+func (*QueryGetCurrentEpochRequest) ProtoMessage() {}
 
-func (x *QueryPocV2ValidationsForStageRequest) GetBlockHeight() int64 {
-	if x != nil {
-		return x.BlockHeight
-	}
-	return 0
+// Deprecated: Use QueryGetCurrentEpochRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetCurrentEpochRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{47}
 }
 
-type QueryPocV2ValidationsForStageResponse struct {
+type QueryGetCurrentEpochResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocValidation []*PoCValidationsWithParticipantsV2 `protobuf:"bytes,1,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
+	Epoch uint64 `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
 }
 
-func (x *QueryPocV2ValidationsForStageResponse) Reset() {
-	*x = QueryPocV2ValidationsForStageResponse{}
+func (x *QueryGetCurrentEpochResponse) Reset() {
+	*x = QueryGetCurrentEpochResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[33]
+		mi := &file_inference_inference_query_proto_msgTypes[48]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPocV2ValidationsForStageResponse) String() string {
+func (x *QueryGetCurrentEpochResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPocV2ValidationsForStageResponse) ProtoMessage() {}
+func (*QueryGetCurrentEpochResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryPocV2ValidationsForStageResponse.ProtoReflect.Descriptor instead.
-func (*QueryPocV2ValidationsForStageResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{33}
+// Deprecated: Use QueryGetCurrentEpochResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetCurrentEpochResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{48}
 }
 
-func (x *QueryPocV2ValidationsForStageResponse) GetPocValidation() []*PoCValidationsWithParticipantsV2 {
+func (x *QueryGetCurrentEpochResponse) GetEpoch() uint64 {
 	if x != nil {
-		return x.PocValidation
+		return x.Epoch
 	}
-	return nil
+	return 0
 }
 
-type PoCValidationsWithParticipantsV2 struct {
+type QueryGetTokenomicsDataRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	Participant   string             `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
-	PubKey        string             `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
-	HexPubKey     string             `protobuf:"bytes,3,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
-	PocValidation []*PoCValidationV2 `protobuf:"bytes,4,rep,name=poc_validation,json=pocValidation,proto3" json:"poc_validation,omitempty"`
-	ModelId       string             `protobuf:"bytes,5,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *PoCValidationsWithParticipantsV2) Reset() {
-	*x = PoCValidationsWithParticipantsV2{}
+func (x *QueryGetTokenomicsDataRequest) Reset() {
+	*x = QueryGetTokenomicsDataRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[34]
+		mi := &file_inference_inference_query_proto_msgTypes[49]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *PoCValidationsWithParticipantsV2) String() string {
+func (x *QueryGetTokenomicsDataRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PoCValidationsWithParticipantsV2) ProtoMessage() {}
+func (*QueryGetTokenomicsDataRequest) ProtoMessage() {}
 
-// Deprecated: Use PoCValidationsWithParticipantsV2.ProtoReflect.Descriptor instead.
-func (*PoCValidationsWithParticipantsV2) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{34}
+// Deprecated: Use QueryGetTokenomicsDataRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetTokenomicsDataRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{49}
 }
 
-func (x *PoCValidationsWithParticipantsV2) GetParticipant() string {
-	if x != nil {
-		return x.Participant
-	}
-	return ""
+type QueryGetTokenomicsDataResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	TokenomicsData *TokenomicsData `protobuf:"bytes,1,opt,name=tokenomics_data,json=tokenomicsData,proto3" json:"tokenomics_data,omitempty"`
 }
 
-func (x *PoCValidationsWithParticipantsV2) GetPubKey() string {
-	if x != nil {
-		return x.PubKey
+func (x *QueryGetTokenomicsDataResponse) Reset() {
+	*x = QueryGetTokenomicsDataResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[50]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return ""
 }
 
-func (x *PoCValidationsWithParticipantsV2) GetHexPubKey() string {
-	if x != nil {
-		return x.HexPubKey
-	}
-	return ""
+func (x *QueryGetTokenomicsDataResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (x *PoCValidationsWithParticipantsV2) GetPocValidation() []*PoCValidationV2 {
-	if x != nil {
-		return x.PocValidation
-	}
-	return nil
+func (*QueryGetTokenomicsDataResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetTokenomicsDataResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetTokenomicsDataResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{50}
 }
 
-func (x *PoCValidationsWithParticipantsV2) GetModelId() string {
+func (x *QueryGetTokenomicsDataResponse) GetTokenomicsData() *TokenomicsData {
 	if x != nil {
-		return x.ModelId
+		return x.TokenomicsData
 	}
-	return ""
+	return nil
 }
 
-// PoC v2 off-chain commit query messages
-type QueryPoCV2StoreCommitRequest struct {
+type QueryGetUnitOfComputePriceProposalRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocStageStartBlockHeight int64  `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
-	ParticipantAddress       string `protobuf:"bytes,2,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
-	ModelId                  string `protobuf:"bytes,3,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryPoCV2StoreCommitRequest) Reset() {
-	*x = QueryPoCV2StoreCommitRequest{}
+func (x *QueryGetUnitOfComputePriceProposalRequest) Reset() {
+	*x = QueryGetUnitOfComputePriceProposalRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[35]
+		mi := &file_inference_inference_query_proto_msgTypes[51]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPoCV2StoreCommitRequest) String() string {
+func (x *QueryGetUnitOfComputePriceProposalRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPoCV2StoreCommitRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryPoCV2StoreCommitRequest.ProtoReflect.Descriptor instead.
-func (*QueryPoCV2StoreCommitRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{35}
-}
-
-func (x *QueryPoCV2StoreCommitRequest) GetPocStageStartBlockHeight() int64 {
-	if x != nil {
-		return x.PocStageStartBlockHeight
-	}
-	return 0
-}
+func (*QueryGetUnitOfComputePriceProposalRequest) ProtoMessage() {}
 
-func (x *QueryPoCV2StoreCommitRequest) GetParticipantAddress() string {
-	if x != nil {
-		return x.ParticipantAddress
-	}
-	return ""
+// Deprecated: Use QueryGetUnitOfComputePriceProposalRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetUnitOfComputePriceProposalRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{51}
 }
 
-func (x *QueryPoCV2StoreCommitRequest) GetModelId() string {
+func (x *QueryGetUnitOfComputePriceProposalRequest) GetParticipant() string {
 	if x != nil {
-		return x.ModelId
+		return x.Participant
 	}
 	return ""
 }
 
-type QueryPoCV2StoreCommitResponse struct {
+type QueryGetUnitOfComputePriceProposalResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Count    uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
-	RootHash []byte `protobuf:"bytes,2,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
-	Found    bool   `protobuf:"varint,3,opt,name=found,proto3" json:"found,omitempty"`
+	Proposal *UnitOfComputePriceProposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
+	Default  uint64                      `protobuf:"varint,2,opt,name=default,proto3" json:"default,omitempty"`
 }
 
-func (x *QueryPoCV2StoreCommitResponse) Reset() {
-	*x = QueryPoCV2StoreCommitResponse{}
+func (x *QueryGetUnitOfComputePriceProposalResponse) Reset() {
+	*x = QueryGetUnitOfComputePriceProposalResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[36]
+		mi := &file_inference_inference_query_proto_msgTypes[52]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPoCV2StoreCommitResponse) String() string {
+func (x *QueryGetUnitOfComputePriceProposalResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPoCV2StoreCommitResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryPoCV2StoreCommitResponse.ProtoReflect.Descriptor instead.
-func (*QueryPoCV2StoreCommitResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{36}
-}
+func (*QueryGetUnitOfComputePriceProposalResponse) ProtoMessage() {}
 
-func (x *QueryPoCV2StoreCommitResponse) GetCount() uint32 {
-	if x != nil {
-		return x.Count
-	}
-	return 0
+// Deprecated: Use QueryGetUnitOfComputePriceProposalResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetUnitOfComputePriceProposalResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{52}
 }
 
-func (x *QueryPoCV2StoreCommitResponse) GetRootHash() []byte {
+func (x *QueryGetUnitOfComputePriceProposalResponse) GetProposal() *UnitOfComputePriceProposal {
 	if x != nil {
-		return x.RootHash
+		return x.Proposal
 	}
 	return nil
 }
 
-func (x *QueryPoCV2StoreCommitResponse) GetFound() bool {
+func (x *QueryGetUnitOfComputePriceProposalResponse) GetDefault() uint64 {
 	if x != nil {
-		return x.Found
+		return x.Default
 	}
-	return false
+	return 0
 }
 
-type QueryMLNodeWeightDistributionRequest struct {
+type QueryCurrentEpochGroupDataRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	PocStageStartBlockHeight int64  `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
-	ParticipantAddress       string `protobuf:"bytes,2,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
-	ModelId                  string `protobuf:"bytes,3,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryMLNodeWeightDistributionRequest) Reset() {
-	*x = QueryMLNodeWeightDistributionRequest{}
+func (x *QueryCurrentEpochGroupDataRequest) Reset() {
+	*x = QueryCurrentEpochGroupDataRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[37]
+		mi := &file_inference_inference_query_proto_msgTypes[53]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryMLNodeWeightDistributionRequest) String() string {
+func (x *QueryCurrentEpochGroupDataRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryMLNodeWeightDistributionRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryMLNodeWeightDistributionRequest.ProtoReflect.Descriptor instead.
-func (*QueryMLNodeWeightDistributionRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{37}
-}
-
-func (x *QueryMLNodeWeightDistributionRequest) GetPocStageStartBlockHeight() int64 {
-	if x != nil {
-		return x.PocStageStartBlockHeight
-	}
-	return 0
-}
-
-func (x *QueryMLNodeWeightDistributionRequest) GetParticipantAddress() string {
-	if x != nil {
-		return x.ParticipantAddress
-	}
-	return ""
-}
+func (*QueryCurrentEpochGroupDataRequest) ProtoMessage() {}
 
-func (x *QueryMLNodeWeightDistributionRequest) GetModelId() string {
-	if x != nil {
-		return x.ModelId
-	}
-	return ""
+// Deprecated: Use QueryCurrentEpochGroupDataRequest.ProtoReflect.Descriptor instead.
+func (*QueryCurrentEpochGroupDataRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{53}
 }
 
-type QueryMLNodeWeightDistributionResponse struct {
+type QueryCurrentEpochGroupDataResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Weights []*MLNodeWeight `protobuf:"bytes,1,rep,name=weights,proto3" json:"weights,omitempty"`
-	Found   bool            `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	EpochGroupData *EpochGroupData `protobuf:"bytes,1,opt,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
 }
 
-func (x *QueryMLNodeWeightDistributionResponse) Reset() {
-	*x = QueryMLNodeWeightDistributionResponse{}
+func (x *QueryCurrentEpochGroupDataResponse) Reset() {
+	*x = QueryCurrentEpochGroupDataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[38]
+		mi := &file_inference_inference_query_proto_msgTypes[54]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryMLNodeWeightDistributionResponse) String() string {
+func (x *QueryCurrentEpochGroupDataResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryMLNodeWeightDistributionResponse) ProtoMessage() {}
+func (*QueryCurrentEpochGroupDataResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryMLNodeWeightDistributionResponse.ProtoReflect.Descriptor instead.
-func (*QueryMLNodeWeightDistributionResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{38}
+// Deprecated: Use QueryCurrentEpochGroupDataResponse.ProtoReflect.Descriptor instead.
+func (*QueryCurrentEpochGroupDataResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{54}
 }
 
-func (x *QueryMLNodeWeightDistributionResponse) GetWeights() []*MLNodeWeight {
+func (x *QueryCurrentEpochGroupDataResponse) GetEpochGroupData() *EpochGroupData {
 	if x != nil {
-		return x.Weights
+		return x.EpochGroupData
 	}
 	return nil
 }
 
-func (x *QueryMLNodeWeightDistributionResponse) GetFound() bool {
-	if x != nil {
-		return x.Found
+type QueryPreviousEpochGroupDataRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *QueryPreviousEpochGroupDataRequest) Reset() {
+	*x = QueryPreviousEpochGroupDataRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[55]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return false
 }
 
-type QueryAllPoCV2StoreCommitsForStageRequest struct {
+func (x *QueryPreviousEpochGroupDataRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryPreviousEpochGroupDataRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryPreviousEpochGroupDataRequest.ProtoReflect.Descriptor instead.
+func (*QueryPreviousEpochGroupDataRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{55}
+}
+
+type QueryPreviousEpochGroupDataResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocStageStartBlockHeight int64 `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
+	EpochGroupData *EpochGroupData `protobuf:"bytes,1,opt,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageRequest) Reset() {
-	*x = QueryAllPoCV2StoreCommitsForStageRequest{}
+func (x *QueryPreviousEpochGroupDataResponse) Reset() {
+	*x = QueryPreviousEpochGroupDataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[39]
+		mi := &file_inference_inference_query_proto_msgTypes[56]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageRequest) String() string {
+func (x *QueryPreviousEpochGroupDataResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllPoCV2StoreCommitsForStageRequest) ProtoMessage() {}
+func (*QueryPreviousEpochGroupDataResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllPoCV2StoreCommitsForStageRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllPoCV2StoreCommitsForStageRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{39}
+// Deprecated: Use QueryPreviousEpochGroupDataResponse.ProtoReflect.Descriptor instead.
+func (*QueryPreviousEpochGroupDataResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{56}
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageRequest) GetPocStageStartBlockHeight() int64 {
+func (x *QueryPreviousEpochGroupDataResponse) GetEpochGroupData() *EpochGroupData {
 	if x != nil {
-		return x.PocStageStartBlockHeight
+		return x.EpochGroupData
 	}
-	return 0
+	return nil
 }
 
-type QueryAllPoCV2StoreCommitsForStageResponse struct {
+type QueryModelsAllRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Commits []*PoCV2StoreCommitWithAddress `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageResponse) Reset() {
-	*x = QueryAllPoCV2StoreCommitsForStageResponse{}
+func (x *QueryModelsAllRequest) Reset() {
+	*x = QueryModelsAllRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[40]
+		mi := &file_inference_inference_query_proto_msgTypes[57]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageResponse) String() string {
+func (x *QueryModelsAllRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllPoCV2StoreCommitsForStageResponse) ProtoMessage() {}
+func (*QueryModelsAllRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllPoCV2StoreCommitsForStageResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllPoCV2StoreCommitsForStageResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{40}
+// Deprecated: Use QueryModelsAllRequest.ProtoReflect.Descriptor instead.
+func (*QueryModelsAllRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{57}
 }
 
-func (x *QueryAllPoCV2StoreCommitsForStageResponse) GetCommits() []*PoCV2StoreCommitWithAddress {
+func (x *QueryModelsAllRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.Commits
+		return x.Pagination
 	}
 	return nil
 }
 
-type PoCV2StoreCommitWithAddress struct {
+type QueryModelsAllResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParticipantAddress string `protobuf:"bytes,1,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
-	Count              uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
-	RootHash           []byte `protobuf:"bytes,3,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
-	HexPubKey          string `protobuf:"bytes,4,opt,name=hex_pub_key,json=hexPubKey,proto3" json:"hex_pub_key,omitempty"`
-	ModelId            string `protobuf:"bytes,5,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	Model      []*Model              `protobuf:"bytes,1,rep,name=model,proto3" json:"model,omitempty"`
+	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *PoCV2StoreCommitWithAddress) Reset() {
-	*x = PoCV2StoreCommitWithAddress{}
+func (x *QueryModelsAllResponse) Reset() {
+	*x = QueryModelsAllResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[41]
+		mi := &file_inference_inference_query_proto_msgTypes[58]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *PoCV2StoreCommitWithAddress) String() string {
+func (x *QueryModelsAllResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PoCV2StoreCommitWithAddress) ProtoMessage() {}
+func (*QueryModelsAllResponse) ProtoMessage() {}
 
-// Deprecated: Use PoCV2StoreCommitWithAddress.ProtoReflect.Descriptor instead.
-func (*PoCV2StoreCommitWithAddress) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{41}
+// Deprecated: Use QueryModelsAllResponse.ProtoReflect.Descriptor instead.
+func (*QueryModelsAllResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{58}
 }
 
-func (x *PoCV2StoreCommitWithAddress) GetParticipantAddress() string {
+func (x *QueryModelsAllResponse) GetModel() []*Model {
 	if x != nil {
-		return x.ParticipantAddress
+		return x.Model
 	}
-	return ""
+	return nil
 }
 
-func (x *PoCV2StoreCommitWithAddress) GetCount() uint32 {
+func (x *QueryModelsAllResponse) GetPagination() *v1beta1.PageResponse {
 	if x != nil {
-		return x.Count
+		return x.Pagination
 	}
-	return 0
+	return nil
 }
 
-func (x *PoCV2StoreCommitWithAddress) GetRootHash() []byte {
-	if x != nil {
-		return x.RootHash
+type QueryGetInferenceTimeoutRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ExpirationHeight uint64 `protobuf:"varint,1,opt,name=expirationHeight,proto3" json:"expirationHeight,omitempty"`
+	InferenceId      string `protobuf:"bytes,2,opt,name=inferenceId,proto3" json:"inferenceId,omitempty"`
+}
+
+func (x *QueryGetInferenceTimeoutRequest) Reset() {
+	*x = QueryGetInferenceTimeoutRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[59]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return nil
 }
 
-func (x *PoCV2StoreCommitWithAddress) GetHexPubKey() string {
+func (x *QueryGetInferenceTimeoutRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*QueryGetInferenceTimeoutRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryGetInferenceTimeoutRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceTimeoutRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{59}
+}
+
+func (x *QueryGetInferenceTimeoutRequest) GetExpirationHeight() uint64 {
 	if x != nil {
-		return x.HexPubKey
+		return x.ExpirationHeight
 	}
-	return ""
+	return 0
 }
 
-func (x *PoCV2StoreCommitWithAddress) GetModelId() string {
+func (x *QueryGetInferenceTimeoutRequest) GetInferenceId() string {
 	if x != nil {
-		return x.ModelId
+		return x.InferenceId
 	}
 	return ""
 }
 
-type QueryAllMLNodeWeightDistributionsForStageRequest struct {
+type QueryGetInferenceTimeoutResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocStageStartBlockHeight int64 `protobuf:"varint,1,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
+	InferenceTimeout *InferenceTimeout `protobuf:"bytes,1,opt,name=inference_timeout,json=inferenceTimeout,proto3" json:"inference_timeout,omitempty"`
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageRequest) Reset() {
-	*x = QueryAllMLNodeWeightDistributionsForStageRequest{}
+func (x *QueryGetInferenceTimeoutResponse) Reset() {
+	*x = QueryGetInferenceTimeoutResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[42]
+		mi := &file_inference_inference_query_proto_msgTypes[60]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageRequest) String() string {
+func (x *QueryGetInferenceTimeoutResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllMLNodeWeightDistributionsForStageRequest) ProtoMessage() {}
+func (*QueryGetInferenceTimeoutResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllMLNodeWeightDistributionsForStageRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllMLNodeWeightDistributionsForStageRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{42}
+// Deprecated: Use QueryGetInferenceTimeoutResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceTimeoutResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{60}
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageRequest) GetPocStageStartBlockHeight() int64 {
+func (x *QueryGetInferenceTimeoutResponse) GetInferenceTimeout() *InferenceTimeout {
 	if x != nil {
-		return x.PocStageStartBlockHeight
+		return x.InferenceTimeout
 	}
-	return 0
+	return nil
 }
 
-type QueryAllMLNodeWeightDistributionsForStageResponse struct {
+type QueryAllInferenceTimeoutRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Distributions []*MLNodeWeightDistributionWithAddress `protobuf:"bytes,1,rep,name=distributions,proto3" json:"distributions,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageResponse) Reset() {
-	*x = QueryAllMLNodeWeightDistributionsForStageResponse{}
+func (x *QueryAllInferenceTimeoutRequest) Reset() {
+	*x = QueryAllInferenceTimeoutRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[43]
+		mi := &file_inference_inference_query_proto_msgTypes[61]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageResponse) String() string {
+func (x *QueryAllInferenceTimeoutRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllMLNodeWeightDistributionsForStageResponse) ProtoMessage() {}
+func (*QueryAllInferenceTimeoutRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllMLNodeWeightDistributionsForStageResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllMLNodeWeightDistributionsForStageResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{43}
+// Deprecated: Use QueryAllInferenceTimeoutRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllInferenceTimeoutRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{61}
 }
 
-func (x *QueryAllMLNodeWeightDistributionsForStageResponse) GetDistributions() []*MLNodeWeightDistributionWithAddress {
+func (x *QueryAllInferenceTimeoutRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.Distributions
+		return x.Pagination
 	}
 	return nil
 }
 
-type MLNodeWeightDistributionWithAddress struct {
+type QueryAllInferenceTimeoutResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParticipantAddress string          `protobuf:"bytes,1,opt,name=participant_address,json=participantAddress,proto3" json:"participant_address,omitempty"`
-	Weights            []*MLNodeWeight `protobuf:"bytes,2,rep,name=weights,proto3" json:"weights,omitempty"`
-	ModelId            string          `protobuf:"bytes,3,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	InferenceTimeout []*InferenceTimeout   `protobuf:"bytes,1,rep,name=inference_timeout,json=inferenceTimeout,proto3" json:"inference_timeout,omitempty"`
+	Pagination       *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *MLNodeWeightDistributionWithAddress) Reset() {
-	*x = MLNodeWeightDistributionWithAddress{}
+func (x *QueryAllInferenceTimeoutResponse) Reset() {
+	*x = QueryAllInferenceTimeoutResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[44]
+		mi := &file_inference_inference_query_proto_msgTypes[62]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *MLNodeWeightDistributionWithAddress) String() string {
+func (x *QueryAllInferenceTimeoutResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*MLNodeWeightDistributionWithAddress) ProtoMessage() {}
-
-// Deprecated: Use MLNodeWeightDistributionWithAddress.ProtoReflect.Descriptor instead.
-func (*MLNodeWeightDistributionWithAddress) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{44}
-}
+func (*QueryAllInferenceTimeoutResponse) ProtoMessage() {}
 
-func (x *MLNodeWeightDistributionWithAddress) GetParticipantAddress() string {
-	if x != nil {
-		return x.ParticipantAddress
-	}
-	return ""
+// Deprecated: Use QueryAllInferenceTimeoutResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllInferenceTimeoutResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{62}
 }
 
-func (x *MLNodeWeightDistributionWithAddress) GetWeights() []*MLNodeWeight {
+func (x *QueryAllInferenceTimeoutResponse) GetInferenceTimeout() []*InferenceTimeout {
 	if x != nil {
-		return x.Weights
+		return x.InferenceTimeout
 	}
 	return nil
 }
 
-func (x *MLNodeWeightDistributionWithAddress) GetModelId() string {
+func (x *QueryAllInferenceTimeoutResponse) GetPagination() *v1beta1.PageResponse {
 	if x != nil {
-		return x.ModelId
+		return x.Pagination
 	}
-	return ""
+	return nil
 }
 
-type QueryGetCurrentEpochRequest struct {
+type QueryGetInferenceValidationDetailsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	EpochId     uint64 `protobuf:"varint,1,opt,name=epochId,proto3" json:"epochId,omitempty"`
+	InferenceId string `protobuf:"bytes,2,opt,name=inferenceId,proto3" json:"inferenceId,omitempty"`
 }
 
-func (x *QueryGetCurrentEpochRequest) Reset() {
-	*x = QueryGetCurrentEpochRequest{}
+func (x *QueryGetInferenceValidationDetailsRequest) Reset() {
+	*x = QueryGetInferenceValidationDetailsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[45]
+		mi := &file_inference_inference_query_proto_msgTypes[63]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetCurrentEpochRequest) String() string {
+func (x *QueryGetInferenceValidationDetailsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetCurrentEpochRequest) ProtoMessage() {}
+func (*QueryGetInferenceValidationDetailsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetCurrentEpochRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetCurrentEpochRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{45}
+// Deprecated: Use QueryGetInferenceValidationDetailsRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceValidationDetailsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{63}
 }
 
-// DEPRECATED: ambiguous query, re-check what it expect as epoch: id, poc_start_block_height, or epoch_group_id
-type QueryGetCurrentEpochResponse struct {
+func (x *QueryGetInferenceValidationDetailsRequest) GetEpochId() uint64 {
+	if x != nil {
+		return x.EpochId
+	}
+	return 0
+}
+
+func (x *QueryGetInferenceValidationDetailsRequest) GetInferenceId() string {
+	if x != nil {
+		return x.InferenceId
+	}
+	return ""
+}
+
+type QueryGetInferenceValidationDetailsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Epoch uint64 `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
+	InferenceValidationDetails *InferenceValidationDetails `protobuf:"bytes,1,opt,name=inferenceValidationDetails,proto3" json:"inferenceValidationDetails,omitempty"`
 }
 
-func (x *QueryGetCurrentEpochResponse) Reset() {
-	*x = QueryGetCurrentEpochResponse{}
+func (x *QueryGetInferenceValidationDetailsResponse) Reset() {
+	*x = QueryGetInferenceValidationDetailsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[46]
+		mi := &file_inference_inference_query_proto_msgTypes[64]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetCurrentEpochResponse) String() string {
+func (x *QueryGetInferenceValidationDetailsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetCurrentEpochResponse) ProtoMessage() {}
+func (*QueryGetInferenceValidationDetailsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetCurrentEpochResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetCurrentEpochResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{46}
+// Deprecated: Use QueryGetInferenceValidationDetailsResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceValidationDetailsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{64}
 }
 
-func (x *QueryGetCurrentEpochResponse) GetEpoch() uint64 {
+func (x *QueryGetInferenceValidationDetailsResponse) GetInferenceValidationDetails() *InferenceValidationDetails {
 	if x != nil {
-		return x.Epoch
+		return x.InferenceValidationDetails
 	}
-	return 0
+	return nil
 }
 
-type QueryGetTokenomicsDataRequest struct {
+type QueryAllInferenceValidationDetailsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryGetTokenomicsDataRequest) Reset() {
-	*x = QueryGetTokenomicsDataRequest{}
+func (x *QueryAllInferenceValidationDetailsRequest) Reset() {
+	*x = QueryAllInferenceValidationDetailsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[47]
+		mi := &file_inference_inference_query_proto_msgTypes[65]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetTokenomicsDataRequest) String() string {
+func (x *QueryAllInferenceValidationDetailsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetTokenomicsDataRequest) ProtoMessage() {}
+func (*QueryAllInferenceValidationDetailsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetTokenomicsDataRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetTokenomicsDataRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{47}
+// Deprecated: Use QueryAllInferenceValidationDetailsRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllInferenceValidationDetailsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{65}
 }
 
-type QueryGetTokenomicsDataResponse struct {
+func (x *QueryAllInferenceValidationDetailsRequest) GetPagination() *v1beta1.PageRequest {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryAllInferenceValidationDetailsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	TokenomicsData *TokenomicsData `protobuf:"bytes,1,opt,name=tokenomics_data,json=tokenomicsData,proto3" json:"tokenomics_data,omitempty"`
+	InferenceValidationDetails []*InferenceValidationDetails `protobuf:"bytes,1,rep,name=inferenceValidationDetails,proto3" json:"inferenceValidationDetails,omitempty"`
+	Pagination                 *v1beta1.PageResponse         `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryGetTokenomicsDataResponse) Reset() {
-	*x = QueryGetTokenomicsDataResponse{}
+func (x *QueryAllInferenceValidationDetailsResponse) Reset() {
+	*x = QueryAllInferenceValidationDetailsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[48]
+		mi := &file_inference_inference_query_proto_msgTypes[66]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetTokenomicsDataResponse) String() string {
+func (x *QueryAllInferenceValidationDetailsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetTokenomicsDataResponse) ProtoMessage() {}
+func (*QueryAllInferenceValidationDetailsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetTokenomicsDataResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetTokenomicsDataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{48}
+// Deprecated: Use QueryAllInferenceValidationDetailsResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllInferenceValidationDetailsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{66}
 }
 
-func (x *QueryGetTokenomicsDataResponse) GetTokenomicsData() *TokenomicsData {
+func (x *QueryAllInferenceValidationDetailsResponse) GetInferenceValidationDetails() []*InferenceValidationDetails {
 	if x != nil {
-		return x.TokenomicsData
+		return x.InferenceValidationDetails
 	}
 	return nil
 }
 
-type QueryGetUnitOfComputePriceProposalRequest struct {
+func (x *QueryAllInferenceValidationDetailsResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryGetInferenceValidationParametersRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	Ids       []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
+	Requester string   `protobuf:"bytes,2,opt,name=requester,proto3" json:"requester,omitempty"`
 }
 
-func (x *QueryGetUnitOfComputePriceProposalRequest) Reset() {
-	*x = QueryGetUnitOfComputePriceProposalRequest{}
+func (x *QueryGetInferenceValidationParametersRequest) Reset() {
+	*x = QueryGetInferenceValidationParametersRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[49]
+		mi := &file_inference_inference_query_proto_msgTypes[67]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetUnitOfComputePriceProposalRequest) String() string {
+func (x *QueryGetInferenceValidationParametersRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetUnitOfComputePriceProposalRequest) ProtoMessage() {}
+func (*QueryGetInferenceValidationParametersRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetUnitOfComputePriceProposalRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetUnitOfComputePriceProposalRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{49}
+// Deprecated: Use QueryGetInferenceValidationParametersRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceValidationParametersRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{67}
 }
 
-func (x *QueryGetUnitOfComputePriceProposalRequest) GetParticipant() string {
+func (x *QueryGetInferenceValidationParametersRequest) GetIds() []string {
 	if x != nil {
-		return x.Participant
+		return x.Ids
+	}
+	return nil
+}
+
+func (x *QueryGetInferenceValidationParametersRequest) GetRequester() string {
+	if x != nil {
+		return x.Requester
 	}
 	return ""
 }
 
-type QueryGetUnitOfComputePriceProposalResponse struct {
+type QueryGetInferenceValidationParametersResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Proposal *UnitOfComputePriceProposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
-	Default  uint64                      `protobuf:"varint,2,opt,name=default,proto3" json:"default,omitempty"`
+	ValidatorPowers []*ValidatorPower             `protobuf:"bytes,1,rep,name=validator_powers,json=validatorPowers,proto3" json:"validator_powers,omitempty"`
+	CurrentHeight   uint64                        `protobuf:"varint,2,opt,name=current_height,json=currentHeight,proto3" json:"current_height,omitempty"`
+	Details         []*InferenceValidationDetails `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
+	Parameters      *ValidationParams             `protobuf:"bytes,4,opt,name=parameters,proto3" json:"parameters,omitempty"`
 }
 
-func (x *QueryGetUnitOfComputePriceProposalResponse) Reset() {
-	*x = QueryGetUnitOfComputePriceProposalResponse{}
+func (x *QueryGetInferenceValidationParametersResponse) Reset() {
+	*x = QueryGetInferenceValidationParametersResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[50]
+		mi := &file_inference_inference_query_proto_msgTypes[68]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetUnitOfComputePriceProposalResponse) String() string {
+func (x *QueryGetInferenceValidationParametersResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetUnitOfComputePriceProposalResponse) ProtoMessage() {}
+func (*QueryGetInferenceValidationParametersResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetUnitOfComputePriceProposalResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetUnitOfComputePriceProposalResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{50}
+// Deprecated: Use QueryGetInferenceValidationParametersResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetInferenceValidationParametersResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{68}
 }
 
-func (x *QueryGetUnitOfComputePriceProposalResponse) GetProposal() *UnitOfComputePriceProposal {
+func (x *QueryGetInferenceValidationParametersResponse) GetValidatorPowers() []*ValidatorPower {
 	if x != nil {
-		return x.Proposal
+		return x.ValidatorPowers
 	}
 	return nil
 }
 
-func (x *QueryGetUnitOfComputePriceProposalResponse) GetDefault() uint64 {
+func (x *QueryGetInferenceValidationParametersResponse) GetCurrentHeight() uint64 {
 	if x != nil {
-		return x.Default
+		return x.CurrentHeight
 	}
 	return 0
 }
 
-type QueryCurrentEpochGroupDataRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *QueryCurrentEpochGroupDataRequest) Reset() {
-	*x = QueryCurrentEpochGroupDataRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[51]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+func (x *QueryGetInferenceValidationParametersResponse) GetDetails() []*InferenceValidationDetails {
+	if x != nil {
+		return x.Details
 	}
+	return nil
 }
 
-func (x *QueryCurrentEpochGroupDataRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*QueryCurrentEpochGroupDataRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryCurrentEpochGroupDataRequest.ProtoReflect.Descriptor instead.
-func (*QueryCurrentEpochGroupDataRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{51}
+func (x *QueryGetInferenceValidationParametersResponse) GetParameters() *ValidationParams {
+	if x != nil {
+		return x.Parameters
+	}
+	return nil
 }
 
-type QueryCurrentEpochGroupDataResponse struct {
+type ValidatorPower struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochGroupData *EpochGroupData `protobuf:"bytes,1,opt,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
+	Power      uint64 `protobuf:"varint,1,opt,name=power,proto3" json:"power,omitempty"`
+	EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *QueryCurrentEpochGroupDataResponse) Reset() {
-	*x = QueryCurrentEpochGroupDataResponse{}
+func (x *ValidatorPower) Reset() {
+	*x = ValidatorPower{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[52]
+		mi := &file_inference_inference_query_proto_msgTypes[69]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCurrentEpochGroupDataResponse) String() string {
+func (x *ValidatorPower) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCurrentEpochGroupDataResponse) ProtoMessage() {}
+func (*ValidatorPower) ProtoMessage() {}
 
-// Deprecated: Use QueryCurrentEpochGroupDataResponse.ProtoReflect.Descriptor instead.
-func (*QueryCurrentEpochGroupDataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{52}
+// Deprecated: Use ValidatorPower.ProtoReflect.Descriptor instead.
+func (*ValidatorPower) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{69}
 }
 
-func (x *QueryCurrentEpochGroupDataResponse) GetEpochGroupData() *EpochGroupData {
+func (x *ValidatorPower) GetPower() uint64 {
 	if x != nil {
-		return x.EpochGroupData
+		return x.Power
 	}
-	return nil
+	return 0
 }
 
-type QueryPreviousEpochGroupDataRequest struct {
+func (x *ValidatorPower) GetEpochIndex() uint64 {
+	if x != nil {
+		return x.EpochIndex
+	}
+	return 0
+}
+
+type QueryEpochPerformanceSummaryByEpochRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *QueryPreviousEpochGroupDataRequest) Reset() {
-	*x = QueryPreviousEpochGroupDataRequest{}
+func (x *QueryEpochPerformanceSummaryByEpochRequest) Reset() {
+	*x = QueryEpochPerformanceSummaryByEpochRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[53]
+		mi := &file_inference_inference_query_proto_msgTypes[70]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPreviousEpochGroupDataRequest) String() string {
+func (x *QueryEpochPerformanceSummaryByEpochRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPreviousEpochGroupDataRequest) ProtoMessage() {}
+func (*QueryEpochPerformanceSummaryByEpochRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryPreviousEpochGroupDataRequest.ProtoReflect.Descriptor instead.
-func (*QueryPreviousEpochGroupDataRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{53}
+// Deprecated: Use QueryEpochPerformanceSummaryByEpochRequest.ProtoReflect.Descriptor instead.
+func (*QueryEpochPerformanceSummaryByEpochRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{70}
 }
 
-type QueryPreviousEpochGroupDataResponse struct {
+func (x *QueryEpochPerformanceSummaryByEpochRequest) GetEpochIndex() uint64 {
+	if x != nil {
+		return x.EpochIndex
+	}
+	return 0
+}
+
+type QueryEpochPerformanceSummaryByEpochResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochGroupData *EpochGroupData `protobuf:"bytes,1,opt,name=epoch_group_data,json=epochGroupData,proto3" json:"epoch_group_data,omitempty"`
+	EpochPerformanceSummary []*EpochPerformanceSummary `protobuf:"bytes,1,rep,name=epochPerformanceSummary,proto3" json:"epochPerformanceSummary,omitempty"`
 }
 
-func (x *QueryPreviousEpochGroupDataResponse) Reset() {
-	*x = QueryPreviousEpochGroupDataResponse{}
+func (x *QueryEpochPerformanceSummaryByEpochResponse) Reset() {
+	*x = QueryEpochPerformanceSummaryByEpochResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[54]
+		mi := &file_inference_inference_query_proto_msgTypes[71]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPreviousEpochGroupDataResponse) String() string {
+func (x *QueryEpochPerformanceSummaryByEpochResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPreviousEpochGroupDataResponse) ProtoMessage() {}
+func (*QueryEpochPerformanceSummaryByEpochResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryPreviousEpochGroupDataResponse.ProtoReflect.Descriptor instead.
-func (*QueryPreviousEpochGroupDataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{54}
+// Deprecated: Use QueryEpochPerformanceSummaryByEpochResponse.ProtoReflect.Descriptor instead.
+func (*QueryEpochPerformanceSummaryByEpochResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{71}
 }
 
-func (x *QueryPreviousEpochGroupDataResponse) GetEpochGroupData() *EpochGroupData {
+func (x *QueryEpochPerformanceSummaryByEpochResponse) GetEpochPerformanceSummary() []*EpochPerformanceSummary {
 	if x != nil {
-		return x.EpochGroupData
+		return x.EpochPerformanceSummary
 	}
 	return nil
 }
 
-type QueryModelsAllRequest struct {
+type QueryEpochPerformanceSummaryByParticipantRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	EpochIndex    uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	ParticipantId string `protobuf:"bytes,2,opt,name=participantId,proto3" json:"participantId,omitempty"`
 }
 
-func (x *QueryModelsAllRequest) Reset() {
-	*x = QueryModelsAllRequest{}
+func (x *QueryEpochPerformanceSummaryByParticipantRequest) Reset() {
+	*x = QueryEpochPerformanceSummaryByParticipantRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[55]
+		mi := &file_inference_inference_query_proto_msgTypes[72]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryModelsAllRequest) String() string {
+func (x *QueryEpochPerformanceSummaryByParticipantRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryModelsAllRequest) ProtoMessage() {}
+func (*QueryEpochPerformanceSummaryByParticipantRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryModelsAllRequest.ProtoReflect.Descriptor instead.
-func (*QueryModelsAllRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{55}
+// Deprecated: Use QueryEpochPerformanceSummaryByParticipantRequest.ProtoReflect.Descriptor instead.
+func (*QueryEpochPerformanceSummaryByParticipantRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{72}
 }
 
-func (x *QueryModelsAllRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryEpochPerformanceSummaryByParticipantRequest) GetEpochIndex() uint64 {
 	if x != nil {
-		return x.Pagination
+		return x.EpochIndex
 	}
-	return nil
+	return 0
 }
 
-type QueryModelsAllResponse struct {
+func (x *QueryEpochPerformanceSummaryByParticipantRequest) GetParticipantId() string {
+	if x != nil {
+		return x.ParticipantId
+	}
+	return ""
+}
+
+type QueryEpochPerformanceSummaryByParticipantResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Model      []*Model              `protobuf:"bytes,1,rep,name=model,proto3" json:"model,omitempty"`
-	Pagination *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	EpochPerformanceSummary *EpochPerformanceSummary `protobuf:"bytes,1,opt,name=epochPerformanceSummary,proto3" json:"epochPerformanceSummary,omitempty"`
 }
 
-func (x *QueryModelsAllResponse) Reset() {
-	*x = QueryModelsAllResponse{}
+func (x *QueryEpochPerformanceSummaryByParticipantResponse) Reset() {
+	*x = QueryEpochPerformanceSummaryByParticipantResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[56]
+		mi := &file_inference_inference_query_proto_msgTypes[73]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryModelsAllResponse) String() string {
+func (x *QueryEpochPerformanceSummaryByParticipantResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryModelsAllResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryModelsAllResponse.ProtoReflect.Descriptor instead.
-func (*QueryModelsAllResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{56}
-}
+func (*QueryEpochPerformanceSummaryByParticipantResponse) ProtoMessage() {}
 
-func (x *QueryModelsAllResponse) GetModel() []*Model {
-	if x != nil {
-		return x.Model
-	}
-	return nil
+// Deprecated: Use QueryEpochPerformanceSummaryByParticipantResponse.ProtoReflect.Descriptor instead.
+func (*QueryEpochPerformanceSummaryByParticipantResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{73}
 }
 
-func (x *QueryModelsAllResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryEpochPerformanceSummaryByParticipantResponse) GetEpochPerformanceSummary() *EpochPerformanceSummary {
 	if x != nil {
-		return x.Pagination
+		return x.EpochPerformanceSummary
 	}
 	return nil
 }
 
-type QueryGetInferenceTimeoutRequest struct {
+type QueryAllEpochPerformanceSummaryRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ExpirationHeight uint64 `protobuf:"varint,1,opt,name=expirationHeight,proto3" json:"expirationHeight,omitempty"`
-	InferenceId      string `protobuf:"bytes,2,opt,name=inferenceId,proto3" json:"inferenceId,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryGetInferenceTimeoutRequest) Reset() {
-	*x = QueryGetInferenceTimeoutRequest{}
+func (x *QueryAllEpochPerformanceSummaryRequest) Reset() {
+	*x = QueryAllEpochPerformanceSummaryRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[57]
+		mi := &file_inference_inference_query_proto_msgTypes[74]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetInferenceTimeoutRequest) String() string {
+func (x *QueryAllEpochPerformanceSummaryRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetInferenceTimeoutRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryGetInferenceTimeoutRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceTimeoutRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{57}
-}
+func (*QueryAllEpochPerformanceSummaryRequest) ProtoMessage() {}
 
-func (x *QueryGetInferenceTimeoutRequest) GetExpirationHeight() uint64 {
-	if x != nil {
-		return x.ExpirationHeight
-	}
-	return 0
+// Deprecated: Use QueryAllEpochPerformanceSummaryRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllEpochPerformanceSummaryRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{74}
 }
 
-func (x *QueryGetInferenceTimeoutRequest) GetInferenceId() string {
+func (x *QueryAllEpochPerformanceSummaryRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.InferenceId
+		return x.Pagination
 	}
-	return ""
+	return nil
 }
 
-type QueryGetInferenceTimeoutResponse struct {
+type QueryAllEpochPerformanceSummaryResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	InferenceTimeout *InferenceTimeout `protobuf:"bytes,1,opt,name=inference_timeout,json=inferenceTimeout,proto3" json:"inference_timeout,omitempty"`
+	EpochPerformanceSummary []*EpochPerformanceSummary `protobuf:"bytes,1,rep,name=epochPerformanceSummary,proto3" json:"epochPerformanceSummary,omitempty"`
+	Pagination              *v1beta1.PageResponse      `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryGetInferenceTimeoutResponse) Reset() {
-	*x = QueryGetInferenceTimeoutResponse{}
+func (x *QueryAllEpochPerformanceSummaryResponse) Reset() {
+	*x = QueryAllEpochPerformanceSummaryResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[58]
+		mi := &file_inference_inference_query_proto_msgTypes[75]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetInferenceTimeoutResponse) String() string {
+func (x *QueryAllEpochPerformanceSummaryResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetInferenceTimeoutResponse) ProtoMessage() {}
+func (*QueryAllEpochPerformanceSummaryResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetInferenceTimeoutResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceTimeoutResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{58}
+// Deprecated: Use QueryAllEpochPerformanceSummaryResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllEpochPerformanceSummaryResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{75}
 }
 
-func (x *QueryGetInferenceTimeoutResponse) GetInferenceTimeout() *InferenceTimeout {
+func (x *QueryAllEpochPerformanceSummaryResponse) GetEpochPerformanceSummary() []*EpochPerformanceSummary {
 	if x != nil {
-		return x.InferenceTimeout
+		return x.EpochPerformanceSummary
+	}
+	return nil
+}
+
+func (x *QueryAllEpochPerformanceSummaryResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
 	}
 	return nil
 }
 
-type QueryAllInferenceTimeoutRequest struct {
+type QueryHardwareNodesRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryAllInferenceTimeoutRequest) Reset() {
-	*x = QueryAllInferenceTimeoutRequest{}
+func (x *QueryHardwareNodesRequest) Reset() {
+	*x = QueryHardwareNodesRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[59]
+		mi := &file_inference_inference_query_proto_msgTypes[76]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllInferenceTimeoutRequest) String() string {
+func (x *QueryHardwareNodesRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllInferenceTimeoutRequest) ProtoMessage() {}
+func (*QueryHardwareNodesRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllInferenceTimeoutRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllInferenceTimeoutRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{59}
+// Deprecated: Use QueryHardwareNodesRequest.ProtoReflect.Descriptor instead.
+func (*QueryHardwareNodesRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{76}
 }
 
-func (x *QueryAllInferenceTimeoutRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryHardwareNodesRequest) GetParticipant() string {
 	if x != nil {
-		return x.Pagination
+		return x.Participant
 	}
-	return nil
+	return ""
 }
 
-type QueryAllInferenceTimeoutResponse struct {
+type QueryHardwareNodesResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	InferenceTimeout []*InferenceTimeout   `protobuf:"bytes,1,rep,name=inference_timeout,json=inferenceTimeout,proto3" json:"inference_timeout,omitempty"`
-	Pagination       *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Nodes *HardwareNodes `protobuf:"bytes,1,opt,name=nodes,proto3" json:"nodes,omitempty"`
 }
 
-func (x *QueryAllInferenceTimeoutResponse) Reset() {
-	*x = QueryAllInferenceTimeoutResponse{}
+func (x *QueryHardwareNodesResponse) Reset() {
+	*x = QueryHardwareNodesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[60]
+		mi := &file_inference_inference_query_proto_msgTypes[77]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllInferenceTimeoutResponse) String() string {
+func (x *QueryHardwareNodesResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllInferenceTimeoutResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryAllInferenceTimeoutResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllInferenceTimeoutResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{60}
-}
+func (*QueryHardwareNodesResponse) ProtoMessage() {}
 
-func (x *QueryAllInferenceTimeoutResponse) GetInferenceTimeout() []*InferenceTimeout {
-	if x != nil {
-		return x.InferenceTimeout
-	}
-	return nil
+// Deprecated: Use QueryHardwareNodesResponse.ProtoReflect.Descriptor instead.
+func (*QueryHardwareNodesResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{77}
 }
 
-func (x *QueryAllInferenceTimeoutResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryHardwareNodesResponse) GetNodes() *HardwareNodes {
 	if x != nil {
-		return x.Pagination
+		return x.Nodes
 	}
 	return nil
 }
 
-type QueryGetInferenceValidationDetailsRequest struct {
+type QueryHardwareNodesAllRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	EpochId     uint64 `protobuf:"varint,1,opt,name=epochId,proto3" json:"epochId,omitempty"`
-	InferenceId string `protobuf:"bytes,2,opt,name=inferenceId,proto3" json:"inferenceId,omitempty"`
 }
 
-func (x *QueryGetInferenceValidationDetailsRequest) Reset() {
-	*x = QueryGetInferenceValidationDetailsRequest{}
+func (x *QueryHardwareNodesAllRequest) Reset() {
+	*x = QueryHardwareNodesAllRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[61]
+		mi := &file_inference_inference_query_proto_msgTypes[78]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetInferenceValidationDetailsRequest) String() string {
+func (x *QueryHardwareNodesAllRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetInferenceValidationDetailsRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryGetInferenceValidationDetailsRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceValidationDetailsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{61}
-}
-
-func (x *QueryGetInferenceValidationDetailsRequest) GetEpochId() uint64 {
-	if x != nil {
-		return x.EpochId
-	}
-	return 0
-}
+func (*QueryHardwareNodesAllRequest) ProtoMessage() {}
 
-func (x *QueryGetInferenceValidationDetailsRequest) GetInferenceId() string {
-	if x != nil {
-		return x.InferenceId
-	}
-	return ""
+// Deprecated: Use QueryHardwareNodesAllRequest.ProtoReflect.Descriptor instead.
+func (*QueryHardwareNodesAllRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{78}
 }
 
-type QueryGetInferenceValidationDetailsResponse struct {
+type QueryHardwareNodesAllResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	InferenceValidationDetails *InferenceValidationDetails `protobuf:"bytes,1,opt,name=inferenceValidationDetails,proto3" json:"inferenceValidationDetails,omitempty"`
+	Nodes []*HardwareNodes `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
 }
 
-func (x *QueryGetInferenceValidationDetailsResponse) Reset() {
-	*x = QueryGetInferenceValidationDetailsResponse{}
+func (x *QueryHardwareNodesAllResponse) Reset() {
+	*x = QueryHardwareNodesAllResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[62]
+		mi := &file_inference_inference_query_proto_msgTypes[79]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetInferenceValidationDetailsResponse) String() string {
+func (x *QueryHardwareNodesAllResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetInferenceValidationDetailsResponse) ProtoMessage() {}
+func (*QueryHardwareNodesAllResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetInferenceValidationDetailsResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceValidationDetailsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{62}
+// Deprecated: Use QueryHardwareNodesAllResponse.ProtoReflect.Descriptor instead.
+func (*QueryHardwareNodesAllResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{79}
 }
 
-func (x *QueryGetInferenceValidationDetailsResponse) GetInferenceValidationDetails() *InferenceValidationDetails {
+func (x *QueryHardwareNodesAllResponse) GetNodes() []*HardwareNodes {
 	if x != nil {
-		return x.InferenceValidationDetails
+		return x.Nodes
 	}
 	return nil
 }
 
-type QueryAllInferenceValidationDetailsRequest struct {
+type QueryGetParticipantCurrentStatsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	ParticipantId string `protobuf:"bytes,1,opt,name=participantId,proto3" json:"participantId,omitempty"`
 }
 
-func (x *QueryAllInferenceValidationDetailsRequest) Reset() {
-	*x = QueryAllInferenceValidationDetailsRequest{}
+func (x *QueryGetParticipantCurrentStatsRequest) Reset() {
+	*x = QueryGetParticipantCurrentStatsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[63]
+		mi := &file_inference_inference_query_proto_msgTypes[80]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllInferenceValidationDetailsRequest) String() string {
+func (x *QueryGetParticipantCurrentStatsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllInferenceValidationDetailsRequest) ProtoMessage() {}
+func (*QueryGetParticipantCurrentStatsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllInferenceValidationDetailsRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllInferenceValidationDetailsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{63}
+// Deprecated: Use QueryGetParticipantCurrentStatsRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetParticipantCurrentStatsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{80}
 }
 
-func (x *QueryAllInferenceValidationDetailsRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryGetParticipantCurrentStatsRequest) GetParticipantId() string {
 	if x != nil {
-		return x.Pagination
+		return x.ParticipantId
 	}
-	return nil
+	return ""
 }
 
-type QueryAllInferenceValidationDetailsResponse struct {
+type QueryGetParticipantCurrentStatsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	InferenceValidationDetails []*InferenceValidationDetails `protobuf:"bytes,1,rep,name=inferenceValidationDetails,proto3" json:"inferenceValidationDetails,omitempty"`
-	Pagination                 *v1beta1.PageResponse         `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Weight     uint64 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty"`
+	Reputation int32  `protobuf:"varint,2,opt,name=reputation,proto3" json:"reputation,omitempty"`
 }
 
-func (x *QueryAllInferenceValidationDetailsResponse) Reset() {
-	*x = QueryAllInferenceValidationDetailsResponse{}
+func (x *QueryGetParticipantCurrentStatsResponse) Reset() {
+	*x = QueryGetParticipantCurrentStatsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[64]
+		mi := &file_inference_inference_query_proto_msgTypes[81]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllInferenceValidationDetailsResponse) String() string {
+func (x *QueryGetParticipantCurrentStatsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllInferenceValidationDetailsResponse) ProtoMessage() {}
+func (*QueryGetParticipantCurrentStatsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllInferenceValidationDetailsResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllInferenceValidationDetailsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{64}
+// Deprecated: Use QueryGetParticipantCurrentStatsResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetParticipantCurrentStatsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{81}
 }
 
-func (x *QueryAllInferenceValidationDetailsResponse) GetInferenceValidationDetails() []*InferenceValidationDetails {
+func (x *QueryGetParticipantCurrentStatsResponse) GetWeight() uint64 {
 	if x != nil {
-		return x.InferenceValidationDetails
+		return x.Weight
 	}
-	return nil
+	return 0
 }
 
-func (x *QueryAllInferenceValidationDetailsResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryGetParticipantCurrentStatsResponse) GetReputation() int32 {
 	if x != nil {
-		return x.Pagination
+		return x.Reputation
 	}
-	return nil
+	return 0
 }
 
-type QueryGetInferenceValidationParametersRequest struct {
+type QueryGetAllParticipantCurrentStatsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	Ids       []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
-	Requester string   `protobuf:"bytes,2,opt,name=requester,proto3" json:"requester,omitempty"`
 }
 
-func (x *QueryGetInferenceValidationParametersRequest) Reset() {
-	*x = QueryGetInferenceValidationParametersRequest{}
+func (x *QueryGetAllParticipantCurrentStatsRequest) Reset() {
+	*x = QueryGetAllParticipantCurrentStatsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[65]
+		mi := &file_inference_inference_query_proto_msgTypes[82]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetInferenceValidationParametersRequest) String() string {
+func (x *QueryGetAllParticipantCurrentStatsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetInferenceValidationParametersRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryGetInferenceValidationParametersRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceValidationParametersRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{65}
-}
-
-func (x *QueryGetInferenceValidationParametersRequest) GetIds() []string {
-	if x != nil {
-		return x.Ids
-	}
-	return nil
-}
+func (*QueryGetAllParticipantCurrentStatsRequest) ProtoMessage() {}
 
-func (x *QueryGetInferenceValidationParametersRequest) GetRequester() string {
-	if x != nil {
-		return x.Requester
-	}
-	return ""
+// Deprecated: Use QueryGetAllParticipantCurrentStatsRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetAllParticipantCurrentStatsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{82}
 }
 
-type QueryGetInferenceValidationParametersResponse struct {
+type QueryGetAllParticipantCurrentStatsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ValidatorPowers []*ValidatorPower             `protobuf:"bytes,1,rep,name=validator_powers,json=validatorPowers,proto3" json:"validator_powers,omitempty"`
-	CurrentHeight   uint64                        `protobuf:"varint,2,opt,name=current_height,json=currentHeight,proto3" json:"current_height,omitempty"`
-	Details         []*InferenceValidationDetails `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
-	Parameters      *ValidationParams             `protobuf:"bytes,4,opt,name=parameters,proto3" json:"parameters,omitempty"`
+	ParticipantCurrentStats []*ParticipantCurrentStats `protobuf:"bytes,1,rep,name=participant_current_stats,json=participantCurrentStats,proto3" json:"participant_current_stats,omitempty"`
+	BlockHeight             int64                      `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	EpochId                 int64                      `protobuf:"varint,3,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
 }
 
-func (x *QueryGetInferenceValidationParametersResponse) Reset() {
-	*x = QueryGetInferenceValidationParametersResponse{}
+func (x *QueryGetAllParticipantCurrentStatsResponse) Reset() {
+	*x = QueryGetAllParticipantCurrentStatsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[66]
+		mi := &file_inference_inference_query_proto_msgTypes[83]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetInferenceValidationParametersResponse) String() string {
+func (x *QueryGetAllParticipantCurrentStatsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetInferenceValidationParametersResponse) ProtoMessage() {}
+func (*QueryGetAllParticipantCurrentStatsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetInferenceValidationParametersResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetInferenceValidationParametersResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{66}
+// Deprecated: Use QueryGetAllParticipantCurrentStatsResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetAllParticipantCurrentStatsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{83}
 }
 
-func (x *QueryGetInferenceValidationParametersResponse) GetValidatorPowers() []*ValidatorPower {
+func (x *QueryGetAllParticipantCurrentStatsResponse) GetParticipantCurrentStats() []*ParticipantCurrentStats {
 	if x != nil {
-		return x.ValidatorPowers
+		return x.ParticipantCurrentStats
 	}
 	return nil
 }
 
-func (x *QueryGetInferenceValidationParametersResponse) GetCurrentHeight() uint64 {
+func (x *QueryGetAllParticipantCurrentStatsResponse) GetBlockHeight() int64 {
 	if x != nil {
-		return x.CurrentHeight
+		return x.BlockHeight
 	}
 	return 0
 }
 
-func (x *QueryGetInferenceValidationParametersResponse) GetDetails() []*InferenceValidationDetails {
-	if x != nil {
-		return x.Details
-	}
-	return nil
-}
-
-func (x *QueryGetInferenceValidationParametersResponse) GetParameters() *ValidationParams {
+func (x *QueryGetAllParticipantCurrentStatsResponse) GetEpochId() int64 {
 	if x != nil {
-		return x.Parameters
+		return x.EpochId
 	}
-	return nil
+	return 0
 }
 
-type ValidatorPower struct {
+type ParticipantCurrentStats struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Power      uint64 `protobuf:"varint,1,opt,name=power,proto3" json:"power,omitempty"`
-	EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	ParticipantId   string `protobuf:"bytes,1,opt,name=participant_id,json=participantId,proto3" json:"participant_id,omitempty"`
+	Weight          uint64 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
+	EffectiveWeight uint64 `protobuf:"varint,4,opt,name=effective_weight,json=effectiveWeight,proto3" json:"effective_weight,omitempty"`
+	CappedWeight    uint64 `protobuf:"varint,5,opt,name=capped_weight,json=cappedWeight,proto3" json:"capped_weight,omitempty"`
+	Reputation      int32  `protobuf:"varint,3,opt,name=reputation,proto3" json:"reputation,omitempty"`
 }
 
-func (x *ValidatorPower) Reset() {
-	*x = ValidatorPower{}
+func (x *ParticipantCurrentStats) Reset() {
+	*x = ParticipantCurrentStats{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[67]
+		mi := &file_inference_inference_query_proto_msgTypes[84]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ValidatorPower) String() string {
+func (x *ParticipantCurrentStats) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ValidatorPower) ProtoMessage() {}
+func (*ParticipantCurrentStats) ProtoMessage() {}
 
-// Deprecated: Use ValidatorPower.ProtoReflect.Descriptor instead.
-func (*ValidatorPower) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{67}
+// Deprecated: Use ParticipantCurrentStats.ProtoReflect.Descriptor instead.
+func (*ParticipantCurrentStats) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{84}
 }
 
-func (x *ValidatorPower) GetPower() uint64 {
+func (x *ParticipantCurrentStats) GetParticipantId() string {
 	if x != nil {
-		return x.Power
+		return x.ParticipantId
+	}
+	return ""
+}
+
+func (x *ParticipantCurrentStats) GetWeight() uint64 {
+	if x != nil {
+		return x.Weight
 	}
 	return 0
 }
 
-func (x *ValidatorPower) GetEpochIndex() uint64 {
+func (x *ParticipantCurrentStats) GetEffectiveWeight() uint64 {
 	if x != nil {
-		return x.EpochIndex
+		return x.EffectiveWeight
 	}
 	return 0
 }
 
-type QueryEpochPerformanceSummaryByEpochRequest struct {
+func (x *ParticipantCurrentStats) GetCappedWeight() uint64 {
+	if x != nil {
+		return x.CappedWeight
+	}
+	return 0
+}
+
+func (x *ParticipantCurrentStats) GetReputation() int32 {
+	if x != nil {
+		return x.Reputation
+	}
+	return 0
+}
+
+type ParticipantFullStats struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	AccountAddress           string `protobuf:"bytes,1,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"`
+	OperatorAddress          string `protobuf:"bytes,2,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"`
+	Reputation               int32  `protobuf:"varint,3,opt,name=reputation,proto3" json:"reputation,omitempty"`
+	EarnedCoinsCurrentEpoch  uint64 `protobuf:"varint,4,opt,name=earned_coins_current_epoch,json=earnedCoinsCurrentEpoch,proto3" json:"earned_coins_current_epoch,omitempty"`
+	RewardedCoinsLatestEpoch uint64 `protobuf:"varint,5,opt,name=rewarded_coins_latest_epoch,json=rewardedCoinsLatestEpoch,proto3" json:"rewarded_coins_latest_epoch,omitempty"`
+	EpochsCompleted          uint32 `protobuf:"varint,6,opt,name=epochs_completed,json=epochsCompleted,proto3" json:"epochs_completed,omitempty"`
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochRequest) Reset() {
-	*x = QueryEpochPerformanceSummaryByEpochRequest{}
+func (x *ParticipantFullStats) Reset() {
+	*x = ParticipantFullStats{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[68]
+		mi := &file_inference_inference_query_proto_msgTypes[85]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochRequest) String() string {
+func (x *ParticipantFullStats) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryEpochPerformanceSummaryByEpochRequest) ProtoMessage() {}
+func (*ParticipantFullStats) ProtoMessage() {}
 
-// Deprecated: Use QueryEpochPerformanceSummaryByEpochRequest.ProtoReflect.Descriptor instead.
-func (*QueryEpochPerformanceSummaryByEpochRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{68}
+// Deprecated: Use ParticipantFullStats.ProtoReflect.Descriptor instead.
+func (*ParticipantFullStats) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{85}
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochRequest) GetEpochIndex() uint64 {
+func (x *ParticipantFullStats) GetAccountAddress() string {
 	if x != nil {
-		return x.EpochIndex
+		return x.AccountAddress
+	}
+	return ""
+}
+
+func (x *ParticipantFullStats) GetOperatorAddress() string {
+	if x != nil {
+		return x.OperatorAddress
+	}
+	return ""
+}
+
+func (x *ParticipantFullStats) GetReputation() int32 {
+	if x != nil {
+		return x.Reputation
 	}
 	return 0
 }
 
-type QueryEpochPerformanceSummaryByEpochResponse struct {
+func (x *ParticipantFullStats) GetEarnedCoinsCurrentEpoch() uint64 {
+	if x != nil {
+		return x.EarnedCoinsCurrentEpoch
+	}
+	return 0
+}
+
+func (x *ParticipantFullStats) GetRewardedCoinsLatestEpoch() uint64 {
+	if x != nil {
+		return x.RewardedCoinsLatestEpoch
+	}
+	return 0
+}
+
+func (x *ParticipantFullStats) GetEpochsCompleted() uint32 {
+	if x != nil {
+		return x.EpochsCompleted
+	}
+	return 0
+}
+
+type QueryParticipantsFullStatsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	EpochPerformanceSummary []*EpochPerformanceSummary `protobuf:"bytes,1,rep,name=epochPerformanceSummary,proto3" json:"epochPerformanceSummary,omitempty"`
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochResponse) Reset() {
-	*x = QueryEpochPerformanceSummaryByEpochResponse{}
+func (x *QueryParticipantsFullStatsRequest) Reset() {
+	*x = QueryParticipantsFullStatsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[69]
+		mi := &file_inference_inference_query_proto_msgTypes[86]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryEpochPerformanceSummaryByEpochResponse) String() string {
+func (x *QueryParticipantsFullStatsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryEpochPerformanceSummaryByEpochResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryEpochPerformanceSummaryByEpochResponse.ProtoReflect.Descriptor instead.
-func (*QueryEpochPerformanceSummaryByEpochResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{69}
-}
+func (*QueryParticipantsFullStatsRequest) ProtoMessage() {}
 
-func (x *QueryEpochPerformanceSummaryByEpochResponse) GetEpochPerformanceSummary() []*EpochPerformanceSummary {
-	if x != nil {
-		return x.EpochPerformanceSummary
-	}
-	return nil
+// Deprecated: Use QueryParticipantsFullStatsRequest.ProtoReflect.Descriptor instead.
+func (*QueryParticipantsFullStatsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{86}
 }
 
-type QueryEpochPerformanceSummaryByParticipantRequest struct {
+type QueryParticipantsFullStatsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochIndex    uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
-	ParticipantId string `protobuf:"bytes,2,opt,name=participantId,proto3" json:"participantId,omitempty"`
+	ParticipantsStats []*ParticipantFullStats `protobuf:"bytes,1,rep,name=participants_stats,json=participantsStats,proto3" json:"participants_stats,omitempty"`
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantRequest) Reset() {
-	*x = QueryEpochPerformanceSummaryByParticipantRequest{}
+func (x *QueryParticipantsFullStatsResponse) Reset() {
+	*x = QueryParticipantsFullStatsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[70]
+		mi := &file_inference_inference_query_proto_msgTypes[87]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantRequest) String() string {
+func (x *QueryParticipantsFullStatsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryEpochPerformanceSummaryByParticipantRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryEpochPerformanceSummaryByParticipantRequest.ProtoReflect.Descriptor instead.
-func (*QueryEpochPerformanceSummaryByParticipantRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{70}
-}
+func (*QueryParticipantsFullStatsResponse) ProtoMessage() {}
 
-func (x *QueryEpochPerformanceSummaryByParticipantRequest) GetEpochIndex() uint64 {
-	if x != nil {
-		return x.EpochIndex
-	}
-	return 0
+// Deprecated: Use QueryParticipantsFullStatsResponse.ProtoReflect.Descriptor instead.
+func (*QueryParticipantsFullStatsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{87}
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantRequest) GetParticipantId() string {
+func (x *QueryParticipantsFullStatsResponse) GetParticipantsStats() []*ParticipantFullStats {
 	if x != nil {
-		return x.ParticipantId
+		return x.ParticipantsStats
 	}
-	return ""
+	return nil
 }
 
-type QueryEpochPerformanceSummaryByParticipantResponse struct {
+type QueryStatsByTimePeriodByDeveloperRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochPerformanceSummary *EpochPerformanceSummary `protobuf:"bytes,1,opt,name=epochPerformanceSummary,proto3" json:"epochPerformanceSummary,omitempty"`
+	Developer string `protobuf:"bytes,1,opt,name=developer,proto3" json:"developer,omitempty"`
+	TimeFrom  int64  `protobuf:"varint,2,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
+	TimeTo    int64  `protobuf:"varint,3,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantResponse) Reset() {
-	*x = QueryEpochPerformanceSummaryByParticipantResponse{}
+func (x *QueryStatsByTimePeriodByDeveloperRequest) Reset() {
+	*x = QueryStatsByTimePeriodByDeveloperRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[71]
+		mi := &file_inference_inference_query_proto_msgTypes[88]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantResponse) String() string {
+func (x *QueryStatsByTimePeriodByDeveloperRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryEpochPerformanceSummaryByParticipantResponse) ProtoMessage() {}
+func (*QueryStatsByTimePeriodByDeveloperRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryEpochPerformanceSummaryByParticipantResponse.ProtoReflect.Descriptor instead.
-func (*QueryEpochPerformanceSummaryByParticipantResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{71}
+// Deprecated: Use QueryStatsByTimePeriodByDeveloperRequest.ProtoReflect.Descriptor instead.
+func (*QueryStatsByTimePeriodByDeveloperRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{88}
 }
 
-func (x *QueryEpochPerformanceSummaryByParticipantResponse) GetEpochPerformanceSummary() *EpochPerformanceSummary {
+func (x *QueryStatsByTimePeriodByDeveloperRequest) GetDeveloper() string {
 	if x != nil {
-		return x.EpochPerformanceSummary
+		return x.Developer
 	}
-	return nil
+	return ""
 }
 
-type QueryAllEpochPerformanceSummaryRequest struct {
+func (x *QueryStatsByTimePeriodByDeveloperRequest) GetTimeFrom() int64 {
+	if x != nil {
+		return x.TimeFrom
+	}
+	return 0
+}
+
+func (x *QueryStatsByTimePeriodByDeveloperRequest) GetTimeTo() int64 {
+	if x != nil {
+		return x.TimeTo
+	}
+	return 0
+}
+
+type QueryStatsByTimePeriodByDeveloperResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Stats []*DeveloperStatsByTime `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"`
 }
 
-func (x *QueryAllEpochPerformanceSummaryRequest) Reset() {
-	*x = QueryAllEpochPerformanceSummaryRequest{}
+func (x *QueryStatsByTimePeriodByDeveloperResponse) Reset() {
+	*x = QueryStatsByTimePeriodByDeveloperResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[72]
+		mi := &file_inference_inference_query_proto_msgTypes[89]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllEpochPerformanceSummaryRequest) String() string {
+func (x *QueryStatsByTimePeriodByDeveloperResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllEpochPerformanceSummaryRequest) ProtoMessage() {}
+func (*QueryStatsByTimePeriodByDeveloperResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllEpochPerformanceSummaryRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllEpochPerformanceSummaryRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{72}
+// Deprecated: Use QueryStatsByTimePeriodByDeveloperResponse.ProtoReflect.Descriptor instead.
+func (*QueryStatsByTimePeriodByDeveloperResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{89}
 }
 
-func (x *QueryAllEpochPerformanceSummaryRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryStatsByTimePeriodByDeveloperResponse) GetStats() []*DeveloperStatsByTime {
 	if x != nil {
-		return x.Pagination
+		return x.Stats
 	}
 	return nil
 }
 
-type QueryAllEpochPerformanceSummaryResponse struct {
+type QueryStatsByDeveloperAndEpochBackwardsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochPerformanceSummary []*EpochPerformanceSummary `protobuf:"bytes,1,rep,name=epochPerformanceSummary,proto3" json:"epochPerformanceSummary,omitempty"`
-	Pagination              *v1beta1.PageResponse      `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Developer string `protobuf:"bytes,1,opt,name=developer,proto3" json:"developer,omitempty"`
+	EpochsN   int32  `protobuf:"varint,2,opt,name=epochs_n,json=epochsN,proto3" json:"epochs_n,omitempty"`
 }
-
-func (x *QueryAllEpochPerformanceSummaryResponse) Reset() {
-	*x = QueryAllEpochPerformanceSummaryResponse{}
+
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) Reset() {
+	*x = QueryStatsByDeveloperAndEpochBackwardsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[73]
+		mi := &file_inference_inference_query_proto_msgTypes[90]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllEpochPerformanceSummaryResponse) String() string {
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllEpochPerformanceSummaryResponse) ProtoMessage() {}
+func (*QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryAllEpochPerformanceSummaryResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllEpochPerformanceSummaryResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{73}
+// Deprecated: Use QueryStatsByDeveloperAndEpochBackwardsRequest.ProtoReflect.Descriptor instead.
+func (*QueryStatsByDeveloperAndEpochBackwardsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{90}
 }
 
-func (x *QueryAllEpochPerformanceSummaryResponse) GetEpochPerformanceSummary() []*EpochPerformanceSummary {
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) GetDeveloper() string {
 	if x != nil {
-		return x.EpochPerformanceSummary
+		return x.Developer
 	}
-	return nil
+	return ""
 }
 
-func (x *QueryAllEpochPerformanceSummaryResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) GetEpochsN() int32 {
 	if x != nil {
-		return x.Pagination
+		return x.EpochsN
 	}
-	return nil
+	return 0
 }
 
-type QueryHardwareNodesRequest struct {
+type QueryInferencesAndTokensStatsByEpochsBackwardsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	EpochsN int32 `protobuf:"varint,1,opt,name=epochs_n,json=epochsN,proto3" json:"epochs_n,omitempty"`
 }
 
-func (x *QueryHardwareNodesRequest) Reset() {
-	*x = QueryHardwareNodesRequest{}
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Reset() {
+	*x = QueryInferencesAndTokensStatsByEpochsBackwardsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[74]
+		mi := &file_inference_inference_query_proto_msgTypes[91]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryHardwareNodesRequest) String() string {
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryHardwareNodesRequest) ProtoMessage() {}
+func (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryHardwareNodesRequest.ProtoReflect.Descriptor instead.
-func (*QueryHardwareNodesRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{74}
+// Deprecated: Use QueryInferencesAndTokensStatsByEpochsBackwardsRequest.ProtoReflect.Descriptor instead.
+func (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{91}
 }
 
-func (x *QueryHardwareNodesRequest) GetParticipant() string {
+func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) GetEpochsN() int32 {
 	if x != nil {
-		return x.Participant
+		return x.EpochsN
 	}
-	return ""
+	return 0
 }
 
-type QueryHardwareNodesResponse struct {
+type QueryInferencesAndTokensStatsByTimePeriodRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Nodes *HardwareNodes `protobuf:"bytes,1,opt,name=nodes,proto3" json:"nodes,omitempty"`
+	TimeFrom int64 `protobuf:"varint,2,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
+	TimeTo   int64 `protobuf:"varint,3,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
 }
 
-func (x *QueryHardwareNodesResponse) Reset() {
-	*x = QueryHardwareNodesResponse{}
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) Reset() {
+	*x = QueryInferencesAndTokensStatsByTimePeriodRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[75]
+		mi := &file_inference_inference_query_proto_msgTypes[92]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryHardwareNodesResponse) String() string {
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryHardwareNodesResponse) ProtoMessage() {}
+func (*QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryHardwareNodesResponse.ProtoReflect.Descriptor instead.
-func (*QueryHardwareNodesResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{75}
+// Deprecated: Use QueryInferencesAndTokensStatsByTimePeriodRequest.ProtoReflect.Descriptor instead.
+func (*QueryInferencesAndTokensStatsByTimePeriodRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{92}
 }
 
-func (x *QueryHardwareNodesResponse) GetNodes() *HardwareNodes {
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) GetTimeFrom() int64 {
 	if x != nil {
-		return x.Nodes
+		return x.TimeFrom
 	}
-	return nil
+	return 0
 }
 
-type QueryHardwareNodesAllRequest struct {
+func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) GetTimeTo() int64 {
+	if x != nil {
+		return x.TimeTo
+	}
+	return 0
+}
+
+type QueryInferencesAndTokensStatsByModelsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	TimeFrom int64 `protobuf:"varint,2,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
+	TimeTo   int64 `protobuf:"varint,3,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
 }
 
-func (x *QueryHardwareNodesAllRequest) Reset() {
-	*x = QueryHardwareNodesAllRequest{}
+func (x *QueryInferencesAndTokensStatsByModelsRequest) Reset() {
+	*x = QueryInferencesAndTokensStatsByModelsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[76]
+		mi := &file_inference_inference_query_proto_msgTypes[93]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryHardwareNodesAllRequest) String() string {
+func (x *QueryInferencesAndTokensStatsByModelsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryHardwareNodesAllRequest) ProtoMessage() {}
+func (*QueryInferencesAndTokensStatsByModelsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryHardwareNodesAllRequest.ProtoReflect.Descriptor instead.
-func (*QueryHardwareNodesAllRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{76}
+// Deprecated: Use QueryInferencesAndTokensStatsByModelsRequest.ProtoReflect.Descriptor instead.
+func (*QueryInferencesAndTokensStatsByModelsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{93}
 }
 
-type QueryHardwareNodesAllResponse struct {
+func (x *QueryInferencesAndTokensStatsByModelsRequest) GetTimeFrom() int64 {
+	if x != nil {
+		return x.TimeFrom
+	}
+	return 0
+}
+
+func (x *QueryInferencesAndTokensStatsByModelsRequest) GetTimeTo() int64 {
+	if x != nil {
+		return x.TimeTo
+	}
+	return 0
+}
+
+type ModelStats struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Nodes []*HardwareNodes `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
+	Model      string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
+	AiTokens   int64  `protobuf:"varint,2,opt,name=ai_tokens,json=aiTokens,proto3" json:"ai_tokens,omitempty"`
+	Inferences int32  `protobuf:"varint,3,opt,name=inferences,proto3" json:"inferences,omitempty"`
 }
 
-func (x *QueryHardwareNodesAllResponse) Reset() {
-	*x = QueryHardwareNodesAllResponse{}
+func (x *ModelStats) Reset() {
+	*x = ModelStats{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[77]
+		mi := &file_inference_inference_query_proto_msgTypes[94]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryHardwareNodesAllResponse) String() string {
+func (x *ModelStats) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryHardwareNodesAllResponse) ProtoMessage() {}
+func (*ModelStats) ProtoMessage() {}
 
-// Deprecated: Use QueryHardwareNodesAllResponse.ProtoReflect.Descriptor instead.
-func (*QueryHardwareNodesAllResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{77}
+// Deprecated: Use ModelStats.ProtoReflect.Descriptor instead.
+func (*ModelStats) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{94}
 }
 
-func (x *QueryHardwareNodesAllResponse) GetNodes() []*HardwareNodes {
+func (x *ModelStats) GetModel() string {
 	if x != nil {
-		return x.Nodes
+		return x.Model
 	}
-	return nil
+	return ""
 }
 
-type QueryGetParticipantCurrentStatsRequest struct {
+func (x *ModelStats) GetAiTokens() int64 {
+	if x != nil {
+		return x.AiTokens
+	}
+	return 0
+}
+
+func (x *ModelStats) GetInferences() int32 {
+	if x != nil {
+		return x.Inferences
+	}
+	return 0
+}
+
+type QueryInferencesAndTokensStatsByModelsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParticipantId string `protobuf:"bytes,1,opt,name=participantId,proto3" json:"participantId,omitempty"`
+	StatsModels []*ModelStats `protobuf:"bytes,1,rep,name=stats_models,json=statsModels,proto3" json:"stats_models,omitempty"`
 }
 
-func (x *QueryGetParticipantCurrentStatsRequest) Reset() {
-	*x = QueryGetParticipantCurrentStatsRequest{}
+func (x *QueryInferencesAndTokensStatsByModelsResponse) Reset() {
+	*x = QueryInferencesAndTokensStatsByModelsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[78]
+		mi := &file_inference_inference_query_proto_msgTypes[95]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetParticipantCurrentStatsRequest) String() string {
+func (x *QueryInferencesAndTokensStatsByModelsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetParticipantCurrentStatsRequest) ProtoMessage() {}
+func (*QueryInferencesAndTokensStatsByModelsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetParticipantCurrentStatsRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetParticipantCurrentStatsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{78}
+// Deprecated: Use QueryInferencesAndTokensStatsByModelsResponse.ProtoReflect.Descriptor instead.
+func (*QueryInferencesAndTokensStatsByModelsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{95}
 }
 
-func (x *QueryGetParticipantCurrentStatsRequest) GetParticipantId() string {
+func (x *QueryInferencesAndTokensStatsByModelsResponse) GetStatsModels() []*ModelStats {
 	if x != nil {
-		return x.ParticipantId
+		return x.StatsModels
 	}
-	return ""
+	return nil
 }
 
-type QueryGetParticipantCurrentStatsResponse struct {
+type QueryInferencesAndTokensStatsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Weight     uint64 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty"`
-	Reputation int32  `protobuf:"varint,2,opt,name=reputation,proto3" json:"reputation,omitempty"`
+	AiTokens             int64 `protobuf:"varint,1,opt,name=ai_tokens,json=aiTokens,proto3" json:"ai_tokens,omitempty"`
+	Inferences           int32 `protobuf:"varint,2,opt,name=inferences,proto3" json:"inferences,omitempty"`
+	ActualInferencesCost int64 `protobuf:"varint,3,opt,name=actual_inferences_cost,json=actualInferencesCost,proto3" json:"actual_inferences_cost,omitempty"`
 }
 
-func (x *QueryGetParticipantCurrentStatsResponse) Reset() {
-	*x = QueryGetParticipantCurrentStatsResponse{}
+func (x *QueryInferencesAndTokensStatsResponse) Reset() {
+	*x = QueryInferencesAndTokensStatsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[79]
+		mi := &file_inference_inference_query_proto_msgTypes[96]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetParticipantCurrentStatsResponse) String() string {
+func (x *QueryInferencesAndTokensStatsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetParticipantCurrentStatsResponse) ProtoMessage() {}
+func (*QueryInferencesAndTokensStatsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetParticipantCurrentStatsResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetParticipantCurrentStatsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{79}
+// Deprecated: Use QueryInferencesAndTokensStatsResponse.ProtoReflect.Descriptor instead.
+func (*QueryInferencesAndTokensStatsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{96}
 }
 
-func (x *QueryGetParticipantCurrentStatsResponse) GetWeight() uint64 {
+func (x *QueryInferencesAndTokensStatsResponse) GetAiTokens() int64 {
 	if x != nil {
-		return x.Weight
+		return x.AiTokens
 	}
 	return 0
 }
 
-func (x *QueryGetParticipantCurrentStatsResponse) GetReputation() int32 {
+func (x *QueryInferencesAndTokensStatsResponse) GetInferences() int32 {
 	if x != nil {
-		return x.Reputation
+		return x.Inferences
 	}
 	return 0
 }
 
-type QueryGetAllParticipantCurrentStatsRequest struct {
+func (x *QueryInferencesAndTokensStatsResponse) GetActualInferencesCost() int64 {
+	if x != nil {
+		return x.ActualInferencesCost
+	}
+	return 0
+}
+
+type QueryCountAllParticipantsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 }
 
-func (x *QueryGetAllParticipantCurrentStatsRequest) Reset() {
-	*x = QueryGetAllParticipantCurrentStatsRequest{}
+func (x *QueryCountAllParticipantsRequest) Reset() {
+	*x = QueryCountAllParticipantsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[80]
+		mi := &file_inference_inference_query_proto_msgTypes[97]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetAllParticipantCurrentStatsRequest) String() string {
+func (x *QueryCountAllParticipantsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetAllParticipantCurrentStatsRequest) ProtoMessage() {}
+func (*QueryCountAllParticipantsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetAllParticipantCurrentStatsRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetAllParticipantCurrentStatsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{80}
+// Deprecated: Use QueryCountAllParticipantsRequest.ProtoReflect.Descriptor instead.
+func (*QueryCountAllParticipantsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{97}
 }
 
-type QueryGetAllParticipantCurrentStatsResponse struct {
+type QueryCountAllParticipantsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParticipantCurrentStats []*ParticipantCurrentStats `protobuf:"bytes,1,rep,name=participant_current_stats,json=participantCurrentStats,proto3" json:"participant_current_stats,omitempty"`
-	BlockHeight             int64                      `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
-	EpochId                 int64                      `protobuf:"varint,3,opt,name=epoch_id,json=epochId,proto3" json:"epoch_id,omitempty"`
+	Total int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
 }
 
-func (x *QueryGetAllParticipantCurrentStatsResponse) Reset() {
-	*x = QueryGetAllParticipantCurrentStatsResponse{}
+func (x *QueryCountAllParticipantsResponse) Reset() {
+	*x = QueryCountAllParticipantsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[81]
+		mi := &file_inference_inference_query_proto_msgTypes[98]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetAllParticipantCurrentStatsResponse) String() string {
+func (x *QueryCountAllParticipantsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetAllParticipantCurrentStatsResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryGetAllParticipantCurrentStatsResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetAllParticipantCurrentStatsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{81}
-}
-
-func (x *QueryGetAllParticipantCurrentStatsResponse) GetParticipantCurrentStats() []*ParticipantCurrentStats {
-	if x != nil {
-		return x.ParticipantCurrentStats
-	}
-	return nil
-}
+func (*QueryCountAllParticipantsResponse) ProtoMessage() {}
 
-func (x *QueryGetAllParticipantCurrentStatsResponse) GetBlockHeight() int64 {
-	if x != nil {
-		return x.BlockHeight
-	}
-	return 0
+// Deprecated: Use QueryCountAllParticipantsResponse.ProtoReflect.Descriptor instead.
+func (*QueryCountAllParticipantsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{98}
 }
 
-func (x *QueryGetAllParticipantCurrentStatsResponse) GetEpochId() int64 {
+func (x *QueryCountAllParticipantsResponse) GetTotal() int64 {
 	if x != nil {
-		return x.EpochId
+		return x.Total
 	}
 	return 0
 }
 
-type ParticipantCurrentStats struct {
+type QueryDebugStatsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	ParticipantId   string `protobuf:"bytes,1,opt,name=participant_id,json=participantId,proto3" json:"participant_id,omitempty"`
-	Weight          uint64 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
-	EffectiveWeight uint64 `protobuf:"varint,4,opt,name=effective_weight,json=effectiveWeight,proto3" json:"effective_weight,omitempty"`
-	CappedWeight    uint64 `protobuf:"varint,5,opt,name=capped_weight,json=cappedWeight,proto3" json:"capped_weight,omitempty"`
-	Reputation      int32  `protobuf:"varint,3,opt,name=reputation,proto3" json:"reputation,omitempty"`
 }
 
-func (x *ParticipantCurrentStats) Reset() {
-	*x = ParticipantCurrentStats{}
+func (x *QueryDebugStatsRequest) Reset() {
+	*x = QueryDebugStatsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[82]
+		mi := &file_inference_inference_query_proto_msgTypes[99]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ParticipantCurrentStats) String() string {
+func (x *QueryDebugStatsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ParticipantCurrentStats) ProtoMessage() {}
+func (*QueryDebugStatsRequest) ProtoMessage() {}
 
-// Deprecated: Use ParticipantCurrentStats.ProtoReflect.Descriptor instead.
-func (*ParticipantCurrentStats) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{82}
+// Deprecated: Use QueryDebugStatsRequest.ProtoReflect.Descriptor instead.
+func (*QueryDebugStatsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{99}
 }
 
-func (x *ParticipantCurrentStats) GetParticipantId() string {
-	if x != nil {
-		return x.ParticipantId
-	}
-	return ""
+type QueryDebugStatsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	StatsByTime  []*QueryDebugStatsResponse_TemporaryTimeStat  `protobuf:"bytes,1,rep,name=stats_by_time,json=statsByTime,proto3" json:"stats_by_time,omitempty"`
+	StatsByEpoch []*QueryDebugStatsResponse_TemporaryEpochStat `protobuf:"bytes,2,rep,name=stats_by_epoch,json=statsByEpoch,proto3" json:"stats_by_epoch,omitempty"`
 }
 
-func (x *ParticipantCurrentStats) GetWeight() uint64 {
-	if x != nil {
-		return x.Weight
+func (x *QueryDebugStatsResponse) Reset() {
+	*x = QueryDebugStatsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[100]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return 0
 }
 
-func (x *ParticipantCurrentStats) GetEffectiveWeight() uint64 {
-	if x != nil {
-		return x.EffectiveWeight
-	}
-	return 0
+func (x *QueryDebugStatsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (x *ParticipantCurrentStats) GetCappedWeight() uint64 {
+func (*QueryDebugStatsResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryDebugStatsResponse.ProtoReflect.Descriptor instead.
+func (*QueryDebugStatsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{100}
+}
+
+func (x *QueryDebugStatsResponse) GetStatsByTime() []*QueryDebugStatsResponse_TemporaryTimeStat {
 	if x != nil {
-		return x.CappedWeight
+		return x.StatsByTime
 	}
-	return 0
+	return nil
 }
 
-func (x *ParticipantCurrentStats) GetReputation() int32 {
+func (x *QueryDebugStatsResponse) GetStatsByEpoch() []*QueryDebugStatsResponse_TemporaryEpochStat {
 	if x != nil {
-		return x.Reputation
+		return x.StatsByEpoch
 	}
-	return 0
+	return nil
 }
 
-type ParticipantFullStats struct {
+type QueryGetMinimumValidationAverageRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	AccountAddress           string `protobuf:"bytes,1,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"`
-	OperatorAddress          string `protobuf:"bytes,2,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"`
-	Reputation               int32  `protobuf:"varint,3,opt,name=reputation,proto3" json:"reputation,omitempty"`
-	EarnedCoinsCurrentEpoch  uint64 `protobuf:"varint,4,opt,name=earned_coins_current_epoch,json=earnedCoinsCurrentEpoch,proto3" json:"earned_coins_current_epoch,omitempty"`
-	RewardedCoinsLatestEpoch uint64 `protobuf:"varint,5,opt,name=rewarded_coins_latest_epoch,json=rewardedCoinsLatestEpoch,proto3" json:"rewarded_coins_latest_epoch,omitempty"`
-	EpochsCompleted          uint32 `protobuf:"varint,6,opt,name=epochs_completed,json=epochsCompleted,proto3" json:"epochs_completed,omitempty"`
 }
 
-func (x *ParticipantFullStats) Reset() {
-	*x = ParticipantFullStats{}
+func (x *QueryGetMinimumValidationAverageRequest) Reset() {
+	*x = QueryGetMinimumValidationAverageRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[83]
+		mi := &file_inference_inference_query_proto_msgTypes[101]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ParticipantFullStats) String() string {
+func (x *QueryGetMinimumValidationAverageRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ParticipantFullStats) ProtoMessage() {}
+func (*QueryGetMinimumValidationAverageRequest) ProtoMessage() {}
 
-// Deprecated: Use ParticipantFullStats.ProtoReflect.Descriptor instead.
-func (*ParticipantFullStats) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{83}
+// Deprecated: Use QueryGetMinimumValidationAverageRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetMinimumValidationAverageRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{101}
 }
 
-func (x *ParticipantFullStats) GetAccountAddress() string {
-	if x != nil {
-		return x.AccountAddress
-	}
-	return ""
+type QueryGetMinimumValidationAverageResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	TrafficBasis             uint64 `protobuf:"varint,1,opt,name=traffic_basis,json=trafficBasis,proto3" json:"traffic_basis,omitempty"`
+	MinimumValidationAverage string `protobuf:"bytes,2,opt,name=minimum_validation_average,json=minimumValidationAverage,proto3" json:"minimum_validation_average,omitempty"`
+	BlockHeight              uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *ParticipantFullStats) GetOperatorAddress() string {
-	if x != nil {
-		return x.OperatorAddress
+func (x *QueryGetMinimumValidationAverageResponse) Reset() {
+	*x = QueryGetMinimumValidationAverageResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[102]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return ""
 }
 
-func (x *ParticipantFullStats) GetReputation() int32 {
-	if x != nil {
-		return x.Reputation
-	}
-	return 0
+func (x *QueryGetMinimumValidationAverageResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (x *ParticipantFullStats) GetEarnedCoinsCurrentEpoch() uint64 {
+func (*QueryGetMinimumValidationAverageResponse) ProtoMessage() {}
+
+// Deprecated: Use QueryGetMinimumValidationAverageResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetMinimumValidationAverageResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{102}
+}
+
+func (x *QueryGetMinimumValidationAverageResponse) GetTrafficBasis() uint64 {
 	if x != nil {
-		return x.EarnedCoinsCurrentEpoch
+		return x.TrafficBasis
 	}
 	return 0
 }
 
-func (x *ParticipantFullStats) GetRewardedCoinsLatestEpoch() uint64 {
+func (x *QueryGetMinimumValidationAverageResponse) GetMinimumValidationAverage() string {
 	if x != nil {
-		return x.RewardedCoinsLatestEpoch
+		return x.MinimumValidationAverage
 	}
-	return 0
+	return ""
 }
 
-func (x *ParticipantFullStats) GetEpochsCompleted() uint32 {
+func (x *QueryGetMinimumValidationAverageResponse) GetBlockHeight() uint64 {
 	if x != nil {
-		return x.EpochsCompleted
+		return x.BlockHeight
 	}
 	return 0
 }
 
-type QueryParticipantsFullStatsRequest struct {
+type QueryGetPartialUpgradeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
 }
 
-func (x *QueryParticipantsFullStatsRequest) Reset() {
-	*x = QueryParticipantsFullStatsRequest{}
+func (x *QueryGetPartialUpgradeRequest) Reset() {
+	*x = QueryGetPartialUpgradeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[84]
+		mi := &file_inference_inference_query_proto_msgTypes[103]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryParticipantsFullStatsRequest) String() string {
+func (x *QueryGetPartialUpgradeRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryParticipantsFullStatsRequest) ProtoMessage() {}
+func (*QueryGetPartialUpgradeRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryParticipantsFullStatsRequest.ProtoReflect.Descriptor instead.
-func (*QueryParticipantsFullStatsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{84}
+// Deprecated: Use QueryGetPartialUpgradeRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetPartialUpgradeRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{103}
 }
 
-type QueryParticipantsFullStatsResponse struct {
+func (x *QueryGetPartialUpgradeRequest) GetHeight() uint64 {
+	if x != nil {
+		return x.Height
+	}
+	return 0
+}
+
+type QueryGetPartialUpgradeResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParticipantsStats []*ParticipantFullStats `protobuf:"bytes,1,rep,name=participants_stats,json=participantsStats,proto3" json:"participants_stats,omitempty"`
+	PartialUpgrade *PartialUpgrade `protobuf:"bytes,1,opt,name=partialUpgrade,proto3" json:"partialUpgrade,omitempty"`
 }
 
-func (x *QueryParticipantsFullStatsResponse) Reset() {
-	*x = QueryParticipantsFullStatsResponse{}
+func (x *QueryGetPartialUpgradeResponse) Reset() {
+	*x = QueryGetPartialUpgradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[85]
+		mi := &file_inference_inference_query_proto_msgTypes[104]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryParticipantsFullStatsResponse) String() string {
+func (x *QueryGetPartialUpgradeResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryParticipantsFullStatsResponse) ProtoMessage() {}
+func (*QueryGetPartialUpgradeResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryParticipantsFullStatsResponse.ProtoReflect.Descriptor instead.
-func (*QueryParticipantsFullStatsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{85}
+// Deprecated: Use QueryGetPartialUpgradeResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetPartialUpgradeResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{104}
 }
 
-func (x *QueryParticipantsFullStatsResponse) GetParticipantsStats() []*ParticipantFullStats {
+func (x *QueryGetPartialUpgradeResponse) GetPartialUpgrade() *PartialUpgrade {
 	if x != nil {
-		return x.ParticipantsStats
+		return x.PartialUpgrade
 	}
 	return nil
 }
 
-type QueryStatsByTimePeriodByDeveloperRequest struct {
+type QueryAllPartialUpgradeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Developer string `protobuf:"bytes,1,opt,name=developer,proto3" json:"developer,omitempty"`
-	TimeFrom  int64  `protobuf:"varint,2,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
-	TimeTo    int64  `protobuf:"varint,3,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperRequest) Reset() {
-	*x = QueryStatsByTimePeriodByDeveloperRequest{}
+func (x *QueryAllPartialUpgradeRequest) Reset() {
+	*x = QueryAllPartialUpgradeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[86]
+		mi := &file_inference_inference_query_proto_msgTypes[105]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperRequest) String() string {
+func (x *QueryAllPartialUpgradeRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryStatsByTimePeriodByDeveloperRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryStatsByTimePeriodByDeveloperRequest.ProtoReflect.Descriptor instead.
-func (*QueryStatsByTimePeriodByDeveloperRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{86}
-}
-
-func (x *QueryStatsByTimePeriodByDeveloperRequest) GetDeveloper() string {
-	if x != nil {
-		return x.Developer
-	}
-	return ""
-}
+func (*QueryAllPartialUpgradeRequest) ProtoMessage() {}
 
-func (x *QueryStatsByTimePeriodByDeveloperRequest) GetTimeFrom() int64 {
-	if x != nil {
-		return x.TimeFrom
-	}
-	return 0
+// Deprecated: Use QueryAllPartialUpgradeRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllPartialUpgradeRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{105}
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperRequest) GetTimeTo() int64 {
+func (x *QueryAllPartialUpgradeRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.TimeTo
+		return x.Pagination
 	}
-	return 0
+	return nil
 }
 
-type QueryStatsByTimePeriodByDeveloperResponse struct {
+type QueryAllPartialUpgradeResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Stats []*DeveloperStatsByTime `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"`
+	PartialUpgrade []*PartialUpgrade     `protobuf:"bytes,1,rep,name=partialUpgrade,proto3" json:"partialUpgrade,omitempty"`
+	Pagination     *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperResponse) Reset() {
-	*x = QueryStatsByTimePeriodByDeveloperResponse{}
+func (x *QueryAllPartialUpgradeResponse) Reset() {
+	*x = QueryAllPartialUpgradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[87]
+		mi := &file_inference_inference_query_proto_msgTypes[106]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperResponse) String() string {
+func (x *QueryAllPartialUpgradeResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryStatsByTimePeriodByDeveloperResponse) ProtoMessage() {}
+func (*QueryAllPartialUpgradeResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryStatsByTimePeriodByDeveloperResponse.ProtoReflect.Descriptor instead.
-func (*QueryStatsByTimePeriodByDeveloperResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{87}
+// Deprecated: Use QueryAllPartialUpgradeResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllPartialUpgradeResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{106}
 }
 
-func (x *QueryStatsByTimePeriodByDeveloperResponse) GetStats() []*DeveloperStatsByTime {
+func (x *QueryAllPartialUpgradeResponse) GetPartialUpgrade() []*PartialUpgrade {
 	if x != nil {
-		return x.Stats
+		return x.PartialUpgrade
 	}
 	return nil
 }
 
-type QueryStatsByDeveloperAndEpochBackwardsRequest struct {
+func (x *QueryAllPartialUpgradeResponse) GetPagination() *v1beta1.PageResponse {
+	if x != nil {
+		return x.Pagination
+	}
+	return nil
+}
+
+type QueryGetBridgeTransactionRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Developer string `protobuf:"bytes,1,opt,name=developer,proto3" json:"developer,omitempty"`
-	EpochsN   int32  `protobuf:"varint,2,opt,name=epochs_n,json=epochsN,proto3" json:"epochs_n,omitempty"`
+	OriginChain  string `protobuf:"bytes,1,opt,name=origin_chain,json=originChain,proto3" json:"origin_chain,omitempty"`
+	BlockNumber  string `protobuf:"bytes,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	ReceiptIndex string `protobuf:"bytes,3,opt,name=receipt_index,json=receiptIndex,proto3" json:"receipt_index,omitempty"`
 }
 
-func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) Reset() {
-	*x = QueryStatsByDeveloperAndEpochBackwardsRequest{}
+func (x *QueryGetBridgeTransactionRequest) Reset() {
+	*x = QueryGetBridgeTransactionRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[88]
+		mi := &file_inference_inference_query_proto_msgTypes[107]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) String() string {
+func (x *QueryGetBridgeTransactionRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMessage() {}
+func (*QueryGetBridgeTransactionRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryStatsByDeveloperAndEpochBackwardsRequest.ProtoReflect.Descriptor instead.
-func (*QueryStatsByDeveloperAndEpochBackwardsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{88}
+// Deprecated: Use QueryGetBridgeTransactionRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetBridgeTransactionRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{107}
 }
 
-func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) GetDeveloper() string {
+func (x *QueryGetBridgeTransactionRequest) GetOriginChain() string {
 	if x != nil {
-		return x.Developer
+		return x.OriginChain
 	}
 	return ""
 }
 
-func (x *QueryStatsByDeveloperAndEpochBackwardsRequest) GetEpochsN() int32 {
+func (x *QueryGetBridgeTransactionRequest) GetBlockNumber() string {
 	if x != nil {
-		return x.EpochsN
+		return x.BlockNumber
 	}
-	return 0
+	return ""
 }
 
-type QueryInferencesAndTokensStatsByEpochsBackwardsRequest struct {
+func (x *QueryGetBridgeTransactionRequest) GetReceiptIndex() string {
+	if x != nil {
+		return x.ReceiptIndex
+	}
+	return ""
+}
+
+type QueryGetBridgeTransactionResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochsN int32 `protobuf:"varint,1,opt,name=epochs_n,json=epochsN,proto3" json:"epochs_n,omitempty"`
+	BridgeTransactions []*BridgeTransaction `protobuf:"bytes,1,rep,name=bridgeTransactions,proto3" json:"bridgeTransactions,omitempty"`
 }
 
-func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Reset() {
-	*x = QueryInferencesAndTokensStatsByEpochsBackwardsRequest{}
+func (x *QueryGetBridgeTransactionResponse) Reset() {
+	*x = QueryGetBridgeTransactionResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[89]
+		mi := &file_inference_inference_query_proto_msgTypes[108]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) String() string {
+func (x *QueryGetBridgeTransactionResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoMessage() {}
+func (*QueryGetBridgeTransactionResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryInferencesAndTokensStatsByEpochsBackwardsRequest.ProtoReflect.Descriptor instead.
-func (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{89}
+// Deprecated: Use QueryGetBridgeTransactionResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetBridgeTransactionResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{108}
 }
 
-func (x *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) GetEpochsN() int32 {
+func (x *QueryGetBridgeTransactionResponse) GetBridgeTransactions() []*BridgeTransaction {
 	if x != nil {
-		return x.EpochsN
+		return x.BridgeTransactions
 	}
-	return 0
+	return nil
 }
 
-type QueryInferencesAndTokensStatsByTimePeriodRequest struct {
+type QueryAllBridgeTransactionsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	TimeFrom int64 `protobuf:"varint,2,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
-	TimeTo   int64 `protobuf:"varint,3,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) Reset() {
-	*x = QueryInferencesAndTokensStatsByTimePeriodRequest{}
+func (x *QueryAllBridgeTransactionsRequest) Reset() {
+	*x = QueryAllBridgeTransactionsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[90]
+		mi := &file_inference_inference_query_proto_msgTypes[109]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) String() string {
+func (x *QueryAllBridgeTransactionsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryInferencesAndTokensStatsByTimePeriodRequest.ProtoReflect.Descriptor instead.
-func (*QueryInferencesAndTokensStatsByTimePeriodRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{90}
-}
+func (*QueryAllBridgeTransactionsRequest) ProtoMessage() {}
 
-func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) GetTimeFrom() int64 {
-	if x != nil {
-		return x.TimeFrom
-	}
-	return 0
+// Deprecated: Use QueryAllBridgeTransactionsRequest.ProtoReflect.Descriptor instead.
+func (*QueryAllBridgeTransactionsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{109}
 }
 
-func (x *QueryInferencesAndTokensStatsByTimePeriodRequest) GetTimeTo() int64 {
+func (x *QueryAllBridgeTransactionsRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.TimeTo
+		return x.Pagination
 	}
-	return 0
+	return nil
 }
 
-type QueryInferencesAndTokensStatsByModelsRequest struct {
+type QueryAllBridgeTransactionsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	TimeFrom int64 `protobuf:"varint,2,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
-	TimeTo   int64 `protobuf:"varint,3,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
+	BridgeTransactions []*BridgeTransaction  `protobuf:"bytes,1,rep,name=bridgeTransactions,proto3" json:"bridgeTransactions,omitempty"`
+	Pagination         *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsRequest) Reset() {
-	*x = QueryInferencesAndTokensStatsByModelsRequest{}
+func (x *QueryAllBridgeTransactionsResponse) Reset() {
+	*x = QueryAllBridgeTransactionsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[91]
+		mi := &file_inference_inference_query_proto_msgTypes[110]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsRequest) String() string {
+func (x *QueryAllBridgeTransactionsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryInferencesAndTokensStatsByModelsRequest) ProtoMessage() {}
+func (*QueryAllBridgeTransactionsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryInferencesAndTokensStatsByModelsRequest.ProtoReflect.Descriptor instead.
-func (*QueryInferencesAndTokensStatsByModelsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{91}
+// Deprecated: Use QueryAllBridgeTransactionsResponse.ProtoReflect.Descriptor instead.
+func (*QueryAllBridgeTransactionsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{110}
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsRequest) GetTimeFrom() int64 {
+func (x *QueryAllBridgeTransactionsResponse) GetBridgeTransactions() []*BridgeTransaction {
 	if x != nil {
-		return x.TimeFrom
+		return x.BridgeTransactions
 	}
-	return 0
+	return nil
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsRequest) GetTimeTo() int64 {
+func (x *QueryAllBridgeTransactionsResponse) GetPagination() *v1beta1.PageResponse {
 	if x != nil {
-		return x.TimeTo
+		return x.Pagination
 	}
-	return 0
+	return nil
 }
 
-type ModelStats struct {
+type WrappedTokenBalance struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Model      string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`
-	AiTokens   int64  `protobuf:"varint,2,opt,name=ai_tokens,json=aiTokens,proto3" json:"ai_tokens,omitempty"`
-	Inferences int32  `protobuf:"varint,3,opt,name=inferences,proto3" json:"inferences,omitempty"`
+	TokenInfo        *BridgeWrappedTokenContract `protobuf:"bytes,1,opt,name=token_info,json=tokenInfo,proto3" json:"token_info,omitempty"`
+	Symbol           string                      `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	Balance          string                      `protobuf:"bytes,3,opt,name=balance,proto3" json:"balance,omitempty"` // current balance (as string to handle large numbers)
+	Decimals         string                      `protobuf:"bytes,4,opt,name=decimals,proto3" json:"decimals,omitempty"`
+	FormattedBalance string                      `protobuf:"bytes,5,opt,name=formatted_balance,json=formattedBalance,proto3" json:"formatted_balance,omitempty"` // human-readable balance (e.g. "1000.50")
 }
 
-func (x *ModelStats) Reset() {
-	*x = ModelStats{}
+func (x *WrappedTokenBalance) Reset() {
+	*x = WrappedTokenBalance{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[92]
+		mi := &file_inference_inference_query_proto_msgTypes[111]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ModelStats) String() string {
+func (x *WrappedTokenBalance) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ModelStats) ProtoMessage() {}
+func (*WrappedTokenBalance) ProtoMessage() {}
 
-// Deprecated: Use ModelStats.ProtoReflect.Descriptor instead.
-func (*ModelStats) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{92}
+// Deprecated: Use WrappedTokenBalance.ProtoReflect.Descriptor instead.
+func (*WrappedTokenBalance) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{111}
 }
 
-func (x *ModelStats) GetModel() string {
+func (x *WrappedTokenBalance) GetTokenInfo() *BridgeWrappedTokenContract {
 	if x != nil {
-		return x.Model
+		return x.TokenInfo
 	}
-	return ""
+	return nil
 }
 
-func (x *ModelStats) GetAiTokens() int64 {
+func (x *WrappedTokenBalance) GetSymbol() string {
 	if x != nil {
-		return x.AiTokens
+		return x.Symbol
 	}
-	return 0
+	return ""
 }
 
-func (x *ModelStats) GetInferences() int32 {
+func (x *WrappedTokenBalance) GetBalance() string {
 	if x != nil {
-		return x.Inferences
+		return x.Balance
 	}
-	return 0
-}
-
-type QueryInferencesAndTokensStatsByModelsResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	StatsModels []*ModelStats `protobuf:"bytes,1,rep,name=stats_models,json=statsModels,proto3" json:"stats_models,omitempty"`
+	return ""
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsResponse) Reset() {
-	*x = QueryInferencesAndTokensStatsByModelsResponse{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[93]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+func (x *WrappedTokenBalance) GetDecimals() string {
+	if x != nil {
+		return x.Decimals
 	}
+	return ""
 }
 
-func (x *QueryInferencesAndTokensStatsByModelsResponse) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*QueryInferencesAndTokensStatsByModelsResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryInferencesAndTokensStatsByModelsResponse.ProtoReflect.Descriptor instead.
-func (*QueryInferencesAndTokensStatsByModelsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{93}
-}
-
-func (x *QueryInferencesAndTokensStatsByModelsResponse) GetStatsModels() []*ModelStats {
+func (x *WrappedTokenBalance) GetFormattedBalance() string {
 	if x != nil {
-		return x.StatsModels
+		return x.FormattedBalance
 	}
-	return nil
+	return ""
 }
 
-type QueryInferencesAndTokensStatsResponse struct {
+type QueryWrappedTokenBalancesRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	AiTokens             int64 `protobuf:"varint,1,opt,name=ai_tokens,json=aiTokens,proto3" json:"ai_tokens,omitempty"`
-	Inferences           int32 `protobuf:"varint,2,opt,name=inferences,proto3" json:"inferences,omitempty"`
-	ActualInferencesCost int64 `protobuf:"varint,3,opt,name=actual_inferences_cost,json=actualInferencesCost,proto3" json:"actual_inferences_cost,omitempty"`
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
 }
 
-func (x *QueryInferencesAndTokensStatsResponse) Reset() {
-	*x = QueryInferencesAndTokensStatsResponse{}
+func (x *QueryWrappedTokenBalancesRequest) Reset() {
+	*x = QueryWrappedTokenBalancesRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[94]
+		mi := &file_inference_inference_query_proto_msgTypes[112]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryInferencesAndTokensStatsResponse) String() string {
+func (x *QueryWrappedTokenBalancesRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryInferencesAndTokensStatsResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryInferencesAndTokensStatsResponse.ProtoReflect.Descriptor instead.
-func (*QueryInferencesAndTokensStatsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{94}
-}
-
-func (x *QueryInferencesAndTokensStatsResponse) GetAiTokens() int64 {
-	if x != nil {
-		return x.AiTokens
-	}
-	return 0
-}
+func (*QueryWrappedTokenBalancesRequest) ProtoMessage() {}
 
-func (x *QueryInferencesAndTokensStatsResponse) GetInferences() int32 {
-	if x != nil {
-		return x.Inferences
-	}
-	return 0
+// Deprecated: Use QueryWrappedTokenBalancesRequest.ProtoReflect.Descriptor instead.
+func (*QueryWrappedTokenBalancesRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{112}
 }
 
-func (x *QueryInferencesAndTokensStatsResponse) GetActualInferencesCost() int64 {
+func (x *QueryWrappedTokenBalancesRequest) GetAddress() string {
 	if x != nil {
-		return x.ActualInferencesCost
+		return x.Address
 	}
-	return 0
+	return ""
 }
 
-type QueryCountAllParticipantsRequest struct {
+type QueryWrappedTokenBalancesResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Balances []*WrappedTokenBalance `protobuf:"bytes,1,rep,name=balances,proto3" json:"balances,omitempty"`
 }
 
-func (x *QueryCountAllParticipantsRequest) Reset() {
-	*x = QueryCountAllParticipantsRequest{}
+func (x *QueryWrappedTokenBalancesResponse) Reset() {
+	*x = QueryWrappedTokenBalancesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[95]
+		mi := &file_inference_inference_query_proto_msgTypes[113]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCountAllParticipantsRequest) String() string {
+func (x *QueryWrappedTokenBalancesResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCountAllParticipantsRequest) ProtoMessage() {}
+func (*QueryWrappedTokenBalancesResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryCountAllParticipantsRequest.ProtoReflect.Descriptor instead.
-func (*QueryCountAllParticipantsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{95}
+// Deprecated: Use QueryWrappedTokenBalancesResponse.ProtoReflect.Descriptor instead.
+func (*QueryWrappedTokenBalancesResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{113}
 }
 
-type QueryCountAllParticipantsResponse struct {
+func (x *QueryWrappedTokenBalancesResponse) GetBalances() []*WrappedTokenBalance {
+	if x != nil {
+		return x.Balances
+	}
+	return nil
+}
+
+type QueryBridgeAddressesByChainRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Total int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
+	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
 }
 
-func (x *QueryCountAllParticipantsResponse) Reset() {
-	*x = QueryCountAllParticipantsResponse{}
+func (x *QueryBridgeAddressesByChainRequest) Reset() {
+	*x = QueryBridgeAddressesByChainRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[96]
+		mi := &file_inference_inference_query_proto_msgTypes[114]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCountAllParticipantsResponse) String() string {
+func (x *QueryBridgeAddressesByChainRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCountAllParticipantsResponse) ProtoMessage() {}
+func (*QueryBridgeAddressesByChainRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryCountAllParticipantsResponse.ProtoReflect.Descriptor instead.
-func (*QueryCountAllParticipantsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{96}
+// Deprecated: Use QueryBridgeAddressesByChainRequest.ProtoReflect.Descriptor instead.
+func (*QueryBridgeAddressesByChainRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{114}
 }
 
-func (x *QueryCountAllParticipantsResponse) GetTotal() int64 {
+func (x *QueryBridgeAddressesByChainRequest) GetChainId() string {
 	if x != nil {
-		return x.Total
+		return x.ChainId
 	}
-	return 0
+	return ""
 }
 
-type QueryDebugStatsRequest struct {
+type QueryBridgeAddressesByChainResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Addresses []*BridgeContractAddress `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
 }
 
-func (x *QueryDebugStatsRequest) Reset() {
-	*x = QueryDebugStatsRequest{}
+func (x *QueryBridgeAddressesByChainResponse) Reset() {
+	*x = QueryBridgeAddressesByChainResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[97]
+		mi := &file_inference_inference_query_proto_msgTypes[115]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryDebugStatsRequest) String() string {
+func (x *QueryBridgeAddressesByChainResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryDebugStatsRequest) ProtoMessage() {}
+func (*QueryBridgeAddressesByChainResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryDebugStatsRequest.ProtoReflect.Descriptor instead.
-func (*QueryDebugStatsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{97}
+// Deprecated: Use QueryBridgeAddressesByChainResponse.ProtoReflect.Descriptor instead.
+func (*QueryBridgeAddressesByChainResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{115}
 }
 
-type QueryDebugStatsResponse struct {
+func (x *QueryBridgeAddressesByChainResponse) GetAddresses() []*BridgeContractAddress {
+	if x != nil {
+		return x.Addresses
+	}
+	return nil
+}
+
+type QueryValidateWrappedTokenForTradeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	StatsByTime  []*QueryDebugStatsResponse_TemporaryTimeStat  `protobuf:"bytes,1,rep,name=stats_by_time,json=statsByTime,proto3" json:"stats_by_time,omitempty"`
-	StatsByEpoch []*QueryDebugStatsResponse_TemporaryEpochStat `protobuf:"bytes,2,rep,name=stats_by_epoch,json=statsByEpoch,proto3" json:"stats_by_epoch,omitempty"`
+	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
 }
 
-func (x *QueryDebugStatsResponse) Reset() {
-	*x = QueryDebugStatsResponse{}
+func (x *QueryValidateWrappedTokenForTradeRequest) Reset() {
+	*x = QueryValidateWrappedTokenForTradeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[98]
+		mi := &file_inference_inference_query_proto_msgTypes[116]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryDebugStatsResponse) String() string {
+func (x *QueryValidateWrappedTokenForTradeRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryDebugStatsResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryDebugStatsResponse.ProtoReflect.Descriptor instead.
-func (*QueryDebugStatsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{98}
-}
+func (*QueryValidateWrappedTokenForTradeRequest) ProtoMessage() {}
 
-func (x *QueryDebugStatsResponse) GetStatsByTime() []*QueryDebugStatsResponse_TemporaryTimeStat {
-	if x != nil {
-		return x.StatsByTime
-	}
-	return nil
+// Deprecated: Use QueryValidateWrappedTokenForTradeRequest.ProtoReflect.Descriptor instead.
+func (*QueryValidateWrappedTokenForTradeRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{116}
 }
 
-func (x *QueryDebugStatsResponse) GetStatsByEpoch() []*QueryDebugStatsResponse_TemporaryEpochStat {
+func (x *QueryValidateWrappedTokenForTradeRequest) GetContractAddress() string {
 	if x != nil {
-		return x.StatsByEpoch
+		return x.ContractAddress
 	}
-	return nil
+	return ""
 }
 
-type QueryGetMinimumValidationAverageRequest struct {
+type QueryValidateWrappedTokenForTradeResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	IsValid_ bool `protobuf:"varint,1,opt,name=is_valid,json=isValid,proto3" json:"is_valid,omitempty"`
 }
 
-func (x *QueryGetMinimumValidationAverageRequest) Reset() {
-	*x = QueryGetMinimumValidationAverageRequest{}
+func (x *QueryValidateWrappedTokenForTradeResponse) Reset() {
+	*x = QueryValidateWrappedTokenForTradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[99]
+		mi := &file_inference_inference_query_proto_msgTypes[117]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetMinimumValidationAverageRequest) String() string {
+func (x *QueryValidateWrappedTokenForTradeResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetMinimumValidationAverageRequest) ProtoMessage() {}
+func (*QueryValidateWrappedTokenForTradeResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetMinimumValidationAverageRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetMinimumValidationAverageRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{99}
+// Deprecated: Use QueryValidateWrappedTokenForTradeResponse.ProtoReflect.Descriptor instead.
+func (*QueryValidateWrappedTokenForTradeResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{117}
 }
 
-type QueryGetMinimumValidationAverageResponse struct {
+func (x *QueryValidateWrappedTokenForTradeResponse) GetIsValid_() bool {
+	if x != nil {
+		return x.IsValid_
+	}
+	return false
+}
+
+type QueryValidateIbcTokenForTradeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	TrafficBasis             uint64 `protobuf:"varint,1,opt,name=traffic_basis,json=trafficBasis,proto3" json:"traffic_basis,omitempty"`
-	MinimumValidationAverage string `protobuf:"bytes,2,opt,name=minimum_validation_average,json=minimumValidationAverage,proto3" json:"minimum_validation_average,omitempty"`
-	BlockHeight              uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	IbcDenom string `protobuf:"bytes,1,opt,name=ibc_denom,json=ibcDenom,proto3" json:"ibc_denom,omitempty"`
 }
 
-func (x *QueryGetMinimumValidationAverageResponse) Reset() {
-	*x = QueryGetMinimumValidationAverageResponse{}
+func (x *QueryValidateIbcTokenForTradeRequest) Reset() {
+	*x = QueryValidateIbcTokenForTradeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[100]
+		mi := &file_inference_inference_query_proto_msgTypes[118]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetMinimumValidationAverageResponse) String() string {
+func (x *QueryValidateIbcTokenForTradeRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetMinimumValidationAverageResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryGetMinimumValidationAverageResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetMinimumValidationAverageResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{100}
-}
+func (*QueryValidateIbcTokenForTradeRequest) ProtoMessage() {}
 
-func (x *QueryGetMinimumValidationAverageResponse) GetTrafficBasis() uint64 {
-	if x != nil {
-		return x.TrafficBasis
-	}
-	return 0
+// Deprecated: Use QueryValidateIbcTokenForTradeRequest.ProtoReflect.Descriptor instead.
+func (*QueryValidateIbcTokenForTradeRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{118}
 }
 
-func (x *QueryGetMinimumValidationAverageResponse) GetMinimumValidationAverage() string {
+func (x *QueryValidateIbcTokenForTradeRequest) GetIbcDenom() string {
 	if x != nil {
-		return x.MinimumValidationAverage
+		return x.IbcDenom
 	}
 	return ""
 }
 
-func (x *QueryGetMinimumValidationAverageResponse) GetBlockHeight() uint64 {
-	if x != nil {
-		return x.BlockHeight
-	}
-	return 0
-}
-
-type QueryGetPartialUpgradeRequest struct {
+type QueryValidateIbcTokenForTradeResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	IsValid_ bool   `protobuf:"varint,1,opt,name=is_valid,json=isValid,proto3" json:"is_valid,omitempty"`
+	Decimals uint32 `protobuf:"varint,2,opt,name=decimals,proto3" json:"decimals,omitempty"`
 }
 
-func (x *QueryGetPartialUpgradeRequest) Reset() {
-	*x = QueryGetPartialUpgradeRequest{}
+func (x *QueryValidateIbcTokenForTradeResponse) Reset() {
+	*x = QueryValidateIbcTokenForTradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[101]
+		mi := &file_inference_inference_query_proto_msgTypes[119]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetPartialUpgradeRequest) String() string {
+func (x *QueryValidateIbcTokenForTradeResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetPartialUpgradeRequest) ProtoMessage() {}
+func (*QueryValidateIbcTokenForTradeResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetPartialUpgradeRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetPartialUpgradeRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{101}
+// Deprecated: Use QueryValidateIbcTokenForTradeResponse.ProtoReflect.Descriptor instead.
+func (*QueryValidateIbcTokenForTradeResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{119}
 }
 
-func (x *QueryGetPartialUpgradeRequest) GetHeight() uint64 {
+func (x *QueryValidateIbcTokenForTradeResponse) GetIsValid_() bool {
+	if x != nil {
+		return x.IsValid_
+	}
+	return false
+}
+
+func (x *QueryValidateIbcTokenForTradeResponse) GetDecimals() uint32 {
 	if x != nil {
-		return x.Height
+		return x.Decimals
 	}
 	return 0
 }
 
-type QueryGetPartialUpgradeResponse struct {
+type QueryLiquidityPoolRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	PartialUpgrade *PartialUpgrade `protobuf:"bytes,1,opt,name=partialUpgrade,proto3" json:"partialUpgrade,omitempty"`
 }
 
-func (x *QueryGetPartialUpgradeResponse) Reset() {
-	*x = QueryGetPartialUpgradeResponse{}
+func (x *QueryLiquidityPoolRequest) Reset() {
+	*x = QueryLiquidityPoolRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[102]
+		mi := &file_inference_inference_query_proto_msgTypes[120]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetPartialUpgradeResponse) String() string {
+func (x *QueryLiquidityPoolRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetPartialUpgradeResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryGetPartialUpgradeResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetPartialUpgradeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{102}
-}
+func (*QueryLiquidityPoolRequest) ProtoMessage() {}
 
-func (x *QueryGetPartialUpgradeResponse) GetPartialUpgrade() *PartialUpgrade {
-	if x != nil {
-		return x.PartialUpgrade
-	}
-	return nil
+// Deprecated: Use QueryLiquidityPoolRequest.ProtoReflect.Descriptor instead.
+func (*QueryLiquidityPoolRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{120}
 }
 
-type QueryAllPartialUpgradeRequest struct {
+type QueryLiquidityPoolResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Address     string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	CodeId      uint64 `protobuf:"varint,2,opt,name=codeId,proto3" json:"codeId,omitempty"`
+	BlockHeight uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *QueryAllPartialUpgradeRequest) Reset() {
-	*x = QueryAllPartialUpgradeRequest{}
+func (x *QueryLiquidityPoolResponse) Reset() {
+	*x = QueryLiquidityPoolResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[103]
+		mi := &file_inference_inference_query_proto_msgTypes[121]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllPartialUpgradeRequest) String() string {
+func (x *QueryLiquidityPoolResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllPartialUpgradeRequest) ProtoMessage() {}
+func (*QueryLiquidityPoolResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllPartialUpgradeRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllPartialUpgradeRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{103}
+// Deprecated: Use QueryLiquidityPoolResponse.ProtoReflect.Descriptor instead.
+func (*QueryLiquidityPoolResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{121}
 }
 
-func (x *QueryAllPartialUpgradeRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryLiquidityPoolResponse) GetAddress() string {
 	if x != nil {
-		return x.Pagination
+		return x.Address
 	}
-	return nil
+	return ""
 }
 
-type QueryAllPartialUpgradeResponse struct {
+func (x *QueryLiquidityPoolResponse) GetCodeId() uint64 {
+	if x != nil {
+		return x.CodeId
+	}
+	return 0
+}
+
+func (x *QueryLiquidityPoolResponse) GetBlockHeight() uint64 {
+	if x != nil {
+		return x.BlockHeight
+	}
+	return 0
+}
+
+type QueryEpochInfoRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	PartialUpgrade []*PartialUpgrade     `protobuf:"bytes,1,rep,name=partialUpgrade,proto3" json:"partialUpgrade,omitempty"`
-	Pagination     *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *QueryAllPartialUpgradeResponse) Reset() {
-	*x = QueryAllPartialUpgradeResponse{}
+func (x *QueryEpochInfoRequest) Reset() {
+	*x = QueryEpochInfoRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[104]
+		mi := &file_inference_inference_query_proto_msgTypes[122]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllPartialUpgradeResponse) String() string {
+func (x *QueryEpochInfoRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllPartialUpgradeResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryAllPartialUpgradeResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllPartialUpgradeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{104}
-}
-
-func (x *QueryAllPartialUpgradeResponse) GetPartialUpgrade() []*PartialUpgrade {
-	if x != nil {
-		return x.PartialUpgrade
-	}
-	return nil
-}
+func (*QueryEpochInfoRequest) ProtoMessage() {}
 
-func (x *QueryAllPartialUpgradeResponse) GetPagination() *v1beta1.PageResponse {
-	if x != nil {
-		return x.Pagination
-	}
-	return nil
+// Deprecated: Use QueryEpochInfoRequest.ProtoReflect.Descriptor instead.
+func (*QueryEpochInfoRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{122}
 }
 
-type QueryGetBridgeTransactionRequest struct {
+type QueryEpochInfoResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	OriginChain  string `protobuf:"bytes,1,opt,name=origin_chain,json=originChain,proto3" json:"origin_chain,omitempty"`
-	BlockNumber  string `protobuf:"bytes,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	ReceiptIndex string `protobuf:"bytes,3,opt,name=receipt_index,json=receiptIndex,proto3" json:"receipt_index,omitempty"`
+	BlockHeight                int64                 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	Params                     *Params               `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
+	LatestEpoch                *Epoch                `protobuf:"bytes,3,opt,name=latest_epoch,json=latestEpoch,proto3" json:"latest_epoch,omitempty"`
+	IsConfirmationPocActive    bool                  `protobuf:"varint,4,opt,name=is_confirmation_poc_active,json=isConfirmationPocActive,proto3" json:"is_confirmation_poc_active,omitempty"`
+	ActiveConfirmationPocEvent *ConfirmationPoCEvent `protobuf:"bytes,5,opt,name=active_confirmation_poc_event,json=activeConfirmationPocEvent,proto3" json:"active_confirmation_poc_event,omitempty"`
 }
 
-func (x *QueryGetBridgeTransactionRequest) Reset() {
-	*x = QueryGetBridgeTransactionRequest{}
+func (x *QueryEpochInfoResponse) Reset() {
+	*x = QueryEpochInfoResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[105]
+		mi := &file_inference_inference_query_proto_msgTypes[123]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetBridgeTransactionRequest) String() string {
+func (x *QueryEpochInfoResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetBridgeTransactionRequest) ProtoMessage() {}
+func (*QueryEpochInfoResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetBridgeTransactionRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetBridgeTransactionRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{105}
+// Deprecated: Use QueryEpochInfoResponse.ProtoReflect.Descriptor instead.
+func (*QueryEpochInfoResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{123}
 }
 
-func (x *QueryGetBridgeTransactionRequest) GetOriginChain() string {
+func (x *QueryEpochInfoResponse) GetBlockHeight() int64 {
 	if x != nil {
-		return x.OriginChain
+		return x.BlockHeight
 	}
-	return ""
+	return 0
 }
 
-func (x *QueryGetBridgeTransactionRequest) GetBlockNumber() string {
+func (x *QueryEpochInfoResponse) GetParams() *Params {
 	if x != nil {
-		return x.BlockNumber
+		return x.Params
 	}
-	return ""
+	return nil
 }
 
-func (x *QueryGetBridgeTransactionRequest) GetReceiptIndex() string {
+func (x *QueryEpochInfoResponse) GetLatestEpoch() *Epoch {
 	if x != nil {
-		return x.ReceiptIndex
+		return x.LatestEpoch
 	}
-	return ""
+	return nil
 }
 
-type QueryGetBridgeTransactionResponse struct {
+func (x *QueryEpochInfoResponse) GetIsConfirmationPocActive() bool {
+	if x != nil {
+		return x.IsConfirmationPocActive
+	}
+	return false
+}
+
+func (x *QueryEpochInfoResponse) GetActiveConfirmationPocEvent() *ConfirmationPoCEvent {
+	if x != nil {
+		return x.ActiveConfirmationPocEvent
+	}
+	return nil
+}
+
+type QueryCountPoCbatchesAtHeightRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BridgeTransactions []*BridgeTransaction `protobuf:"bytes,1,rep,name=bridgeTransactions,proto3" json:"bridgeTransactions,omitempty"`
+	BlockHeight int32 `protobuf:"varint,1,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
 }
 
-func (x *QueryGetBridgeTransactionResponse) Reset() {
-	*x = QueryGetBridgeTransactionResponse{}
+func (x *QueryCountPoCbatchesAtHeightRequest) Reset() {
+	*x = QueryCountPoCbatchesAtHeightRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[106]
+		mi := &file_inference_inference_query_proto_msgTypes[124]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetBridgeTransactionResponse) String() string {
+func (x *QueryCountPoCbatchesAtHeightRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetBridgeTransactionResponse) ProtoMessage() {}
+func (*QueryCountPoCbatchesAtHeightRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetBridgeTransactionResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetBridgeTransactionResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{106}
+// Deprecated: Use QueryCountPoCbatchesAtHeightRequest.ProtoReflect.Descriptor instead.
+func (*QueryCountPoCbatchesAtHeightRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{124}
 }
 
-func (x *QueryGetBridgeTransactionResponse) GetBridgeTransactions() []*BridgeTransaction {
+func (x *QueryCountPoCbatchesAtHeightRequest) GetBlockHeight() int32 {
 	if x != nil {
-		return x.BridgeTransactions
+		return x.BlockHeight
 	}
-	return nil
+	return 0
 }
 
-type QueryAllBridgeTransactionsRequest struct {
+type QueryCountPoCbatchesAtHeightResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Count uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
 }
 
-func (x *QueryAllBridgeTransactionsRequest) Reset() {
-	*x = QueryAllBridgeTransactionsRequest{}
+func (x *QueryCountPoCbatchesAtHeightResponse) Reset() {
+	*x = QueryCountPoCbatchesAtHeightResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[107]
+		mi := &file_inference_inference_query_proto_msgTypes[125]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllBridgeTransactionsRequest) String() string {
+func (x *QueryCountPoCbatchesAtHeightResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllBridgeTransactionsRequest) ProtoMessage() {}
+func (*QueryCountPoCbatchesAtHeightResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryAllBridgeTransactionsRequest.ProtoReflect.Descriptor instead.
-func (*QueryAllBridgeTransactionsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{107}
+// Deprecated: Use QueryCountPoCbatchesAtHeightResponse.ProtoReflect.Descriptor instead.
+func (*QueryCountPoCbatchesAtHeightResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{125}
 }
 
-func (x *QueryAllBridgeTransactionsRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryCountPoCbatchesAtHeightResponse) GetCount() uint64 {
 	if x != nil {
-		return x.Pagination
+		return x.Count
 	}
-	return nil
+	return 0
 }
 
-type QueryAllBridgeTransactionsResponse struct {
+type QueryCountPoCvalidationsAtHeightRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BridgeTransactions []*BridgeTransaction  `protobuf:"bytes,1,rep,name=bridgeTransactions,proto3" json:"bridgeTransactions,omitempty"`
-	Pagination         *v1beta1.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	BlockHeight int32 `protobuf:"varint,1,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
 }
 
-func (x *QueryAllBridgeTransactionsResponse) Reset() {
-	*x = QueryAllBridgeTransactionsResponse{}
+func (x *QueryCountPoCvalidationsAtHeightRequest) Reset() {
+	*x = QueryCountPoCvalidationsAtHeightRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[108]
+		mi := &file_inference_inference_query_proto_msgTypes[126]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryAllBridgeTransactionsResponse) String() string {
+func (x *QueryCountPoCvalidationsAtHeightRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryAllBridgeTransactionsResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryAllBridgeTransactionsResponse.ProtoReflect.Descriptor instead.
-func (*QueryAllBridgeTransactionsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{108}
-}
+func (*QueryCountPoCvalidationsAtHeightRequest) ProtoMessage() {}
 
-func (x *QueryAllBridgeTransactionsResponse) GetBridgeTransactions() []*BridgeTransaction {
-	if x != nil {
-		return x.BridgeTransactions
-	}
-	return nil
+// Deprecated: Use QueryCountPoCvalidationsAtHeightRequest.ProtoReflect.Descriptor instead.
+func (*QueryCountPoCvalidationsAtHeightRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{126}
 }
 
-func (x *QueryAllBridgeTransactionsResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryCountPoCvalidationsAtHeightRequest) GetBlockHeight() int32 {
 	if x != nil {
-		return x.Pagination
+		return x.BlockHeight
 	}
-	return nil
+	return 0
 }
 
-type WrappedTokenBalance struct {
+type QueryCountPoCvalidationsAtHeightResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	TokenInfo        *BridgeWrappedTokenContract `protobuf:"bytes,1,opt,name=token_info,json=tokenInfo,proto3" json:"token_info,omitempty"`
-	Symbol           string                      `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
-	Balance          string                      `protobuf:"bytes,3,opt,name=balance,proto3" json:"balance,omitempty"` // current balance (as string to handle large numbers)
-	Decimals         string                      `protobuf:"bytes,4,opt,name=decimals,proto3" json:"decimals,omitempty"`
-	FormattedBalance string                      `protobuf:"bytes,5,opt,name=formatted_balance,json=formattedBalance,proto3" json:"formatted_balance,omitempty"` // human-readable balance (e.g. "1000.50")
+	Count uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
 }
 
-func (x *WrappedTokenBalance) Reset() {
-	*x = WrappedTokenBalance{}
+func (x *QueryCountPoCvalidationsAtHeightResponse) Reset() {
+	*x = QueryCountPoCvalidationsAtHeightResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[109]
+		mi := &file_inference_inference_query_proto_msgTypes[127]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *WrappedTokenBalance) String() string {
+func (x *QueryCountPoCvalidationsAtHeightResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*WrappedTokenBalance) ProtoMessage() {}
+func (*QueryCountPoCvalidationsAtHeightResponse) ProtoMessage() {}
 
-// Deprecated: Use WrappedTokenBalance.ProtoReflect.Descriptor instead.
-func (*WrappedTokenBalance) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{109}
+// Deprecated: Use QueryCountPoCvalidationsAtHeightResponse.ProtoReflect.Descriptor instead.
+func (*QueryCountPoCvalidationsAtHeightResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{127}
 }
 
-func (x *WrappedTokenBalance) GetTokenInfo() *BridgeWrappedTokenContract {
+func (x *QueryCountPoCvalidationsAtHeightResponse) GetCount() uint64 {
 	if x != nil {
-		return x.TokenInfo
+		return x.Count
 	}
-	return nil
+	return 0
 }
 
-func (x *WrappedTokenBalance) GetSymbol() string {
-	if x != nil {
-		return x.Symbol
-	}
-	return ""
+type QueryApprovedTokensForTradeRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
 }
 
-func (x *WrappedTokenBalance) GetBalance() string {
-	if x != nil {
-		return x.Balance
+func (x *QueryApprovedTokensForTradeRequest) Reset() {
+	*x = QueryApprovedTokensForTradeRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_query_proto_msgTypes[128]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
 	}
-	return ""
 }
 
-func (x *WrappedTokenBalance) GetDecimals() string {
-	if x != nil {
-		return x.Decimals
-	}
-	return ""
+func (x *QueryApprovedTokensForTradeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
 }
 
-func (x *WrappedTokenBalance) GetFormattedBalance() string {
-	if x != nil {
-		return x.FormattedBalance
-	}
-	return ""
+func (*QueryApprovedTokensForTradeRequest) ProtoMessage() {}
+
+// Deprecated: Use QueryApprovedTokensForTradeRequest.ProtoReflect.Descriptor instead.
+func (*QueryApprovedTokensForTradeRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{128}
 }
 
-type QueryWrappedTokenBalancesRequest struct {
+type QueryApprovedTokensForTradeResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	ApprovedTokens []*BridgeTokenReference `protobuf:"bytes,1,rep,name=approved_tokens,json=approvedTokens,proto3" json:"approved_tokens,omitempty"`
 }
 
-func (x *QueryWrappedTokenBalancesRequest) Reset() {
-	*x = QueryWrappedTokenBalancesRequest{}
+func (x *QueryApprovedTokensForTradeResponse) Reset() {
+	*x = QueryApprovedTokensForTradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[110]
+		mi := &file_inference_inference_query_proto_msgTypes[129]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryWrappedTokenBalancesRequest) String() string {
+func (x *QueryApprovedTokensForTradeResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryWrappedTokenBalancesRequest) ProtoMessage() {}
+func (*QueryApprovedTokensForTradeResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryWrappedTokenBalancesRequest.ProtoReflect.Descriptor instead.
-func (*QueryWrappedTokenBalancesRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{110}
+// Deprecated: Use QueryApprovedTokensForTradeResponse.ProtoReflect.Descriptor instead.
+func (*QueryApprovedTokensForTradeResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{129}
 }
 
-func (x *QueryWrappedTokenBalancesRequest) GetAddress() string {
+func (x *QueryApprovedTokensForTradeResponse) GetApprovedTokens() []*BridgeTokenReference {
 	if x != nil {
-		return x.Address
+		return x.ApprovedTokens
 	}
-	return ""
+	return nil
 }
 
-type QueryWrappedTokenBalancesResponse struct {
+// Dynamic pricing query messages
+type QueryGetModelPerTokenPriceRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Balances []*WrappedTokenBalance `protobuf:"bytes,1,rep,name=balances,proto3" json:"balances,omitempty"`
+	ModelId string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryWrappedTokenBalancesResponse) Reset() {
-	*x = QueryWrappedTokenBalancesResponse{}
+func (x *QueryGetModelPerTokenPriceRequest) Reset() {
+	*x = QueryGetModelPerTokenPriceRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[111]
+		mi := &file_inference_inference_query_proto_msgTypes[130]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryWrappedTokenBalancesResponse) String() string {
+func (x *QueryGetModelPerTokenPriceRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryWrappedTokenBalancesResponse) ProtoMessage() {}
+func (*QueryGetModelPerTokenPriceRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryWrappedTokenBalancesResponse.ProtoReflect.Descriptor instead.
-func (*QueryWrappedTokenBalancesResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{111}
+// Deprecated: Use QueryGetModelPerTokenPriceRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetModelPerTokenPriceRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{130}
 }
 
-func (x *QueryWrappedTokenBalancesResponse) GetBalances() []*WrappedTokenBalance {
+func (x *QueryGetModelPerTokenPriceRequest) GetModelId() string {
 	if x != nil {
-		return x.Balances
+		return x.ModelId
 	}
-	return nil
+	return ""
 }
 
-type QueryBridgeAddressesByChainRequest struct {
+type QueryGetModelPerTokenPriceResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+	Price uint64 `protobuf:"varint,1,opt,name=price,proto3" json:"price,omitempty"`
+	Found bool   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryBridgeAddressesByChainRequest) Reset() {
-	*x = QueryBridgeAddressesByChainRequest{}
+func (x *QueryGetModelPerTokenPriceResponse) Reset() {
+	*x = QueryGetModelPerTokenPriceResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[112]
+		mi := &file_inference_inference_query_proto_msgTypes[131]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryBridgeAddressesByChainRequest) String() string {
+func (x *QueryGetModelPerTokenPriceResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryBridgeAddressesByChainRequest) ProtoMessage() {}
+func (*QueryGetModelPerTokenPriceResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryBridgeAddressesByChainRequest.ProtoReflect.Descriptor instead.
-func (*QueryBridgeAddressesByChainRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{112}
+// Deprecated: Use QueryGetModelPerTokenPriceResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetModelPerTokenPriceResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{131}
 }
 
-func (x *QueryBridgeAddressesByChainRequest) GetChainId() string {
+func (x *QueryGetModelPerTokenPriceResponse) GetPrice() uint64 {
 	if x != nil {
-		return x.ChainId
+		return x.Price
 	}
-	return ""
+	return 0
 }
 
-type QueryBridgeAddressesByChainResponse struct {
+func (x *QueryGetModelPerTokenPriceResponse) GetFound() bool {
+	if x != nil {
+		return x.Found
+	}
+	return false
+}
+
+type QueryGetAllModelPerTokenPricesRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	Addresses []*BridgeContractAddress `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
 }
 
-func (x *QueryBridgeAddressesByChainResponse) Reset() {
-	*x = QueryBridgeAddressesByChainResponse{}
+func (x *QueryGetAllModelPerTokenPricesRequest) Reset() {
+	*x = QueryGetAllModelPerTokenPricesRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[113]
+		mi := &file_inference_inference_query_proto_msgTypes[132]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryBridgeAddressesByChainResponse) String() string {
+func (x *QueryGetAllModelPerTokenPricesRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryBridgeAddressesByChainResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryBridgeAddressesByChainResponse.ProtoReflect.Descriptor instead.
-func (*QueryBridgeAddressesByChainResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{113}
-}
+func (*QueryGetAllModelPerTokenPricesRequest) ProtoMessage() {}
 
-func (x *QueryBridgeAddressesByChainResponse) GetAddresses() []*BridgeContractAddress {
-	if x != nil {
-		return x.Addresses
-	}
-	return nil
+// Deprecated: Use QueryGetAllModelPerTokenPricesRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetAllModelPerTokenPricesRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{132}
 }
 
-type QueryValidateWrappedTokenForTradeRequest struct {
+type ModelPrice struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
+	ModelId string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	Price   uint64 `protobuf:"varint,2,opt,name=price,proto3" json:"price,omitempty"`
 }
 
-func (x *QueryValidateWrappedTokenForTradeRequest) Reset() {
-	*x = QueryValidateWrappedTokenForTradeRequest{}
+func (x *ModelPrice) Reset() {
+	*x = ModelPrice{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[114]
+		mi := &file_inference_inference_query_proto_msgTypes[133]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryValidateWrappedTokenForTradeRequest) String() string {
+func (x *ModelPrice) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryValidateWrappedTokenForTradeRequest) ProtoMessage() {}
+func (*ModelPrice) ProtoMessage() {}
 
-// Deprecated: Use QueryValidateWrappedTokenForTradeRequest.ProtoReflect.Descriptor instead.
-func (*QueryValidateWrappedTokenForTradeRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{114}
+// Deprecated: Use ModelPrice.ProtoReflect.Descriptor instead.
+func (*ModelPrice) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{133}
 }
 
-func (x *QueryValidateWrappedTokenForTradeRequest) GetContractAddress() string {
+func (x *ModelPrice) GetModelId() string {
 	if x != nil {
-		return x.ContractAddress
+		return x.ModelId
 	}
 	return ""
 }
 
-type QueryValidateWrappedTokenForTradeResponse struct {
+func (x *ModelPrice) GetPrice() uint64 {
+	if x != nil {
+		return x.Price
+	}
+	return 0
+}
+
+type QueryGetAllModelPerTokenPricesResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	IsValid_ bool `protobuf:"varint,1,opt,name=is_valid,json=isValid,proto3" json:"is_valid,omitempty"`
+	ModelPrices []*ModelPrice `protobuf:"bytes,1,rep,name=model_prices,json=modelPrices,proto3" json:"model_prices,omitempty"`
 }
 
-func (x *QueryValidateWrappedTokenForTradeResponse) Reset() {
-	*x = QueryValidateWrappedTokenForTradeResponse{}
+func (x *QueryGetAllModelPerTokenPricesResponse) Reset() {
+	*x = QueryGetAllModelPerTokenPricesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[115]
+		mi := &file_inference_inference_query_proto_msgTypes[134]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryValidateWrappedTokenForTradeResponse) String() string {
+func (x *QueryGetAllModelPerTokenPricesResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryValidateWrappedTokenForTradeResponse) ProtoMessage() {}
+func (*QueryGetAllModelPerTokenPricesResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryValidateWrappedTokenForTradeResponse.ProtoReflect.Descriptor instead.
-func (*QueryValidateWrappedTokenForTradeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{115}
+// Deprecated: Use QueryGetAllModelPerTokenPricesResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetAllModelPerTokenPricesResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{134}
 }
 
-func (x *QueryValidateWrappedTokenForTradeResponse) GetIsValid_() bool {
+func (x *QueryGetAllModelPerTokenPricesResponse) GetModelPrices() []*ModelPrice {
 	if x != nil {
-		return x.IsValid_
+		return x.ModelPrices
 	}
-	return false
+	return nil
 }
 
-type QueryValidateIbcTokenForTradeRequest struct {
+type QueryGetModelCapacityRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	IbcDenom string `protobuf:"bytes,1,opt,name=ibc_denom,json=ibcDenom,proto3" json:"ibc_denom,omitempty"`
+	ModelId string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryValidateIbcTokenForTradeRequest) Reset() {
-	*x = QueryValidateIbcTokenForTradeRequest{}
+func (x *QueryGetModelCapacityRequest) Reset() {
+	*x = QueryGetModelCapacityRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[116]
+		mi := &file_inference_inference_query_proto_msgTypes[135]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryValidateIbcTokenForTradeRequest) String() string {
+func (x *QueryGetModelCapacityRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryValidateIbcTokenForTradeRequest) ProtoMessage() {}
+func (*QueryGetModelCapacityRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryValidateIbcTokenForTradeRequest.ProtoReflect.Descriptor instead.
-func (*QueryValidateIbcTokenForTradeRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{116}
+// Deprecated: Use QueryGetModelCapacityRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetModelCapacityRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{135}
 }
 
-func (x *QueryValidateIbcTokenForTradeRequest) GetIbcDenom() string {
+func (x *QueryGetModelCapacityRequest) GetModelId() string {
 	if x != nil {
-		return x.IbcDenom
+		return x.ModelId
 	}
 	return ""
 }
 
-type QueryValidateIbcTokenForTradeResponse struct {
+type QueryGetModelCapacityResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	IsValid_ bool   `protobuf:"varint,1,opt,name=is_valid,json=isValid,proto3" json:"is_valid,omitempty"`
-	Decimals uint32 `protobuf:"varint,2,opt,name=decimals,proto3" json:"decimals,omitempty"`
+	Capacity uint64 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
+	Found    bool   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryValidateIbcTokenForTradeResponse) Reset() {
-	*x = QueryValidateIbcTokenForTradeResponse{}
+func (x *QueryGetModelCapacityResponse) Reset() {
+	*x = QueryGetModelCapacityResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[117]
+		mi := &file_inference_inference_query_proto_msgTypes[136]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryValidateIbcTokenForTradeResponse) String() string {
+func (x *QueryGetModelCapacityResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryValidateIbcTokenForTradeResponse) ProtoMessage() {}
+func (*QueryGetModelCapacityResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryValidateIbcTokenForTradeResponse.ProtoReflect.Descriptor instead.
-func (*QueryValidateIbcTokenForTradeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{117}
+// Deprecated: Use QueryGetModelCapacityResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetModelCapacityResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{136}
 }
 
-func (x *QueryValidateIbcTokenForTradeResponse) GetIsValid_() bool {
+func (x *QueryGetModelCapacityResponse) GetCapacity() uint64 {
 	if x != nil {
-		return x.IsValid_
+		return x.Capacity
 	}
-	return false
+	return 0
 }
 
-func (x *QueryValidateIbcTokenForTradeResponse) GetDecimals() uint32 {
+func (x *QueryGetModelCapacityResponse) GetFound() bool {
 	if x != nil {
-		return x.Decimals
+		return x.Found
 	}
-	return 0
+	return false
 }
 
-type QueryLiquidityPoolRequest struct {
+type QueryGetAllModelCapacitiesRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 }
 
-func (x *QueryLiquidityPoolRequest) Reset() {
-	*x = QueryLiquidityPoolRequest{}
+func (x *QueryGetAllModelCapacitiesRequest) Reset() {
+	*x = QueryGetAllModelCapacitiesRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[118]
+		mi := &file_inference_inference_query_proto_msgTypes[137]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryLiquidityPoolRequest) String() string {
+func (x *QueryGetAllModelCapacitiesRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryLiquidityPoolRequest) ProtoMessage() {}
+func (*QueryGetAllModelCapacitiesRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryLiquidityPoolRequest.ProtoReflect.Descriptor instead.
-func (*QueryLiquidityPoolRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{118}
+// Deprecated: Use QueryGetAllModelCapacitiesRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetAllModelCapacitiesRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{137}
 }
 
-type QueryLiquidityPoolResponse struct {
+type QueryGetAllModelCapacitiesResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Address     string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
-	CodeId      uint64 `protobuf:"varint,2,opt,name=codeId,proto3" json:"codeId,omitempty"`
-	BlockHeight uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	ModelCapacities []*ModelCapacity `protobuf:"bytes,1,rep,name=model_capacities,json=modelCapacities,proto3" json:"model_capacities,omitempty"`
 }
 
-func (x *QueryLiquidityPoolResponse) Reset() {
-	*x = QueryLiquidityPoolResponse{}
+func (x *QueryGetAllModelCapacitiesResponse) Reset() {
+	*x = QueryGetAllModelCapacitiesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[119]
+		mi := &file_inference_inference_query_proto_msgTypes[138]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryLiquidityPoolResponse) String() string {
+func (x *QueryGetAllModelCapacitiesResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryLiquidityPoolResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryLiquidityPoolResponse.ProtoReflect.Descriptor instead.
-func (*QueryLiquidityPoolResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{119}
-}
-
-func (x *QueryLiquidityPoolResponse) GetAddress() string {
-	if x != nil {
-		return x.Address
-	}
-	return ""
-}
+func (*QueryGetAllModelCapacitiesResponse) ProtoMessage() {}
 
-func (x *QueryLiquidityPoolResponse) GetCodeId() uint64 {
-	if x != nil {
-		return x.CodeId
-	}
-	return 0
+// Deprecated: Use QueryGetAllModelCapacitiesResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetAllModelCapacitiesResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{138}
 }
 
-func (x *QueryLiquidityPoolResponse) GetBlockHeight() uint64 {
+func (x *QueryGetAllModelCapacitiesResponse) GetModelCapacities() []*ModelCapacity {
 	if x != nil {
-		return x.BlockHeight
+		return x.ModelCapacities
 	}
-	return 0
+	return nil
 }
 
-type QueryEpochInfoRequest struct {
+type ModelCapacity struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	ModelId  string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	Capacity uint64 `protobuf:"varint,2,opt,name=capacity,proto3" json:"capacity,omitempty"`
 }
 
-func (x *QueryEpochInfoRequest) Reset() {
-	*x = QueryEpochInfoRequest{}
+func (x *ModelCapacity) Reset() {
+	*x = ModelCapacity{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[120]
+		mi := &file_inference_inference_query_proto_msgTypes[139]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryEpochInfoRequest) String() string {
+func (x *ModelCapacity) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryEpochInfoRequest) ProtoMessage() {}
+func (*ModelCapacity) ProtoMessage() {}
 
-// Deprecated: Use QueryEpochInfoRequest.ProtoReflect.Descriptor instead.
-func (*QueryEpochInfoRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{120}
+// Deprecated: Use ModelCapacity.ProtoReflect.Descriptor instead.
+func (*ModelCapacity) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{139}
 }
 
-type QueryEpochInfoResponse struct {
+func (x *ModelCapacity) GetModelId() string {
+	if x != nil {
+		return x.ModelId
+	}
+	return ""
+}
+
+func (x *ModelCapacity) GetCapacity() uint64 {
+	if x != nil {
+		return x.Capacity
+	}
+	return 0
+}
+
+type QueryGranteesByMessageTypeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BlockHeight                int64                 `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
-	Params                     *Params               `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
-	LatestEpoch                *Epoch                `protobuf:"bytes,3,opt,name=latest_epoch,json=latestEpoch,proto3" json:"latest_epoch,omitempty"`
-	IsConfirmationPocActive    bool                  `protobuf:"varint,4,opt,name=is_confirmation_poc_active,json=isConfirmationPocActive,proto3" json:"is_confirmation_poc_active,omitempty"`
-	ActiveConfirmationPocEvent *ConfirmationPoCEvent `protobuf:"bytes,5,opt,name=active_confirmation_poc_event,json=activeConfirmationPocEvent,proto3" json:"active_confirmation_poc_event,omitempty"`
+	GranterAddress string `protobuf:"bytes,1,opt,name=granter_address,json=granterAddress,proto3" json:"granter_address,omitempty"`
+	MessageTypeUrl string `protobuf:"bytes,2,opt,name=message_type_url,json=messageTypeUrl,proto3" json:"message_type_url,omitempty"`
 }
 
-func (x *QueryEpochInfoResponse) Reset() {
-	*x = QueryEpochInfoResponse{}
+func (x *QueryGranteesByMessageTypeRequest) Reset() {
+	*x = QueryGranteesByMessageTypeRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[121]
+		mi := &file_inference_inference_query_proto_msgTypes[140]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryEpochInfoResponse) String() string {
+func (x *QueryGranteesByMessageTypeRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryEpochInfoResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryEpochInfoResponse.ProtoReflect.Descriptor instead.
-func (*QueryEpochInfoResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{121}
-}
-
-func (x *QueryEpochInfoResponse) GetBlockHeight() int64 {
-	if x != nil {
-		return x.BlockHeight
-	}
-	return 0
-}
-
-func (x *QueryEpochInfoResponse) GetParams() *Params {
-	if x != nil {
-		return x.Params
-	}
-	return nil
-}
+func (*QueryGranteesByMessageTypeRequest) ProtoMessage() {}
 
-func (x *QueryEpochInfoResponse) GetLatestEpoch() *Epoch {
-	if x != nil {
-		return x.LatestEpoch
-	}
-	return nil
+// Deprecated: Use QueryGranteesByMessageTypeRequest.ProtoReflect.Descriptor instead.
+func (*QueryGranteesByMessageTypeRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{140}
 }
 
-func (x *QueryEpochInfoResponse) GetIsConfirmationPocActive() bool {
+func (x *QueryGranteesByMessageTypeRequest) GetGranterAddress() string {
 	if x != nil {
-		return x.IsConfirmationPocActive
+		return x.GranterAddress
 	}
-	return false
+	return ""
 }
 
-func (x *QueryEpochInfoResponse) GetActiveConfirmationPocEvent() *ConfirmationPoCEvent {
+func (x *QueryGranteesByMessageTypeRequest) GetMessageTypeUrl() string {
 	if x != nil {
-		return x.ActiveConfirmationPocEvent
+		return x.MessageTypeUrl
 	}
-	return nil
+	return ""
 }
 
-type QueryCountPoCbatchesAtHeightRequest struct {
+type Grantee struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BlockHeight int32 `protobuf:"varint,1,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	PubKey  string `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
 }
 
-func (x *QueryCountPoCbatchesAtHeightRequest) Reset() {
-	*x = QueryCountPoCbatchesAtHeightRequest{}
+func (x *Grantee) Reset() {
+	*x = Grantee{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[122]
+		mi := &file_inference_inference_query_proto_msgTypes[141]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCountPoCbatchesAtHeightRequest) String() string {
+func (x *Grantee) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCountPoCbatchesAtHeightRequest) ProtoMessage() {}
+func (*Grantee) ProtoMessage() {}
 
-// Deprecated: Use QueryCountPoCbatchesAtHeightRequest.ProtoReflect.Descriptor instead.
-func (*QueryCountPoCbatchesAtHeightRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{122}
+// Deprecated: Use Grantee.ProtoReflect.Descriptor instead.
+func (*Grantee) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{141}
 }
 
-func (x *QueryCountPoCbatchesAtHeightRequest) GetBlockHeight() int32 {
+func (x *Grantee) GetAddress() string {
 	if x != nil {
-		return x.BlockHeight
+		return x.Address
 	}
-	return 0
+	return ""
 }
 
-type QueryCountPoCbatchesAtHeightResponse struct {
+func (x *Grantee) GetPubKey() string {
+	if x != nil {
+		return x.PubKey
+	}
+	return ""
+}
+
+type QueryGranteesByMessageTypeResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Count uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Grantees []*Grantee `protobuf:"bytes,1,rep,name=grantees,proto3" json:"grantees,omitempty"`
 }
 
-func (x *QueryCountPoCbatchesAtHeightResponse) Reset() {
-	*x = QueryCountPoCbatchesAtHeightResponse{}
+func (x *QueryGranteesByMessageTypeResponse) Reset() {
+	*x = QueryGranteesByMessageTypeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[123]
+		mi := &file_inference_inference_query_proto_msgTypes[142]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCountPoCbatchesAtHeightResponse) String() string {
+func (x *QueryGranteesByMessageTypeResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCountPoCbatchesAtHeightResponse) ProtoMessage() {}
+func (*QueryGranteesByMessageTypeResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryCountPoCbatchesAtHeightResponse.ProtoReflect.Descriptor instead.
-func (*QueryCountPoCbatchesAtHeightResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{123}
+// Deprecated: Use QueryGranteesByMessageTypeResponse.ProtoReflect.Descriptor instead.
+func (*QueryGranteesByMessageTypeResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{142}
 }
 
-func (x *QueryCountPoCbatchesAtHeightResponse) GetCount() uint64 {
+func (x *QueryGranteesByMessageTypeResponse) GetGrantees() []*Grantee {
 	if x != nil {
-		return x.Count
+		return x.Grantees
 	}
-	return 0
+	return nil
 }
 
-type QueryCountPoCvalidationsAtHeightRequest struct {
+type QueryParticipantAllowListRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	BlockHeight int32 `protobuf:"varint,1,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
 }
 
-func (x *QueryCountPoCvalidationsAtHeightRequest) Reset() {
-	*x = QueryCountPoCvalidationsAtHeightRequest{}
+func (x *QueryParticipantAllowListRequest) Reset() {
+	*x = QueryParticipantAllowListRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[124]
+		mi := &file_inference_inference_query_proto_msgTypes[143]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCountPoCvalidationsAtHeightRequest) String() string {
+func (x *QueryParticipantAllowListRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCountPoCvalidationsAtHeightRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryCountPoCvalidationsAtHeightRequest.ProtoReflect.Descriptor instead.
-func (*QueryCountPoCvalidationsAtHeightRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{124}
-}
+func (*QueryParticipantAllowListRequest) ProtoMessage() {}
 
-func (x *QueryCountPoCvalidationsAtHeightRequest) GetBlockHeight() int32 {
-	if x != nil {
-		return x.BlockHeight
-	}
-	return 0
+// Deprecated: Use QueryParticipantAllowListRequest.ProtoReflect.Descriptor instead.
+func (*QueryParticipantAllowListRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{143}
 }
 
-type QueryCountPoCvalidationsAtHeightResponse struct {
+type QueryParticipantAllowListResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Count uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
+	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
 }
 
-func (x *QueryCountPoCvalidationsAtHeightResponse) Reset() {
-	*x = QueryCountPoCvalidationsAtHeightResponse{}
+func (x *QueryParticipantAllowListResponse) Reset() {
+	*x = QueryParticipantAllowListResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[125]
+		mi := &file_inference_inference_query_proto_msgTypes[144]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryCountPoCvalidationsAtHeightResponse) String() string {
+func (x *QueryParticipantAllowListResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryCountPoCvalidationsAtHeightResponse) ProtoMessage() {}
+func (*QueryParticipantAllowListResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryCountPoCvalidationsAtHeightResponse.ProtoReflect.Descriptor instead.
-func (*QueryCountPoCvalidationsAtHeightResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{125}
+// Deprecated: Use QueryParticipantAllowListResponse.ProtoReflect.Descriptor instead.
+func (*QueryParticipantAllowListResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{144}
 }
 
-func (x *QueryCountPoCvalidationsAtHeightResponse) GetCount() uint64 {
+func (x *QueryParticipantAllowListResponse) GetAddresses() []string {
 	if x != nil {
-		return x.Count
+		return x.Addresses
 	}
-	return 0
+	return nil
 }
 
-type QueryApprovedTokensForTradeRequest struct {
+type QueryGetMLNodeVersionRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 }
 
-func (x *QueryApprovedTokensForTradeRequest) Reset() {
-	*x = QueryApprovedTokensForTradeRequest{}
+func (x *QueryGetMLNodeVersionRequest) Reset() {
+	*x = QueryGetMLNodeVersionRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[126]
+		mi := &file_inference_inference_query_proto_msgTypes[145]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryApprovedTokensForTradeRequest) String() string {
+func (x *QueryGetMLNodeVersionRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryApprovedTokensForTradeRequest) ProtoMessage() {}
+func (*QueryGetMLNodeVersionRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryApprovedTokensForTradeRequest.ProtoReflect.Descriptor instead.
-func (*QueryApprovedTokensForTradeRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{126}
+// Deprecated: Use QueryGetMLNodeVersionRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetMLNodeVersionRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{145}
 }
 
-type QueryApprovedTokensForTradeResponse struct {
+type QueryGetMLNodeVersionResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ApprovedTokens []*BridgeTokenReference `protobuf:"bytes,1,rep,name=approved_tokens,json=approvedTokens,proto3" json:"approved_tokens,omitempty"`
+	MlnodeVersion *MLNodeVersion `protobuf:"bytes,1,opt,name=mlnode_version,json=mlnodeVersion,proto3" json:"mlnode_version,omitempty"`
 }
 
-func (x *QueryApprovedTokensForTradeResponse) Reset() {
-	*x = QueryApprovedTokensForTradeResponse{}
+func (x *QueryGetMLNodeVersionResponse) Reset() {
+	*x = QueryGetMLNodeVersionResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[127]
+		mi := &file_inference_inference_query_proto_msgTypes[146]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryApprovedTokensForTradeResponse) String() string {
+func (x *QueryGetMLNodeVersionResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryApprovedTokensForTradeResponse) ProtoMessage() {}
+func (*QueryGetMLNodeVersionResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryApprovedTokensForTradeResponse.ProtoReflect.Descriptor instead.
-func (*QueryApprovedTokensForTradeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{127}
+// Deprecated: Use QueryGetMLNodeVersionResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetMLNodeVersionResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{146}
 }
 
-func (x *QueryApprovedTokensForTradeResponse) GetApprovedTokens() []*BridgeTokenReference {
+func (x *QueryGetMLNodeVersionResponse) GetMlnodeVersion() *MLNodeVersion {
 	if x != nil {
-		return x.ApprovedTokens
+		return x.MlnodeVersion
 	}
 	return nil
 }
 
-// Dynamic pricing query messages
-type QueryGetModelPerTokenPriceRequest struct {
+type QueryGetLastUpgradeHeightRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	ModelId string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
 }
 
-func (x *QueryGetModelPerTokenPriceRequest) Reset() {
-	*x = QueryGetModelPerTokenPriceRequest{}
+func (x *QueryGetLastUpgradeHeightRequest) Reset() {
+	*x = QueryGetLastUpgradeHeightRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[128]
+		mi := &file_inference_inference_query_proto_msgTypes[147]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetModelPerTokenPriceRequest) String() string {
+func (x *QueryGetLastUpgradeHeightRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetModelPerTokenPriceRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryGetModelPerTokenPriceRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetModelPerTokenPriceRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{128}
-}
+func (*QueryGetLastUpgradeHeightRequest) ProtoMessage() {}
 
-func (x *QueryGetModelPerTokenPriceRequest) GetModelId() string {
-	if x != nil {
-		return x.ModelId
-	}
-	return ""
+// Deprecated: Use QueryGetLastUpgradeHeightRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetLastUpgradeHeightRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{147}
 }
 
-type QueryGetModelPerTokenPriceResponse struct {
+type QueryGetLastUpgradeHeightResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Price uint64 `protobuf:"varint,1,opt,name=price,proto3" json:"price,omitempty"`
-	Found bool   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	LastUpgradeHeight int64 `protobuf:"varint,1,opt,name=last_upgrade_height,json=lastUpgradeHeight,proto3" json:"last_upgrade_height,omitempty"`
+	Found             bool  `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryGetModelPerTokenPriceResponse) Reset() {
-	*x = QueryGetModelPerTokenPriceResponse{}
+func (x *QueryGetLastUpgradeHeightResponse) Reset() {
+	*x = QueryGetLastUpgradeHeightResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[129]
+		mi := &file_inference_inference_query_proto_msgTypes[148]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetModelPerTokenPriceResponse) String() string {
+func (x *QueryGetLastUpgradeHeightResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetModelPerTokenPriceResponse) ProtoMessage() {}
+func (*QueryGetLastUpgradeHeightResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetModelPerTokenPriceResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetModelPerTokenPriceResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{129}
+// Deprecated: Use QueryGetLastUpgradeHeightResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetLastUpgradeHeightResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{148}
 }
 
-func (x *QueryGetModelPerTokenPriceResponse) GetPrice() uint64 {
+func (x *QueryGetLastUpgradeHeightResponse) GetLastUpgradeHeight() int64 {
 	if x != nil {
-		return x.Price
+		return x.LastUpgradeHeight
 	}
 	return 0
 }
 
-func (x *QueryGetModelPerTokenPriceResponse) GetFound() bool {
+func (x *QueryGetLastUpgradeHeightResponse) GetFound() bool {
 	if x != nil {
 		return x.Found
 	}
 	return false
 }
 
-type QueryGetAllModelPerTokenPricesRequest struct {
+// QueryExcludedParticipantsRequest requests excluded participants for an epoch.
+// If epoch_index is 0, the query should return for the current effective epoch.
+type QueryExcludedParticipantsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *QueryGetAllModelPerTokenPricesRequest) Reset() {
-	*x = QueryGetAllModelPerTokenPricesRequest{}
+func (x *QueryExcludedParticipantsRequest) Reset() {
+	*x = QueryExcludedParticipantsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[130]
+		mi := &file_inference_inference_query_proto_msgTypes[149]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetAllModelPerTokenPricesRequest) String() string {
+func (x *QueryExcludedParticipantsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetAllModelPerTokenPricesRequest) ProtoMessage() {}
+func (*QueryExcludedParticipantsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetAllModelPerTokenPricesRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetAllModelPerTokenPricesRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{130}
+// Deprecated: Use QueryExcludedParticipantsRequest.ProtoReflect.Descriptor instead.
+func (*QueryExcludedParticipantsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{149}
 }
 
-type ModelPrice struct {
+func (x *QueryExcludedParticipantsRequest) GetEpochIndex() uint64 {
+	if x != nil {
+		return x.EpochIndex
+	}
+	return 0
+}
+
+// QueryExcludedParticipantsResponse returns a list of excluded participants for the epoch.
+type QueryExcludedParticipantsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ModelId string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
-	Price   uint64 `protobuf:"varint,2,opt,name=price,proto3" json:"price,omitempty"`
+	Items []*ExcludedParticipant `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
 }
 
-func (x *ModelPrice) Reset() {
-	*x = ModelPrice{}
+func (x *QueryExcludedParticipantsResponse) Reset() {
+	*x = QueryExcludedParticipantsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[131]
+		mi := &file_inference_inference_query_proto_msgTypes[150]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ModelPrice) String() string {
+func (x *QueryExcludedParticipantsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ModelPrice) ProtoMessage() {}
-
-// Deprecated: Use ModelPrice.ProtoReflect.Descriptor instead.
-func (*ModelPrice) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{131}
-}
+func (*QueryExcludedParticipantsResponse) ProtoMessage() {}
 
-func (x *ModelPrice) GetModelId() string {
-	if x != nil {
-		return x.ModelId
-	}
-	return ""
+// Deprecated: Use QueryExcludedParticipantsResponse.ProtoReflect.Descriptor instead.
+func (*QueryExcludedParticipantsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{150}
 }
 
-func (x *ModelPrice) GetPrice() uint64 {
+func (x *QueryExcludedParticipantsResponse) GetItems() []*ExcludedParticipant {
 	if x != nil {
-		return x.Price
+		return x.Items
 	}
-	return 0
+	return nil
 }
 
-type QueryGetAllModelPerTokenPricesResponse struct {
+// QueryActiveConfirmationPoCEventRequest is request type for the Query/ActiveConfirmationPoCEvent RPC method.
+type QueryActiveConfirmationPoCEventRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	ModelPrices []*ModelPrice `protobuf:"bytes,1,rep,name=model_prices,json=modelPrices,proto3" json:"model_prices,omitempty"`
 }
 
-func (x *QueryGetAllModelPerTokenPricesResponse) Reset() {
-	*x = QueryGetAllModelPerTokenPricesResponse{}
+func (x *QueryActiveConfirmationPoCEventRequest) Reset() {
+	*x = QueryActiveConfirmationPoCEventRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[132]
+		mi := &file_inference_inference_query_proto_msgTypes[151]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetAllModelPerTokenPricesResponse) String() string {
+func (x *QueryActiveConfirmationPoCEventRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetAllModelPerTokenPricesResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryGetAllModelPerTokenPricesResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetAllModelPerTokenPricesResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{132}
-}
+func (*QueryActiveConfirmationPoCEventRequest) ProtoMessage() {}
 
-func (x *QueryGetAllModelPerTokenPricesResponse) GetModelPrices() []*ModelPrice {
-	if x != nil {
-		return x.ModelPrices
-	}
-	return nil
+// Deprecated: Use QueryActiveConfirmationPoCEventRequest.ProtoReflect.Descriptor instead.
+func (*QueryActiveConfirmationPoCEventRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{151}
 }
 
-type QueryGetModelCapacityRequest struct {
+// QueryActiveConfirmationPoCEventResponse is response type for the Query/ActiveConfirmationPoCEvent RPC method.
+type QueryActiveConfirmationPoCEventResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ModelId string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	IsActive bool                  `protobuf:"varint,1,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
+	Event    *ConfirmationPoCEvent `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
 }
 
-func (x *QueryGetModelCapacityRequest) Reset() {
-	*x = QueryGetModelCapacityRequest{}
+func (x *QueryActiveConfirmationPoCEventResponse) Reset() {
+	*x = QueryActiveConfirmationPoCEventResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[133]
+		mi := &file_inference_inference_query_proto_msgTypes[152]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetModelCapacityRequest) String() string {
+func (x *QueryActiveConfirmationPoCEventResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetModelCapacityRequest) ProtoMessage() {}
+func (*QueryActiveConfirmationPoCEventResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetModelCapacityRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetModelCapacityRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{133}
+// Deprecated: Use QueryActiveConfirmationPoCEventResponse.ProtoReflect.Descriptor instead.
+func (*QueryActiveConfirmationPoCEventResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{152}
 }
 
-func (x *QueryGetModelCapacityRequest) GetModelId() string {
+func (x *QueryActiveConfirmationPoCEventResponse) GetIsActive() bool {
 	if x != nil {
-		return x.ModelId
+		return x.IsActive
 	}
-	return ""
+	return false
 }
 
-type QueryGetModelCapacityResponse struct {
+func (x *QueryActiveConfirmationPoCEventResponse) GetEvent() *ConfirmationPoCEvent {
+	if x != nil {
+		return x.Event
+	}
+	return nil
+}
+
+// QueryConfirmationPoCEventsRequest is request type for the Query/ConfirmationPoCEvents RPC method.
+type QueryConfirmationPoCEventsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Capacity uint64 `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
-	Found    bool   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *QueryGetModelCapacityResponse) Reset() {
-	*x = QueryGetModelCapacityResponse{}
+func (x *QueryConfirmationPoCEventsRequest) Reset() {
+	*x = QueryConfirmationPoCEventsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[134]
+		mi := &file_inference_inference_query_proto_msgTypes[153]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetModelCapacityResponse) String() string {
+func (x *QueryConfirmationPoCEventsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetModelCapacityResponse) ProtoMessage() {}
+func (*QueryConfirmationPoCEventsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetModelCapacityResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetModelCapacityResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{134}
+// Deprecated: Use QueryConfirmationPoCEventsRequest.ProtoReflect.Descriptor instead.
+func (*QueryConfirmationPoCEventsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{153}
 }
 
-func (x *QueryGetModelCapacityResponse) GetCapacity() uint64 {
+func (x *QueryConfirmationPoCEventsRequest) GetEpochIndex() uint64 {
 	if x != nil {
-		return x.Capacity
+		return x.EpochIndex
 	}
 	return 0
 }
 
-func (x *QueryGetModelCapacityResponse) GetFound() bool {
-	if x != nil {
-		return x.Found
-	}
-	return false
-}
-
-type QueryGetAllModelCapacitiesRequest struct {
+// QueryConfirmationPoCEventsResponse is response type for the Query/ConfirmationPoCEvents RPC method.
+type QueryConfirmationPoCEventsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Events []*ConfirmationPoCEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
 }
 
-func (x *QueryGetAllModelCapacitiesRequest) Reset() {
-	*x = QueryGetAllModelCapacitiesRequest{}
+func (x *QueryConfirmationPoCEventsResponse) Reset() {
+	*x = QueryConfirmationPoCEventsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[135]
+		mi := &file_inference_inference_query_proto_msgTypes[154]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetAllModelCapacitiesRequest) String() string {
+func (x *QueryConfirmationPoCEventsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetAllModelCapacitiesRequest) ProtoMessage() {}
+func (*QueryConfirmationPoCEventsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetAllModelCapacitiesRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetAllModelCapacitiesRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{135}
+// Deprecated: Use QueryConfirmationPoCEventsResponse.ProtoReflect.Descriptor instead.
+func (*QueryConfirmationPoCEventsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{154}
 }
 
-type QueryGetAllModelCapacitiesResponse struct {
+func (x *QueryConfirmationPoCEventsResponse) GetEvents() []*ConfirmationPoCEvent {
+	if x != nil {
+		return x.Events
+	}
+	return nil
+}
+
+// ParticipantWithBalance contains participant data along with their bank balance.
+type ParticipantWithBalance struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ModelCapacities []*ModelCapacity `protobuf:"bytes,1,rep,name=model_capacities,json=modelCapacities,proto3" json:"model_capacities,omitempty"`
+	Participant *Participant     `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	Balances    []*v1beta11.Coin `protobuf:"bytes,2,rep,name=balances,proto3" json:"balances,omitempty"`
 }
 
-func (x *QueryGetAllModelCapacitiesResponse) Reset() {
-	*x = QueryGetAllModelCapacitiesResponse{}
+func (x *ParticipantWithBalance) Reset() {
+	*x = ParticipantWithBalance{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[136]
+		mi := &file_inference_inference_query_proto_msgTypes[155]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetAllModelCapacitiesResponse) String() string {
+func (x *ParticipantWithBalance) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetAllModelCapacitiesResponse) ProtoMessage() {}
+func (*ParticipantWithBalance) ProtoMessage() {}
 
-// Deprecated: Use QueryGetAllModelCapacitiesResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetAllModelCapacitiesResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{136}
+// Deprecated: Use ParticipantWithBalance.ProtoReflect.Descriptor instead.
+func (*ParticipantWithBalance) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{155}
 }
 
-func (x *QueryGetAllModelCapacitiesResponse) GetModelCapacities() []*ModelCapacity {
+func (x *ParticipantWithBalance) GetParticipant() *Participant {
 	if x != nil {
-		return x.ModelCapacities
+		return x.Participant
 	}
 	return nil
 }
 
-type ModelCapacity struct {
+func (x *ParticipantWithBalance) GetBalances() []*v1beta11.Coin {
+	if x != nil {
+		return x.Balances
+	}
+	return nil
+}
+
+// QueryParticipantsWithBalancesRequest is request type for the Query/ParticipantsWithBalances RPC method.
+type QueryParticipantsWithBalancesRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ModelId  string `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
-	Capacity uint64 `protobuf:"varint,2,opt,name=capacity,proto3" json:"capacity,omitempty"`
+	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
 
-func (x *ModelCapacity) Reset() {
-	*x = ModelCapacity{}
+func (x *QueryParticipantsWithBalancesRequest) Reset() {
+	*x = QueryParticipantsWithBalancesRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[137]
+		mi := &file_inference_inference_query_proto_msgTypes[156]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ModelCapacity) String() string {
+func (x *QueryParticipantsWithBalancesRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ModelCapacity) ProtoMessage() {}
-
-// Deprecated: Use ModelCapacity.ProtoReflect.Descriptor instead.
-func (*ModelCapacity) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{137}
-}
+func (*QueryParticipantsWithBalancesRequest) ProtoMessage() {}
 
-func (x *ModelCapacity) GetModelId() string {
-	if x != nil {
-		return x.ModelId
-	}
-	return ""
+// Deprecated: Use QueryParticipantsWithBalancesRequest.ProtoReflect.Descriptor instead.
+func (*QueryParticipantsWithBalancesRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{156}
 }
 
-func (x *ModelCapacity) GetCapacity() uint64 {
+func (x *QueryParticipantsWithBalancesRequest) GetPagination() *v1beta1.PageRequest {
 	if x != nil {
-		return x.Capacity
+		return x.Pagination
 	}
-	return 0
+	return nil
 }
 
-type QueryGranteesByMessageTypeRequest struct {
+// QueryParticipantsWithBalancesResponse is response type for the Query/ParticipantsWithBalances RPC method.
+type QueryParticipantsWithBalancesResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	GranterAddress string `protobuf:"bytes,1,opt,name=granter_address,json=granterAddress,proto3" json:"granter_address,omitempty"`
-	MessageTypeUrl string `protobuf:"bytes,2,opt,name=message_type_url,json=messageTypeUrl,proto3" json:"message_type_url,omitempty"`
+	Participants []*ParticipantWithBalance `protobuf:"bytes,1,rep,name=participants,proto3" json:"participants,omitempty"`
+	Pagination   *v1beta1.PageResponse     `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	BlockHeight  int64                     `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
-func (x *QueryGranteesByMessageTypeRequest) Reset() {
-	*x = QueryGranteesByMessageTypeRequest{}
+func (x *QueryParticipantsWithBalancesResponse) Reset() {
+	*x = QueryParticipantsWithBalancesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[138]
+		mi := &file_inference_inference_query_proto_msgTypes[157]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGranteesByMessageTypeRequest) String() string {
+func (x *QueryParticipantsWithBalancesResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGranteesByMessageTypeRequest) ProtoMessage() {}
+func (*QueryParticipantsWithBalancesResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGranteesByMessageTypeRequest.ProtoReflect.Descriptor instead.
-func (*QueryGranteesByMessageTypeRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{138}
+// Deprecated: Use QueryParticipantsWithBalancesResponse.ProtoReflect.Descriptor instead.
+func (*QueryParticipantsWithBalancesResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{157}
 }
 
-func (x *QueryGranteesByMessageTypeRequest) GetGranterAddress() string {
+func (x *QueryParticipantsWithBalancesResponse) GetParticipants() []*ParticipantWithBalance {
 	if x != nil {
-		return x.GranterAddress
+		return x.Participants
 	}
-	return ""
+	return nil
 }
 
-func (x *QueryGranteesByMessageTypeRequest) GetMessageTypeUrl() string {
+func (x *QueryParticipantsWithBalancesResponse) GetPagination() *v1beta1.PageResponse {
 	if x != nil {
-		return x.MessageTypeUrl
+		return x.Pagination
 	}
-	return ""
+	return nil
 }
 
-type Grantee struct {
+func (x *QueryParticipantsWithBalancesResponse) GetBlockHeight() int64 {
+	if x != nil {
+		return x.BlockHeight
+	}
+	return 0
+}
+
+// QueryRandomSeedsRequest is request type for the Query/RandomSeeds RPC method.
+type QueryRandomSeedsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
-	PubKey  string `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *Grantee) Reset() {
-	*x = Grantee{}
+func (x *QueryRandomSeedsRequest) Reset() {
+	*x = QueryRandomSeedsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[139]
+		mi := &file_inference_inference_query_proto_msgTypes[158]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *Grantee) String() string {
+func (x *QueryRandomSeedsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*Grantee) ProtoMessage() {}
-
-// Deprecated: Use Grantee.ProtoReflect.Descriptor instead.
-func (*Grantee) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{139}
-}
+func (*QueryRandomSeedsRequest) ProtoMessage() {}
 
-func (x *Grantee) GetAddress() string {
-	if x != nil {
-		return x.Address
-	}
-	return ""
+// Deprecated: Use QueryRandomSeedsRequest.ProtoReflect.Descriptor instead.
+func (*QueryRandomSeedsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{158}
 }
 
-func (x *Grantee) GetPubKey() string {
+func (x *QueryRandomSeedsRequest) GetEpochIndex() uint64 {
 	if x != nil {
-		return x.PubKey
+		return x.EpochIndex
 	}
-	return ""
+	return 0
 }
 
-type QueryGranteesByMessageTypeResponse struct {
+// QueryRandomSeedsResponse is response type for the Query/RandomSeeds RPC method.
+type QueryRandomSeedsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Grantees []*Grantee `protobuf:"bytes,1,rep,name=grantees,proto3" json:"grantees,omitempty"`
+	Seeds []*RandomSeed `protobuf:"bytes,1,rep,name=seeds,proto3" json:"seeds,omitempty"`
 }
 
-func (x *QueryGranteesByMessageTypeResponse) Reset() {
-	*x = QueryGranteesByMessageTypeResponse{}
+func (x *QueryRandomSeedsResponse) Reset() {
+	*x = QueryRandomSeedsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[140]
+		mi := &file_inference_inference_query_proto_msgTypes[159]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGranteesByMessageTypeResponse) String() string {
+func (x *QueryRandomSeedsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGranteesByMessageTypeResponse) ProtoMessage() {}
+func (*QueryRandomSeedsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGranteesByMessageTypeResponse.ProtoReflect.Descriptor instead.
-func (*QueryGranteesByMessageTypeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{140}
+// Deprecated: Use QueryRandomSeedsResponse.ProtoReflect.Descriptor instead.
+func (*QueryRandomSeedsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{159}
 }
 
-func (x *QueryGranteesByMessageTypeResponse) GetGrantees() []*Grantee {
+func (x *QueryRandomSeedsResponse) GetSeeds() []*RandomSeed {
 	if x != nil {
-		return x.Grantees
+		return x.Seeds
 	}
 	return nil
 }
 
-type QueryParticipantAllowListRequest struct {
+type QueryPoCValidationSnapshotRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	PocStageStartHeight int64 `protobuf:"varint,1,opt,name=poc_stage_start_height,json=pocStageStartHeight,proto3" json:"poc_stage_start_height,omitempty"`
 }
 
-func (x *QueryParticipantAllowListRequest) Reset() {
-	*x = QueryParticipantAllowListRequest{}
+func (x *QueryPoCValidationSnapshotRequest) Reset() {
+	*x = QueryPoCValidationSnapshotRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[141]
+		mi := &file_inference_inference_query_proto_msgTypes[160]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryParticipantAllowListRequest) String() string {
+func (x *QueryPoCValidationSnapshotRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryParticipantAllowListRequest) ProtoMessage() {}
+func (*QueryPoCValidationSnapshotRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryParticipantAllowListRequest.ProtoReflect.Descriptor instead.
-func (*QueryParticipantAllowListRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{141}
+// Deprecated: Use QueryPoCValidationSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*QueryPoCValidationSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{160}
 }
 
-type QueryParticipantAllowListResponse struct {
+func (x *QueryPoCValidationSnapshotRequest) GetPocStageStartHeight() int64 {
+	if x != nil {
+		return x.PocStageStartHeight
+	}
+	return 0
+}
+
+type QueryPoCValidationSnapshotResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
+	Snapshot *PoCValidationSnapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
+	Found    bool                   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryParticipantAllowListResponse) Reset() {
-	*x = QueryParticipantAllowListResponse{}
+func (x *QueryPoCValidationSnapshotResponse) Reset() {
+	*x = QueryPoCValidationSnapshotResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[142]
+		mi := &file_inference_inference_query_proto_msgTypes[161]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryParticipantAllowListResponse) String() string {
+func (x *QueryPoCValidationSnapshotResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryParticipantAllowListResponse) ProtoMessage() {}
+func (*QueryPoCValidationSnapshotResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryParticipantAllowListResponse.ProtoReflect.Descriptor instead.
-func (*QueryParticipantAllowListResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{142}
+// Deprecated: Use QueryPoCValidationSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*QueryPoCValidationSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{161}
 }
 
-func (x *QueryParticipantAllowListResponse) GetAddresses() []string {
+func (x *QueryPoCValidationSnapshotResponse) GetSnapshot() *PoCValidationSnapshot {
 	if x != nil {
-		return x.Addresses
+		return x.Snapshot
 	}
 	return nil
 }
 
-type QueryGetMLNodeVersionRequest struct {
+func (x *QueryPoCValidationSnapshotResponse) GetFound() bool {
+	if x != nil {
+		return x.Found
+	}
+	return false
+}
+
+type QueryPreservedNodesSnapshotRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 }
 
-func (x *QueryGetMLNodeVersionRequest) Reset() {
-	*x = QueryGetMLNodeVersionRequest{}
+func (x *QueryPreservedNodesSnapshotRequest) Reset() {
+	*x = QueryPreservedNodesSnapshotRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[143]
+		mi := &file_inference_inference_query_proto_msgTypes[162]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetMLNodeVersionRequest) String() string {
+func (x *QueryPreservedNodesSnapshotRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetMLNodeVersionRequest) ProtoMessage() {}
+func (*QueryPreservedNodesSnapshotRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetMLNodeVersionRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetMLNodeVersionRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{143}
+// Deprecated: Use QueryPreservedNodesSnapshotRequest.ProtoReflect.Descriptor instead.
+func (*QueryPreservedNodesSnapshotRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{162}
 }
 
-type QueryGetMLNodeVersionResponse struct {
+type QueryPreservedNodesSnapshotResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	MlnodeVersion *MLNodeVersion `protobuf:"bytes,1,opt,name=mlnode_version,json=mlnodeVersion,proto3" json:"mlnode_version,omitempty"`
+	Snapshot *PreservedNodesSnapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
+	Found    bool                    `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryGetMLNodeVersionResponse) Reset() {
-	*x = QueryGetMLNodeVersionResponse{}
+func (x *QueryPreservedNodesSnapshotResponse) Reset() {
+	*x = QueryPreservedNodesSnapshotResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[144]
+		mi := &file_inference_inference_query_proto_msgTypes[163]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetMLNodeVersionResponse) String() string {
+func (x *QueryPreservedNodesSnapshotResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetMLNodeVersionResponse) ProtoMessage() {}
+func (*QueryPreservedNodesSnapshotResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetMLNodeVersionResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetMLNodeVersionResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{144}
+// Deprecated: Use QueryPreservedNodesSnapshotResponse.ProtoReflect.Descriptor instead.
+func (*QueryPreservedNodesSnapshotResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{163}
 }
 
-func (x *QueryGetMLNodeVersionResponse) GetMlnodeVersion() *MLNodeVersion {
+func (x *QueryPreservedNodesSnapshotResponse) GetSnapshot() *PreservedNodesSnapshot {
 	if x != nil {
-		return x.MlnodeVersion
+		return x.Snapshot
 	}
 	return nil
 }
 
-// QueryExcludedParticipantsRequest requests excluded participants for an epoch.
-// If epoch_index is 0, the query should return for the current effective epoch.
-type QueryExcludedParticipantsRequest struct {
+func (x *QueryPreservedNodesSnapshotResponse) GetFound() bool {
+	if x != nil {
+		return x.Found
+	}
+	return false
+}
+
+type QueryGetDevshardEscrowRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
 }
 
-func (x *QueryExcludedParticipantsRequest) Reset() {
-	*x = QueryExcludedParticipantsRequest{}
+func (x *QueryGetDevshardEscrowRequest) Reset() {
+	*x = QueryGetDevshardEscrowRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[145]
+		mi := &file_inference_inference_query_proto_msgTypes[164]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryExcludedParticipantsRequest) String() string {
+func (x *QueryGetDevshardEscrowRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryExcludedParticipantsRequest) ProtoMessage() {}
+func (*QueryGetDevshardEscrowRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryExcludedParticipantsRequest.ProtoReflect.Descriptor instead.
-func (*QueryExcludedParticipantsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{145}
+// Deprecated: Use QueryGetDevshardEscrowRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetDevshardEscrowRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{164}
 }
 
-func (x *QueryExcludedParticipantsRequest) GetEpochIndex() uint64 {
+func (x *QueryGetDevshardEscrowRequest) GetId() uint64 {
 	if x != nil {
-		return x.EpochIndex
+		return x.Id
 	}
 	return 0
 }
 
-// QueryExcludedParticipantsResponse returns a list of excluded participants for the epoch.
-type QueryExcludedParticipantsResponse struct {
+type QueryGetDevshardEscrowResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Items []*ExcludedParticipant `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
+	Escrow *DevshardEscrow `protobuf:"bytes,1,opt,name=escrow,proto3" json:"escrow,omitempty"`
+	Found  bool            `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryExcludedParticipantsResponse) Reset() {
-	*x = QueryExcludedParticipantsResponse{}
+func (x *QueryGetDevshardEscrowResponse) Reset() {
+	*x = QueryGetDevshardEscrowResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[146]
+		mi := &file_inference_inference_query_proto_msgTypes[165]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryExcludedParticipantsResponse) String() string {
+func (x *QueryGetDevshardEscrowResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryExcludedParticipantsResponse) ProtoMessage() {}
+func (*QueryGetDevshardEscrowResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryExcludedParticipantsResponse.ProtoReflect.Descriptor instead.
-func (*QueryExcludedParticipantsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{146}
+// Deprecated: Use QueryGetDevshardEscrowResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetDevshardEscrowResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{165}
 }
 
-func (x *QueryExcludedParticipantsResponse) GetItems() []*ExcludedParticipant {
+func (x *QueryGetDevshardEscrowResponse) GetEscrow() *DevshardEscrow {
 	if x != nil {
-		return x.Items
+		return x.Escrow
 	}
 	return nil
 }
 
-// QueryActiveConfirmationPoCEventRequest is request type for the Query/ActiveConfirmationPoCEvent RPC method.
-type QueryActiveConfirmationPoCEventRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-}
-
-func (x *QueryActiveConfirmationPoCEventRequest) Reset() {
-	*x = QueryActiveConfirmationPoCEventRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[147]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
+func (x *QueryGetDevshardEscrowResponse) GetFound() bool {
+	if x != nil {
+		return x.Found
 	}
+	return false
 }
 
-func (x *QueryActiveConfirmationPoCEventRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*QueryActiveConfirmationPoCEventRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryActiveConfirmationPoCEventRequest.ProtoReflect.Descriptor instead.
-func (*QueryActiveConfirmationPoCEventRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{147}
-}
-
-// QueryActiveConfirmationPoCEventResponse is response type for the Query/ActiveConfirmationPoCEvent RPC method.
-type QueryActiveConfirmationPoCEventResponse struct {
+type QueryGetDevshardHostEpochStatsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	IsActive bool                  `protobuf:"varint,1,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
-	Event    *ConfirmationPoCEvent `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
+	EpochIndex  uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	Participant string `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryActiveConfirmationPoCEventResponse) Reset() {
-	*x = QueryActiveConfirmationPoCEventResponse{}
+func (x *QueryGetDevshardHostEpochStatsRequest) Reset() {
+	*x = QueryGetDevshardHostEpochStatsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[148]
+		mi := &file_inference_inference_query_proto_msgTypes[166]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryActiveConfirmationPoCEventResponse) String() string {
+func (x *QueryGetDevshardHostEpochStatsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryActiveConfirmationPoCEventResponse) ProtoMessage() {}
+func (*QueryGetDevshardHostEpochStatsRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryActiveConfirmationPoCEventResponse.ProtoReflect.Descriptor instead.
-func (*QueryActiveConfirmationPoCEventResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{148}
+// Deprecated: Use QueryGetDevshardHostEpochStatsRequest.ProtoReflect.Descriptor instead.
+func (*QueryGetDevshardHostEpochStatsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{166}
 }
 
-func (x *QueryActiveConfirmationPoCEventResponse) GetIsActive() bool {
+func (x *QueryGetDevshardHostEpochStatsRequest) GetEpochIndex() uint64 {
 	if x != nil {
-		return x.IsActive
+		return x.EpochIndex
 	}
-	return false
+	return 0
 }
 
-func (x *QueryActiveConfirmationPoCEventResponse) GetEvent() *ConfirmationPoCEvent {
+func (x *QueryGetDevshardHostEpochStatsRequest) GetParticipant() string {
 	if x != nil {
-		return x.Event
+		return x.Participant
 	}
-	return nil
+	return ""
 }
 
-// QueryConfirmationPoCEventsRequest is request type for the Query/ConfirmationPoCEvents RPC method.
-type QueryConfirmationPoCEventsRequest struct {
+type QueryGetDevshardHostEpochStatsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	Stats *DevshardHostEpochStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
+	Found bool                    `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryConfirmationPoCEventsRequest) Reset() {
-	*x = QueryConfirmationPoCEventsRequest{}
+func (x *QueryGetDevshardHostEpochStatsResponse) Reset() {
+	*x = QueryGetDevshardHostEpochStatsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[149]
+		mi := &file_inference_inference_query_proto_msgTypes[167]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryConfirmationPoCEventsRequest) String() string {
+func (x *QueryGetDevshardHostEpochStatsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryConfirmationPoCEventsRequest) ProtoMessage() {}
+func (*QueryGetDevshardHostEpochStatsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryConfirmationPoCEventsRequest.ProtoReflect.Descriptor instead.
-func (*QueryConfirmationPoCEventsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{149}
+// Deprecated: Use QueryGetDevshardHostEpochStatsResponse.ProtoReflect.Descriptor instead.
+func (*QueryGetDevshardHostEpochStatsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{167}
 }
 
-func (x *QueryConfirmationPoCEventsRequest) GetEpochIndex() uint64 {
+func (x *QueryGetDevshardHostEpochStatsResponse) GetStats() *DevshardHostEpochStats {
 	if x != nil {
-		return x.EpochIndex
+		return x.Stats
 	}
-	return 0
+	return nil
 }
 
-// QueryConfirmationPoCEventsResponse is response type for the Query/ConfirmationPoCEvents RPC method.
-type QueryConfirmationPoCEventsResponse struct {
+func (x *QueryGetDevshardHostEpochStatsResponse) GetFound() bool {
+	if x != nil {
+		return x.Found
+	}
+	return false
+}
+
+type QueryMaintenanceCreditRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Events []*ConfirmationPoCEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryConfirmationPoCEventsResponse) Reset() {
-	*x = QueryConfirmationPoCEventsResponse{}
+func (x *QueryMaintenanceCreditRequest) Reset() {
+	*x = QueryMaintenanceCreditRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[150]
+		mi := &file_inference_inference_query_proto_msgTypes[168]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryConfirmationPoCEventsResponse) String() string {
+func (x *QueryMaintenanceCreditRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryConfirmationPoCEventsResponse) ProtoMessage() {}
+func (*QueryMaintenanceCreditRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryConfirmationPoCEventsResponse.ProtoReflect.Descriptor instead.
-func (*QueryConfirmationPoCEventsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{150}
+// Deprecated: Use QueryMaintenanceCreditRequest.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceCreditRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{168}
 }
 
-func (x *QueryConfirmationPoCEventsResponse) GetEvents() []*ConfirmationPoCEvent {
+func (x *QueryMaintenanceCreditRequest) GetParticipant() string {
 	if x != nil {
-		return x.Events
+		return x.Participant
 	}
-	return nil
+	return ""
 }
 
-// ParticipantWithBalance contains participant data along with their bank balance.
-type ParticipantWithBalance struct {
+type QueryMaintenanceCreditResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participant *Participant     `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
-	Balances    []*v1beta11.Coin `protobuf:"bytes,2,rep,name=balances,proto3" json:"balances,omitempty"`
+	CreditBlocks uint64 `protobuf:"varint,1,opt,name=credit_blocks,json=creditBlocks,proto3" json:"credit_blocks,omitempty"`
+	Found        bool   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *ParticipantWithBalance) Reset() {
-	*x = ParticipantWithBalance{}
+func (x *QueryMaintenanceCreditResponse) Reset() {
+	*x = QueryMaintenanceCreditResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[151]
+		mi := &file_inference_inference_query_proto_msgTypes[169]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *ParticipantWithBalance) String() string {
+func (x *QueryMaintenanceCreditResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ParticipantWithBalance) ProtoMessage() {}
+func (*QueryMaintenanceCreditResponse) ProtoMessage() {}
 
-// Deprecated: Use ParticipantWithBalance.ProtoReflect.Descriptor instead.
-func (*ParticipantWithBalance) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{151}
+// Deprecated: Use QueryMaintenanceCreditResponse.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceCreditResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{169}
 }
 
-func (x *ParticipantWithBalance) GetParticipant() *Participant {
+func (x *QueryMaintenanceCreditResponse) GetCreditBlocks() uint64 {
 	if x != nil {
-		return x.Participant
+		return x.CreditBlocks
 	}
-	return nil
+	return 0
 }
 
-func (x *ParticipantWithBalance) GetBalances() []*v1beta11.Coin {
+func (x *QueryMaintenanceCreditResponse) GetFound() bool {
 	if x != nil {
-		return x.Balances
+		return x.Found
 	}
-	return nil
+	return false
 }
 
-// QueryParticipantsWithBalancesRequest is request type for the Query/ParticipantsWithBalances RPC method.
-type QueryParticipantsWithBalancesRequest struct {
+type QueryMaintenanceScheduledRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Pagination *v1beta1.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryParticipantsWithBalancesRequest) Reset() {
-	*x = QueryParticipantsWithBalancesRequest{}
+func (x *QueryMaintenanceScheduledRequest) Reset() {
+	*x = QueryMaintenanceScheduledRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[152]
+		mi := &file_inference_inference_query_proto_msgTypes[170]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryParticipantsWithBalancesRequest) String() string {
+func (x *QueryMaintenanceScheduledRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryParticipantsWithBalancesRequest) ProtoMessage() {}
+func (*QueryMaintenanceScheduledRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryParticipantsWithBalancesRequest.ProtoReflect.Descriptor instead.
-func (*QueryParticipantsWithBalancesRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{152}
+// Deprecated: Use QueryMaintenanceScheduledRequest.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceScheduledRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{170}
 }
 
-func (x *QueryParticipantsWithBalancesRequest) GetPagination() *v1beta1.PageRequest {
+func (x *QueryMaintenanceScheduledRequest) GetParticipant() string {
 	if x != nil {
-		return x.Pagination
+		return x.Participant
 	}
-	return nil
+	return ""
 }
 
-// QueryParticipantsWithBalancesResponse is response type for the Query/ParticipantsWithBalances RPC method.
-type QueryParticipantsWithBalancesResponse struct {
+type QueryMaintenanceScheduledResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Participants []*ParticipantWithBalance `protobuf:"bytes,1,rep,name=participants,proto3" json:"participants,omitempty"`
-	Pagination   *v1beta1.PageResponse     `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
-	BlockHeight  int64                     `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	Reservation *MaintenanceReservation `protobuf:"bytes,1,opt,name=reservation,proto3" json:"reservation,omitempty"`
+	Found       bool                    `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryParticipantsWithBalancesResponse) Reset() {
-	*x = QueryParticipantsWithBalancesResponse{}
+func (x *QueryMaintenanceScheduledResponse) Reset() {
+	*x = QueryMaintenanceScheduledResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[153]
+		mi := &file_inference_inference_query_proto_msgTypes[171]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryParticipantsWithBalancesResponse) String() string {
+func (x *QueryMaintenanceScheduledResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryParticipantsWithBalancesResponse) ProtoMessage() {}
-
-// Deprecated: Use QueryParticipantsWithBalancesResponse.ProtoReflect.Descriptor instead.
-func (*QueryParticipantsWithBalancesResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{153}
-}
+func (*QueryMaintenanceScheduledResponse) ProtoMessage() {}
 
-func (x *QueryParticipantsWithBalancesResponse) GetParticipants() []*ParticipantWithBalance {
-	if x != nil {
-		return x.Participants
-	}
-	return nil
+// Deprecated: Use QueryMaintenanceScheduledResponse.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceScheduledResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{171}
 }
 
-func (x *QueryParticipantsWithBalancesResponse) GetPagination() *v1beta1.PageResponse {
+func (x *QueryMaintenanceScheduledResponse) GetReservation() *MaintenanceReservation {
 	if x != nil {
-		return x.Pagination
+		return x.Reservation
 	}
 	return nil
 }
 
-func (x *QueryParticipantsWithBalancesResponse) GetBlockHeight() int64 {
+func (x *QueryMaintenanceScheduledResponse) GetFound() bool {
 	if x != nil {
-		return x.BlockHeight
+		return x.Found
 	}
-	return 0
+	return false
 }
 
-// QueryRandomSeedsRequest is request type for the Query/RandomSeeds RPC method.
-type QueryRandomSeedsRequest struct {
+type QueryMaintenanceActiveRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
-
-	EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
 }
 
-func (x *QueryRandomSeedsRequest) Reset() {
-	*x = QueryRandomSeedsRequest{}
+func (x *QueryMaintenanceActiveRequest) Reset() {
+	*x = QueryMaintenanceActiveRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[154]
+		mi := &file_inference_inference_query_proto_msgTypes[172]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryRandomSeedsRequest) String() string {
+func (x *QueryMaintenanceActiveRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryRandomSeedsRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryRandomSeedsRequest.ProtoReflect.Descriptor instead.
-func (*QueryRandomSeedsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{154}
-}
+func (*QueryMaintenanceActiveRequest) ProtoMessage() {}
 
-func (x *QueryRandomSeedsRequest) GetEpochIndex() uint64 {
-	if x != nil {
-		return x.EpochIndex
-	}
-	return 0
+// Deprecated: Use QueryMaintenanceActiveRequest.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceActiveRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{172}
 }
 
-// QueryRandomSeedsResponse is response type for the Query/RandomSeeds RPC method.
-type QueryRandomSeedsResponse struct {
+type QueryMaintenanceActiveResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Seeds []*RandomSeed `protobuf:"bytes,1,rep,name=seeds,proto3" json:"seeds,omitempty"`
+	Reservations []*MaintenanceReservation `protobuf:"bytes,1,rep,name=reservations,proto3" json:"reservations,omitempty"`
 }
 
-func (x *QueryRandomSeedsResponse) Reset() {
-	*x = QueryRandomSeedsResponse{}
+func (x *QueryMaintenanceActiveResponse) Reset() {
+	*x = QueryMaintenanceActiveResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[155]
+		mi := &file_inference_inference_query_proto_msgTypes[173]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryRandomSeedsResponse) String() string {
+func (x *QueryMaintenanceActiveResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryRandomSeedsResponse) ProtoMessage() {}
+func (*QueryMaintenanceActiveResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryRandomSeedsResponse.ProtoReflect.Descriptor instead.
-func (*QueryRandomSeedsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{155}
+// Deprecated: Use QueryMaintenanceActiveResponse.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceActiveResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{173}
 }
 
-func (x *QueryRandomSeedsResponse) GetSeeds() []*RandomSeed {
+func (x *QueryMaintenanceActiveResponse) GetReservations() []*MaintenanceReservation {
 	if x != nil {
-		return x.Seeds
+		return x.Reservations
 	}
 	return nil
 }
 
-type QueryPoCValidationSnapshotRequest struct {
+type QueryMaintenanceStatusRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	PocStageStartHeight int64 `protobuf:"varint,1,opt,name=poc_stage_start_height,json=pocStageStartHeight,proto3" json:"poc_stage_start_height,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryPoCValidationSnapshotRequest) Reset() {
-	*x = QueryPoCValidationSnapshotRequest{}
+func (x *QueryMaintenanceStatusRequest) Reset() {
+	*x = QueryMaintenanceStatusRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[156]
+		mi := &file_inference_inference_query_proto_msgTypes[174]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPoCValidationSnapshotRequest) String() string {
+func (x *QueryMaintenanceStatusRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPoCValidationSnapshotRequest) ProtoMessage() {}
+func (*QueryMaintenanceStatusRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryPoCValidationSnapshotRequest.ProtoReflect.Descriptor instead.
-func (*QueryPoCValidationSnapshotRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{156}
+// Deprecated: Use QueryMaintenanceStatusRequest.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceStatusRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{174}
 }
 
-func (x *QueryPoCValidationSnapshotRequest) GetPocStageStartHeight() int64 {
+func (x *QueryMaintenanceStatusRequest) GetParticipant() string {
 	if x != nil {
-		return x.PocStageStartHeight
+		return x.Participant
 	}
-	return 0
+	return ""
 }
 
-type QueryPoCValidationSnapshotResponse struct {
+type QueryMaintenanceStatusResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Snapshot *PoCValidationSnapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
-	Found    bool                   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	State                *MaintenanceState       `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
+	ActiveReservation    *MaintenanceReservation `protobuf:"bytes,2,opt,name=active_reservation,json=activeReservation,proto3" json:"active_reservation,omitempty"`
+	ScheduledReservation *MaintenanceReservation `protobuf:"bytes,3,opt,name=scheduled_reservation,json=scheduledReservation,proto3" json:"scheduled_reservation,omitempty"`
+	Found                bool                    `protobuf:"varint,4,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (x *QueryPoCValidationSnapshotResponse) Reset() {
-	*x = QueryPoCValidationSnapshotResponse{}
+func (x *QueryMaintenanceStatusResponse) Reset() {
+	*x = QueryMaintenanceStatusResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[157]
+		mi := &file_inference_inference_query_proto_msgTypes[175]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPoCValidationSnapshotResponse) String() string {
+func (x *QueryMaintenanceStatusResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPoCValidationSnapshotResponse) ProtoMessage() {}
+func (*QueryMaintenanceStatusResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryPoCValidationSnapshotResponse.ProtoReflect.Descriptor instead.
-func (*QueryPoCValidationSnapshotResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{157}
+// Deprecated: Use QueryMaintenanceStatusResponse.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceStatusResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{175}
 }
 
-func (x *QueryPoCValidationSnapshotResponse) GetSnapshot() *PoCValidationSnapshot {
+func (x *QueryMaintenanceStatusResponse) GetState() *MaintenanceState {
 	if x != nil {
-		return x.Snapshot
+		return x.State
 	}
 	return nil
 }
 
-func (x *QueryPoCValidationSnapshotResponse) GetFound() bool {
+func (x *QueryMaintenanceStatusResponse) GetActiveReservation() *MaintenanceReservation {
+	if x != nil {
+		return x.ActiveReservation
+	}
+	return nil
+}
+
+func (x *QueryMaintenanceStatusResponse) GetScheduledReservation() *MaintenanceReservation {
+	if x != nil {
+		return x.ScheduledReservation
+	}
+	return nil
+}
+
+func (x *QueryMaintenanceStatusResponse) GetFound() bool {
 	if x != nil {
 		return x.Found
 	}
 	return false
 }
 
-type QueryPreservedNodesSnapshotRequest struct {
+type QueryMaintenanceConcurrencyRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
+
+	Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
 }
 
-func (x *QueryPreservedNodesSnapshotRequest) Reset() {
-	*x = QueryPreservedNodesSnapshotRequest{}
+func (x *QueryMaintenanceConcurrencyRequest) Reset() {
+	*x = QueryMaintenanceConcurrencyRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[158]
+		mi := &file_inference_inference_query_proto_msgTypes[176]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPreservedNodesSnapshotRequest) String() string {
+func (x *QueryMaintenanceConcurrencyRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPreservedNodesSnapshotRequest) ProtoMessage() {}
+func (*QueryMaintenanceConcurrencyRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryPreservedNodesSnapshotRequest.ProtoReflect.Descriptor instead.
-func (*QueryPreservedNodesSnapshotRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{158}
+// Deprecated: Use QueryMaintenanceConcurrencyRequest.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceConcurrencyRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{176}
 }
 
-type QueryPreservedNodesSnapshotResponse struct {
+func (x *QueryMaintenanceConcurrencyRequest) GetHeight() int64 {
+	if x != nil {
+		return x.Height
+	}
+	return 0
+}
+
+type QueryMaintenanceConcurrencyResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Snapshot *PreservedNodesSnapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
-	Found    bool                    `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	ConcurrentCount    uint32 `protobuf:"varint,1,opt,name=concurrent_count,json=concurrentCount,proto3" json:"concurrent_count,omitempty"`
+	ConcurrentPowerBps int64  `protobuf:"varint,2,opt,name=concurrent_power_bps,json=concurrentPowerBps,proto3" json:"concurrent_power_bps,omitempty"`
 }
 
-func (x *QueryPreservedNodesSnapshotResponse) Reset() {
-	*x = QueryPreservedNodesSnapshotResponse{}
+func (x *QueryMaintenanceConcurrencyResponse) Reset() {
+	*x = QueryMaintenanceConcurrencyResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[159]
+		mi := &file_inference_inference_query_proto_msgTypes[177]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryPreservedNodesSnapshotResponse) String() string {
+func (x *QueryMaintenanceConcurrencyResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryPreservedNodesSnapshotResponse) ProtoMessage() {}
+func (*QueryMaintenanceConcurrencyResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryPreservedNodesSnapshotResponse.ProtoReflect.Descriptor instead.
-func (*QueryPreservedNodesSnapshotResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{159}
+// Deprecated: Use QueryMaintenanceConcurrencyResponse.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceConcurrencyResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{177}
 }
 
-func (x *QueryPreservedNodesSnapshotResponse) GetSnapshot() *PreservedNodesSnapshot {
+func (x *QueryMaintenanceConcurrencyResponse) GetConcurrentCount() uint32 {
 	if x != nil {
-		return x.Snapshot
+		return x.ConcurrentCount
 	}
-	return nil
+	return 0
 }
 
-func (x *QueryPreservedNodesSnapshotResponse) GetFound() bool {
+func (x *QueryMaintenanceConcurrencyResponse) GetConcurrentPowerBps() int64 {
 	if x != nil {
-		return x.Found
+		return x.ConcurrentPowerBps
 	}
-	return false
+	return 0
 }
 
-type QueryGetDevshardEscrowRequest struct {
+type QueryMaintenanceSchedulabilityRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+	Participant    string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	StartHeight    int64  `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
+	DurationBlocks uint64 `protobuf:"varint,3,opt,name=duration_blocks,json=durationBlocks,proto3" json:"duration_blocks,omitempty"`
 }
 
-func (x *QueryGetDevshardEscrowRequest) Reset() {
-	*x = QueryGetDevshardEscrowRequest{}
+func (x *QueryMaintenanceSchedulabilityRequest) Reset() {
+	*x = QueryMaintenanceSchedulabilityRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[160]
+		mi := &file_inference_inference_query_proto_msgTypes[178]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetDevshardEscrowRequest) String() string {
+func (x *QueryMaintenanceSchedulabilityRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetDevshardEscrowRequest) ProtoMessage() {}
+func (*QueryMaintenanceSchedulabilityRequest) ProtoMessage() {}
 
-// Deprecated: Use QueryGetDevshardEscrowRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetDevshardEscrowRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{160}
+// Deprecated: Use QueryMaintenanceSchedulabilityRequest.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceSchedulabilityRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{178}
 }
 
-func (x *QueryGetDevshardEscrowRequest) GetId() uint64 {
+func (x *QueryMaintenanceSchedulabilityRequest) GetParticipant() string {
 	if x != nil {
-		return x.Id
+		return x.Participant
+	}
+	return ""
+}
+
+func (x *QueryMaintenanceSchedulabilityRequest) GetStartHeight() int64 {
+	if x != nil {
+		return x.StartHeight
 	}
 	return 0
 }
 
-type QueryGetDevshardEscrowResponse struct {
+func (x *QueryMaintenanceSchedulabilityRequest) GetDurationBlocks() uint64 {
+	if x != nil {
+		return x.DurationBlocks
+	}
+	return 0
+}
+
+type QueryMaintenanceSchedulabilityResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Escrow *DevshardEscrow `protobuf:"bytes,1,opt,name=escrow,proto3" json:"escrow,omitempty"`
-	Found  bool            `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	Schedulable     bool   `protobuf:"varint,1,opt,name=schedulable,proto3" json:"schedulable,omitempty"`
+	RejectionReason string `protobuf:"bytes,2,opt,name=rejection_reason,json=rejectionReason,proto3" json:"rejection_reason,omitempty"`
 }
 
-func (x *QueryGetDevshardEscrowResponse) Reset() {
-	*x = QueryGetDevshardEscrowResponse{}
+func (x *QueryMaintenanceSchedulabilityResponse) Reset() {
+	*x = QueryMaintenanceSchedulabilityResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[161]
+		mi := &file_inference_inference_query_proto_msgTypes[179]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetDevshardEscrowResponse) String() string {
+func (x *QueryMaintenanceSchedulabilityResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetDevshardEscrowResponse) ProtoMessage() {}
+func (*QueryMaintenanceSchedulabilityResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetDevshardEscrowResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetDevshardEscrowResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{161}
+// Deprecated: Use QueryMaintenanceSchedulabilityResponse.ProtoReflect.Descriptor instead.
+func (*QueryMaintenanceSchedulabilityResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{179}
 }
 
-func (x *QueryGetDevshardEscrowResponse) GetEscrow() *DevshardEscrow {
+func (x *QueryMaintenanceSchedulabilityResponse) GetSchedulable() bool {
 	if x != nil {
-		return x.Escrow
+		return x.Schedulable
 	}
-	return nil
+	return false
 }
 
-func (x *QueryGetDevshardEscrowResponse) GetFound() bool {
+func (x *QueryMaintenanceSchedulabilityResponse) GetRejectionReason() string {
 	if x != nil {
-		return x.Found
+		return x.RejectionReason
 	}
-	return false
+	return ""
 }
 
-type QueryGetDevshardHostEpochStatsRequest struct {
+type QueryListClaimRecipientsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	EpochIndex  uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
-	Participant string `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (x *QueryGetDevshardHostEpochStatsRequest) Reset() {
-	*x = QueryGetDevshardHostEpochStatsRequest{}
+func (x *QueryListClaimRecipientsRequest) Reset() {
+	*x = QueryListClaimRecipientsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[162]
+		mi := &file_inference_inference_query_proto_msgTypes[180]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetDevshardHostEpochStatsRequest) String() string {
+func (x *QueryListClaimRecipientsRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetDevshardHostEpochStatsRequest) ProtoMessage() {}
-
-// Deprecated: Use QueryGetDevshardHostEpochStatsRequest.ProtoReflect.Descriptor instead.
-func (*QueryGetDevshardHostEpochStatsRequest) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{162}
-}
+func (*QueryListClaimRecipientsRequest) ProtoMessage() {}
 
-func (x *QueryGetDevshardHostEpochStatsRequest) GetEpochIndex() uint64 {
-	if x != nil {
-		return x.EpochIndex
-	}
-	return 0
+// Deprecated: Use QueryListClaimRecipientsRequest.ProtoReflect.Descriptor instead.
+func (*QueryListClaimRecipientsRequest) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{180}
 }
 
-func (x *QueryGetDevshardHostEpochStatsRequest) GetParticipant() string {
+func (x *QueryListClaimRecipientsRequest) GetParticipant() string {
 	if x != nil {
 		return x.Participant
 	}
 	return ""
 }
 
-type QueryGetDevshardHostEpochStatsResponse struct {
+type QueryListClaimRecipientsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Stats *DevshardHostEpochStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"`
-	Found bool                    `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+	Entries []*ClaimRecipientEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
 }
 
-func (x *QueryGetDevshardHostEpochStatsResponse) Reset() {
-	*x = QueryGetDevshardHostEpochStatsResponse{}
+func (x *QueryListClaimRecipientsResponse) Reset() {
+	*x = QueryListClaimRecipientsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[163]
+		mi := &file_inference_inference_query_proto_msgTypes[181]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
 }
 
-func (x *QueryGetDevshardHostEpochStatsResponse) String() string {
+func (x *QueryListClaimRecipientsResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*QueryGetDevshardHostEpochStatsResponse) ProtoMessage() {}
+func (*QueryListClaimRecipientsResponse) ProtoMessage() {}
 
-// Deprecated: Use QueryGetDevshardHostEpochStatsResponse.ProtoReflect.Descriptor instead.
-func (*QueryGetDevshardHostEpochStatsResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{163}
+// Deprecated: Use QueryListClaimRecipientsResponse.ProtoReflect.Descriptor instead.
+func (*QueryListClaimRecipientsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{181}
 }
 
-func (x *QueryGetDevshardHostEpochStatsResponse) GetStats() *DevshardHostEpochStats {
+func (x *QueryListClaimRecipientsResponse) GetEntries() []*ClaimRecipientEntry {
 	if x != nil {
-		return x.Stats
+		return x.Entries
 	}
 	return nil
 }
 
-func (x *QueryGetDevshardHostEpochStatsResponse) GetFound() bool {
-	if x != nil {
-		return x.Found
-	}
-	return false
-}
-
 type QueryDebugStatsResponse_TemporaryTimeStat struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -84382,7 +93206,7 @@ type QueryDebugStatsResponse_TemporaryTimeStat struct {
 func (x *QueryDebugStatsResponse_TemporaryTimeStat) Reset() {
 	*x = QueryDebugStatsResponse_TemporaryTimeStat{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[164]
+		mi := &file_inference_inference_query_proto_msgTypes[182]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -84396,7 +93220,7 @@ func (*QueryDebugStatsResponse_TemporaryTimeStat) ProtoMessage() {}
 
 // Deprecated: Use QueryDebugStatsResponse_TemporaryTimeStat.ProtoReflect.Descriptor instead.
 func (*QueryDebugStatsResponse_TemporaryTimeStat) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{98, 0}
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{100, 0}
 }
 
 func (x *QueryDebugStatsResponse_TemporaryTimeStat) GetDeveloper() string {
@@ -84425,7 +93249,7 @@ type QueryDebugStatsResponse_TemporaryEpochStat struct {
 func (x *QueryDebugStatsResponse_TemporaryEpochStat) Reset() {
 	*x = QueryDebugStatsResponse_TemporaryEpochStat{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_query_proto_msgTypes[165]
+		mi := &file_inference_inference_query_proto_msgTypes[183]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -84439,7 +93263,7 @@ func (*QueryDebugStatsResponse_TemporaryEpochStat) ProtoMessage() {}
 
 // Deprecated: Use QueryDebugStatsResponse_TemporaryEpochStat.ProtoReflect.Descriptor instead.
 func (*QueryDebugStatsResponse_TemporaryEpochStat) Descriptor() ([]byte, []int) {
-	return file_inference_inference_query_proto_rawDescGZIP(), []int{98, 1}
+	return file_inference_inference_query_proto_rawDescGZIP(), []int{100, 1}
 }
 
 func (x *QueryDebugStatsResponse_TemporaryEpochStat) GetDeveloper() string {
@@ -84540,2213 +93364,2456 @@ var file_inference_inference_query_proto_rawDesc = []byte{
 	0x6f, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65,
 	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x1a, 0x32, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76,
-	0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x28, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63,
-	0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x22, 0x14, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x55, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e,
-	0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f,
-	0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x30,
-	0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e,
-	0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78,
-	0x22, 0x5f, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a,
-	0x09, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x22, 0x62, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a,
+	0x6f, 0x74, 0x6f, 0x1a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x32, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f,
+	0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x28,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6c,
+	0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x22, 0x14, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x55, 0x0a, 0x13, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x3e, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8,
+	0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x22, 0x30, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05,
+	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69, 0x6e, 0x64,
+	0x65, 0x78, 0x22, 0x5f, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x42, 0x0a, 0x09, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x22, 0x62, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa8, 0x01, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72,
+	0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x22, 0x32, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x67, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22,
+	0x64, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a,
 	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
 	0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e,
 	0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61,
 	0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa8, 0x01, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
-	0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x09, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xd3, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
+	0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12,
+	0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61,
+	0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b,
+	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x38, 0x0a, 0x1c, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x67, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63,
+	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x18,
+	0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6e, 0x6f,
+	0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x22, 0x35,
+	0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d,
+	0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x22, 0x64, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
+	0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x65, 0x78, 0x65, 0x63, 0x75,
+	0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f,
+	0x00, 0x52, 0x08, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x22, 0x5b, 0x0a, 0x1d, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75,
+	0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x19, 0x0a,
+	0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x75, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61,
+	0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52,
+	0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x22,
+	0x67, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61,
+	0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbe, 0x01, 0x0a, 0x1e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44,
+	0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65,
+	0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63,
+	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
+	0x52, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61,
+	0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70,
+	0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3f, 0x0a, 0x1b, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e,
+	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x6c, 0x0a, 0x1c, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0d, 0x73, 0x65,
+	0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x73, 0x65, 0x74, 0x74,
+	0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x65, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f,
 	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e,
-	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x22, 0x32, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14,
-	0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x69,
-	0x6e, 0x64, 0x65, 0x78, 0x22, 0x67, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
-	0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x64, 0x0a,
-	0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70,
-	0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75,
-	0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x22, 0xd3, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
-	0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x47, 0x0a,
-	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e,
-	0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61,
-	0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69,
-	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
-	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c,
-	0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x38, 0x0a, 0x1c, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x22, 0x67, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x63, 0x6f,
-	0x75, 0x6e, 0x74, 0x42, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07,
-	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62,
-	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x22, 0x35, 0x0a, 0x1d,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78,
-	0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a,
-	0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x22, 0x64, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x52,
-	0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x08, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f,
-	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52,
-	0x08, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x22, 0x5b, 0x0a, 0x1d, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44,
-	0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x19, 0x0a, 0x08, 0x6d,
-	0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d,
-	0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x75, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
-	0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72,
-	0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x65,
-	0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x22, 0x67, 0x0a,
-	0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72,
-	0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46,
-	0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65,
-	0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50,
-	0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69,
-	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbe, 0x01, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74,
-	0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47,
-	0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12, 0x47,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22,
+	0xb5, 0x01, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74,
+	0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x4c, 0x0a, 0x0d, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
+	0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65,
+	0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
+	0x52, 0x0c, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x47,
 	0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01,
 	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65,
 	0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50,
 	0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67,
-	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3f, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x6c, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0d, 0x73, 0x65, 0x74, 0x74,
-	0x6c, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75,
-	0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65,
-	0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x65, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
-	0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31,
-	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb5, 0x01,
-	0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65,
-	0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c,
-	0x0a, 0x0d, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18,
-	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x74,
-	0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c,
-	0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x47, 0x0a, 0x0a,
-	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71,
-	0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x69, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a,
-	0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12,
-	0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78,
-	0x22, 0x91, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f,
-	0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x17, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x6e,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x45, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52,
+	0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x72,
+	0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x42,
+	0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0d, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61,
+	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x15, 0x65,
+	0x65, 0x2e, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x04,
+	0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x22, 0x69, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70,
+	0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x91, 0x01,
+	0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47,
+	0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68,
+	0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45,
 	0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x22, 0x6e, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a,
-	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71,
-	0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67,
-	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x22, 0xda, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c,
-	0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68,
-	0x0a, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f,
-	0x00, 0x52, 0x15, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69,
-	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63,
-	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79,
-	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x22, 0x43, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74,
-	0x63, 0x68, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x75, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
-	0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52, 0x0a, 0x09, 0x70, 0x6f, 0x63,
-	0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69,
+	0x69, 0x6f, 0x6e, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x15, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x22, 0x6e, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f,
+	0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72,
+	0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x22, 0xda, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70,
+	0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x17, 0x65,
+	0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x57, 0x69, 0x74,
-	0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x42, 0x04, 0xc8,
-	0xde, 0x1f, 0x00, 0x52, 0x08, 0x70, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, 0xb9, 0x01,
-	0x0a, 0x1a, 0x50, 0x6f, 0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68,
+	0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x15,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x43,
+	0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65,
+	0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x22, 0x75, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x42,
+	0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52, 0x0a, 0x09, 0x70, 0x6f, 0x63, 0x5f, 0x62, 0x61,
+	0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x50, 0x6f, 0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
+	0x52, 0x08, 0x70, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, 0xb9, 0x01, 0x0a, 0x1a, 0x50,
+	0x6f, 0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70,
+	0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75,
+	0x62, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65, 0x78, 0x5f, 0x70, 0x75, 0x62, 0x5f,
+	0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x65, 0x78, 0x50, 0x75,
+	0x62, 0x4b, 0x65, 0x79, 0x12, 0x40, 0x0a, 0x09, 0x70, 0x6f, 0x63, 0x5f, 0x62, 0x61, 0x74, 0x63,
+	0x68, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f,
+	0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x08, 0x70, 0x6f,
+	0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, 0x47, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+	0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72,
+	0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c,
+	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22,
+	0x87, 0x01, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x60, 0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x63, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xcc, 0x01, 0x0a, 0x1e, 0x50, 0x6f,
+	0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74, 0x68,
 	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x20, 0x0a, 0x0b,
 	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
 	0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x17,
 	0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
 	0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65, 0x78, 0x5f, 0x70,
 	0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x65,
-	0x78, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x40, 0x0a, 0x09, 0x70, 0x6f, 0x63, 0x5f, 0x62,
-	0x61, 0x74, 0x63, 0x68, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x50, 0x6f, 0x43, 0x42, 0x61, 0x74, 0x63, 0x68, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52,
-	0x08, 0x70, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, 0x47, 0x0a, 0x22, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x22, 0x87, 0x01, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61,
-	0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x60, 0x0a, 0x0e, 0x70, 0x6f,
-	0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x70,
-	0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xcc, 0x01, 0x0a,
-	0x1e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x57,
-	0x69, 0x74, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12,
-	0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65,
-	0x78, 0x5f, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x09, 0x68, 0x65, 0x78, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x4f, 0x0a, 0x0e, 0x70, 0x6f,
-	0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x70, 0x6f,
-	0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x49, 0x0a, 0x24, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x8b, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x50, 0x6f, 0x63, 0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x62, 0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50,
-	0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74,
-	0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x56, 0x32, 0x42,
+	0x78, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x4f, 0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x63, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x49, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x6f, 0x63, 0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x22, 0x8b, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63,
+	0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72,
+	0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a,
+	0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x56, 0x32, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x22, 0xeb, 0x01, 0x0a, 0x20, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x73, 0x56, 0x32, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f,
+	0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65,
+	0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65, 0x78, 0x5f, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x65, 0x78, 0x50, 0x75, 0x62, 0x4b, 0x65,
+	0x79, 0x12, 0x51, 0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x42,
 	0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x22, 0xeb, 0x01, 0x0a, 0x20, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x57, 0x69, 0x74, 0x68, 0x50, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x56, 0x32, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
-	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70,
-	0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75,
-	0x62, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65, 0x78, 0x5f, 0x70, 0x75, 0x62, 0x5f,
-	0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x65, 0x78, 0x50, 0x75,
-	0x62, 0x4b, 0x65, 0x79, 0x12, 0x51, 0x0a, 0x0e, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x56, 0x32, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x70, 0x6f, 0x63, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x49, 0x64, 0x22, 0xaa, 0x01, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56,
-	0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22,
+	0xaa, 0x01, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74,
+	0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65,
+	0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x12, 0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f,
+	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x68, 0x0a, 0x1d,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a,
+	0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68,
+	0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52,
+	0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0xb2, 0x01, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74,
+	0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53,
+	0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+	0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x7a, 0x0a, 0x25, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f,
+	0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x6a, 0x0a, 0x28, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x41, 0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d,
+	0x6d, 0x69, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75,
 	0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65,
 	0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69,
 	0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74,
 	0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22,
-	0x68, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f,
-	0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52,
-	0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68,
-	0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48,
-	0x61, 0x73, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0xb2, 0x01, 0x0a, 0x24, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44,
-	0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61,
-	0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x7a,
-	0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68,
-	0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
-	0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x07, 0x77, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x6a, 0x0a, 0x28, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65,
-	0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74,
-	0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
-	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f,
-	0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
-	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x77, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
-	0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d,
-	0x69, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x32,
-	0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x57, 0x69, 0x74, 0x68, 0x41,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x22,
-	0xbc, 0x01, 0x0a, 0x1b, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f,
-	0x6d, 0x6d, 0x69, 0x74, 0x57, 0x69, 0x74, 0x68, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12,
-	0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52,
-	0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68,
-	0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48,
-	0x61, 0x73, 0x68, 0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65, 0x78, 0x5f, 0x70, 0x75, 0x62, 0x5f, 0x6b,
-	0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x65, 0x78, 0x50, 0x75, 0x62,
-	0x4b, 0x65, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18,
-	0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x72,
-	0x0a, 0x30, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65,
+	0x67, 0x68, 0x74, 0x22, 0x77, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50,
+	0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73,
+	0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x4a, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f,
+	0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x57, 0x69, 0x74, 0x68, 0x41, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x22, 0xbc, 0x01, 0x0a,
+	0x1b, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69,
+	0x74, 0x57, 0x69, 0x74, 0x68, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2f, 0x0a, 0x13,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a,
+	0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68,
+	0x12, 0x1e, 0x0a, 0x0b, 0x68, 0x65, 0x78, 0x5f, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x65, 0x78, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79,
+	0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x72, 0x0a, 0x30, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53,
+	0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22,
+	0x93, 0x01, 0x0a, 0x31, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d, 0x4c, 0x4e, 0x6f,
+	0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0d, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62,
+	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44,
+	0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x0d, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75,
+	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xae, 0x01, 0x0a, 0x23, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65,
 	0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61,
-	0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x22, 0x93, 0x01, 0x0a, 0x31, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d,
-	0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72,
-	0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0d, 0x64, 0x69, 0x73, 0x74,
-	0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x6f, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2f, 0x0a,
+	0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3b,
+	0x0a, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69,
-	0x74, 0x68, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x0d, 0x64, 0x69, 0x73, 0x74, 0x72,
-	0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xae, 0x01, 0x0a, 0x23, 0x4d, 0x4c, 0x4e,
-	0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62,
-	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x12, 0x2f, 0x0a, 0x13, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f,
-	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x70,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x12, 0x3b, 0x0a, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x19,
-	0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x1d, 0x0a, 0x1b, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x34, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x1f,
-	0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f,
-	0x6d, 0x69, 0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22,
-	0x74, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
-	0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x52, 0x0a, 0x0f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x5f,
-	0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x42,
-	0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63,
-	0x73, 0x44, 0x61, 0x74, 0x61, 0x22, 0x4d, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72,
-	0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x22, 0x93, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72,
-	0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x4b, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x74,
-	0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72,
-	0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c,
-	0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x22, 0x23, 0x0a, 0x21, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47,
-	0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22,
-	0x79, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45,
-	0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67,
-	0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70,
-	0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x22, 0x24, 0x0a, 0x22, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x22, 0x7a, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75,
-	0x73, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f,
-	0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x22, 0x5f, 0x0a, 0x15,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31,
-	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x99, 0x01,
-	0x0a, 0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f,
-	0x64, 0x65, 0x6c, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
-	0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
-	0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70,
-	0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x6f, 0x0a, 0x1f, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69,
-	0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x10,
-	0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x22, 0x7c, 0x0a, 0x20, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54,
-	0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58,
-	0x0a, 0x11, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65,
-	0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
-	0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x69, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d,
-	0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70,
-	0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75,
-	0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x22, 0xc5, 0x01, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
-	0x52, 0x10, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f,
-	0x75, 0x74, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x68, 0x74, 0x52, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x1d, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x34, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
+	0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x1f, 0x0a, 0x1d, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63,
+	0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x74, 0x0a, 0x1e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69,
+	0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x52,
+	0x0a, 0x0f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x5f, 0x64, 0x61, 0x74,
+	0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61,
+	0x74, 0x61, 0x22, 0x4d, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x55, 0x6e,
+	0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65,
+	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x22, 0x93, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x55, 0x6e,
+	0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65,
+	0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x4b, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43,
+	0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f,
+	0x73, 0x61, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x18, 0x0a,
+	0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07,
+	0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x22, 0x23, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75,
+	0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x79, 0x0a, 0x22,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63,
+	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75,
+	0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74,
+	0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x22, 0x24, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f,
+	0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7a, 0x0a,
+	0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x45, 0x70,
+	0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72,
+	0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44,
+	0x61, 0x74, 0x61, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x65, 0x70, 0x6f, 0x63, 0x68,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x22, 0x5f, 0x0a, 0x15, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a,
+	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x99, 0x01, 0x0a, 0x16, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
+	0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x47, 0x0a,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e,
+	0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61,
+	0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69,
+	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x6f, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f,
+	0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x10, 0x65, 0x78, 0x70,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x10, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x22, 0x7c, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65,
+	0x6f, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x42, 0x04, 0xc8,
+	0xde, 0x1f, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69,
+	0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x69, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c,
+	0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75,
+	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69,
+	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63,
+	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79,
+	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x22, 0xc5, 0x01, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x10, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12,
+	0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73,
+	0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
+	0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61,
+	0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x67, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x12,
+	0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49,
+	0x64, 0x22, 0xa3, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x75, 0x0a, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65,
+	0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x1a, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x73, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
+	0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62,
+	0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xec, 0x01, 0x0a,
+	0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61,
+	0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x75, 0x0a, 0x1a, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73,
+	0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69,
+	0x6c, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
 	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
 	0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
 	0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52,
-	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x67, 0x0a, 0x29, 0x51,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x5e, 0x0a, 0x2c, 0x51,
 	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c,
-	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49,
-	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x49, 0x64, 0x22, 0xa3, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x75, 0x0a, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c,
-	0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x1a,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x73, 0x0a, 0x29, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f,
-	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e,
-	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22,
-	0xec, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x69,
+	0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x03, 0x69, 0x64, 0x73, 0x12, 0x1c, 0x0a,
+	0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x22, 0xb8, 0x02, 0x0a, 0x2d,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d,
+	0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a,
+	0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x0f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x12, 0x25, 0x0a,
+	0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x12, 0x49, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18,
+	0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44,
-	0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x75,
-	0x0a, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61,
-	0x69, 0x6c, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x1a, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65,
-	0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31,
-	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x5e,
-	0x0a, 0x2c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72,
-	0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10,
-	0x0a, 0x03, 0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x03, 0x69, 0x64, 0x73,
-	0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x22, 0xb8,
-	0x02, 0x0a, 0x2d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61,
-	0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x4e, 0x0a, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x70, 0x6f,
-	0x77, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52,
-	0x0f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x73,
-	0x12, 0x25, 0x0a, 0x0e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e,
-	0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x49, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69,
-	0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69,
-	0x6c, 0x73, 0x12, 0x45, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x0a, 0x70,
-	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x22, 0x47, 0x0a, 0x0e, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70,
-	0x6f, 0x77, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x6f, 0x77, 0x65,
-	0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64,
-	0x65, 0x78, 0x22, 0x4d, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61,
-	0x72, 0x79, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65,
-	0x78, 0x22, 0x9b, 0x01, 0x0a, 0x2b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61,
-	0x72, 0x79, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x6c, 0x0a, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72,
-	0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65,
-	0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79,
-	0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72,
-	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22,
-	0x79, 0x0a, 0x30, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72,
+	0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12,
+	0x45, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x61,
+	0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x22, 0x47, 0x0a, 0x0e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x6f, 0x72, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x6f, 0x77, 0x65,
+	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x1f,
+	0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22,
+	0x4d, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72,
 	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42,
-	0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64,
-	0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49,
-	0x6e, 0x64, 0x65, 0x78, 0x12, 0x24, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x22, 0xa1, 0x01, 0x0a, 0x31, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d,
-	0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x6c, 0x0a, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d,
-	0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72,
+	0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a,
+	0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x9b,
+	0x01, 0x0a, 0x2b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72,
 	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42,
-	0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66,
-	0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x70,
-	0x0a, 0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50,
+	0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c,
+	0x0a, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e,
+	0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f,
+	0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x04, 0xc8,
+	0xde, 0x1f, 0x00, 0x52, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72,
+	0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x79, 0x0a, 0x30,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72,
+	0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65,
+	0x78, 0x12, 0x24, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x22, 0xa1, 0x01, 0x0a, 0x31, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63,
+	0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c, 0x0a,
+	0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63,
+	0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72,
+	0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d,
+	0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x70, 0x0a, 0x26, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66,
+	0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d,
+	0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31,
+	0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xe0, 0x01,
+	0x0a, 0x27, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50,
 	0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72,
-	0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69,
-	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63,
-	0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79,
-	0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x22, 0xe0, 0x01, 0x0a, 0x27, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f,
+	0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c, 0x0a, 0x17, 0x65, 0x70, 0x6f,
 	0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d,
-	0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c, 0x0a, 0x17,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65,
-	0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d,
-	0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x04, 0xc8, 0xde, 0x1f,
-	0x00, 0x52, 0x17, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61,
-	0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61,
-	0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27,
-	0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65,
-	0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x22, 0x3d, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64,
-	0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x22, 0x56, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77,
-	0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x38, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f,
-	0x64, 0x65, 0x73, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0x1e, 0x0a, 0x1c, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
-	0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x59, 0x0a, 0x1d, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
-	0x41, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x05, 0x6e,
-	0x6f, 0x64, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66,
+	0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x05,
-	0x6e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0x4e, 0x0a, 0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72,
-	0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x24, 0x0a, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x49, 0x64, 0x22, 0x61, 0x0a, 0x27, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72,
-	0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x16, 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x75,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x72, 0x65,
-	0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2b, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd4, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
-	0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x19, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74,
-	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61,
+	0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63,
+	0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x17,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65,
+	0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e,
+	0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x22, 0x3d, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72,
+	0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a,
+	0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22,
+	0x56, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65,
+	0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a,
+	0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
+	0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0x1e, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x41, 0x6c, 0x6c,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x59, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x41, 0x6c, 0x6c,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48, 0x61,
+	0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x05, 0x6e, 0x6f, 0x64,
+	0x65, 0x73, 0x22, 0x4e, 0x0a, 0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61,
 	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x17, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x21,
-	0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68,
-	0x74, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x22, 0xc8, 0x01, 0x0a,
-	0x17, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72,
-	0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x12,
-	0x16, 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x66, 0x66, 0x65, 0x63,
-	0x74, 0x69, 0x76, 0x65, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x0f, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x57, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x77, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x70, 0x65,
-	0x64, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x72, 0x65, 0x70,
-	0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb1, 0x02, 0x0a, 0x14, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x12, 0x27, 0x0a, 0x0f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x63, 0x63, 0x6f, 0x75,
-	0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x65,
-	0x72, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x24, 0x0a, 0x0d,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x49, 0x64, 0x22, 0x61, 0x0a, 0x27, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a,
+	0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x77,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2b, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
+	0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43,
+	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x22, 0xd4, 0x01, 0x0a, 0x2a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41,
+	0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x68, 0x0a, 0x19, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x52, 0x17, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43,
+	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x19,
+	0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x22, 0xc8, 0x01, 0x0a, 0x17, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06,
+	0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x77, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76,
+	0x65, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f,
+	0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
+	0x23, 0x0a, 0x0d, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x70, 0x65, 0x64, 0x57, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69,
 	0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x1a, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x5f, 0x63,
-	0x6f, 0x69, 0x6e, 0x73, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x17, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64,
-	0x43, 0x6f, 0x69, 0x6e, 0x73, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x12, 0x3d, 0x0a, 0x1b, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x5f, 0x63, 0x6f,
-	0x69, 0x6e, 0x73, 0x5f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x18, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64,
-	0x43, 0x6f, 0x69, 0x6e, 0x73, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x12, 0x29, 0x0a, 0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c,
-	0x65, 0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x23, 0x0a, 0x21, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73,
-	0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x22, 0x7e, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x11, 0x70,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x22, 0x7e, 0x0a, 0x28, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79,
-	0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65,
-	0x6c, 0x6f, 0x70, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09,
-	0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x69,
-	0x6d, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x74,
-	0x69, 0x6d, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x5f,
-	0x74, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x6f,
-	0x22, 0x6c, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79,
-	0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65,
-	0x6c, 0x6f, 0x70, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a,
-	0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74,
-	0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x22, 0x68,
-	0x0a, 0x2d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x44, 0x65,
-	0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42,
-	0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12, 0x19, 0x0a,
-	0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
-	0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x4e, 0x22, 0x52, 0x0a, 0x35, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f,
-	0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x73, 0x42, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x6e, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x05, 0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x4e, 0x22, 0x68, 0x0a, 0x30,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41,
-	0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54,
-	0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x12, 0x1b, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x12, 0x17, 0x0a,
-	0x07, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06,
-	0x74, 0x69, 0x6d, 0x65, 0x54, 0x6f, 0x22, 0x64, 0x0a, 0x2c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x66,
-	0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x46,
-	0x72, 0x6f, 0x6d, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x6f, 0x22, 0x5f, 0x0a, 0x0a,
-	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x12, 0x1b, 0x0a, 0x09, 0x61, 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x08, 0x61, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x1e, 0x0a,
-	0x0a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x05, 0x52, 0x0a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x73, 0x0a,
-	0x2d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73,
-	0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79,
-	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42,
-	0x0a, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x73, 0x4d, 0x6f, 0x64, 0x65,
-	0x6c, 0x73, 0x22, 0x9a, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53,
-	0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09,
-	0x61, 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
-	0x08, 0x61, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x61, 0x63, 0x74,
-	0x75, 0x61, 0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x5f, 0x63,
-	0x6f, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x61, 0x63, 0x74, 0x75, 0x61,
-	0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x43, 0x6f, 0x73, 0x74, 0x22,
-	0x22, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x6c, 0x6c,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x22, 0x39, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e,
-	0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x74, 0x61,
-	0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x22, 0x18,
-	0x0a, 0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74,
-	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xce, 0x03, 0x0a, 0x17, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79,
-	0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74,
-	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72,
-	0x61, 0x72, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x52, 0x0b, 0x73, 0x74, 0x61,
-	0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x65, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x74,
-	0x73, 0x5f, 0x62, 0x79, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75,
-	0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54,
-	0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61,
-	0x74, 0x52, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x1a,
-	0x72, 0x0a, 0x11, 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x54, 0x69, 0x6d, 0x65,
-	0x53, 0x74, 0x61, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65,
-	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
-	0x65, 0x72, 0x12, 0x3f, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65,
-	0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x05, 0x73, 0x74,
-	0x61, 0x74, 0x73, 0x1a, 0x74, 0x0a, 0x12, 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76,
+	0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb1, 0x02, 0x0a, 0x14, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x27, 0x0a,
+	0x0f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
+	0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x3b, 0x0a, 0x1a, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x69, 0x6e,
+	0x73, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x17, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x69,
+	0x6e, 0x73, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x3d,
+	0x0a, 0x1b, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x73,
+	0x5f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x05, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x18, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x69,
+	0x6e, 0x73, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x29, 0x0a,
+	0x10, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65,
+	0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x43,
+	0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x23, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c,
+	0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7e, 0x0a,
+	0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x12, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x11, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x7e, 0x0a,
+	0x28, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d,
+	0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
+	0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76,
 	0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65,
-	0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73,
-	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76,
-	0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f,
-	0x63, 0x68, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x22, 0x29, 0x0a, 0x27, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x22, 0xb0, 0x01, 0x0a, 0x28, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x62, 0x61, 0x73,
-	0x69, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69,
-	0x63, 0x42, 0x61, 0x73, 0x69, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75,
-	0x6d, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x76, 0x65,
-	0x72, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x6d, 0x69, 0x6e, 0x69,
-	0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65,
-	0x72, 0x61, 0x67, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65,
-	0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x37, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64,
-	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x22, 0x73, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x51, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67,
-	0x72, 0x61, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x42,
-	0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70,
-	0x67, 0x72, 0x61, 0x64, 0x65, 0x22, 0x67, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c,
-	0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76,
-	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbc,
-	0x01, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69,
-	0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x51, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72,
-	0x61, 0x64, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f,
+	0x66, 0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65,
+	0x46, 0x72, 0x6f, 0x6d, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x6f, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x6f, 0x22, 0x6c, 0x0a,
+	0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d,
+	0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
+	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x05, 0x73, 0x74,
+	0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x42, 0x04,
-	0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67,
-	0x72, 0x61, 0x64, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
-	0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62,
-	0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x01,
-	0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
-	0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x5f, 0x63, 0x68, 0x61,
-	0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e,
-	0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e,
-	0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x62, 0x6c, 0x6f,
-	0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x65,
-	0x69, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0c, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x81, 0x01,
-	0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
-	0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x12, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61,
-	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e,
-	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x12, 0x62,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x22, 0x6b, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69,
-	0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76,
-	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xcb,
-	0x01, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x12, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54,
-	0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72,
-	0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52,
-	0x12, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
-	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65,
-	0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xe0, 0x01, 0x0a,
-	0x13, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c,
-	0x61, 0x6e, 0x63, 0x65, 0x12, 0x4e, 0x0a, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x6e,
-	0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x09, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
-	0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x12, 0x18, 0x0a, 0x07,
-	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62,
-	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
-	0x6c, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x5f,
-	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x66,
-	0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22,
-	0x3c, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x69, 0x0a,
-	0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x44, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x57, 0x72, 0x61, 0x70, 0x70,
-	0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x08,
-	0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x3f, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73,
-	0x42, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19,
-	0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x75, 0x0a, 0x23, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
-	0x73, 0x42, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x4e, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20,
+	0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79,
+	0x54, 0x69, 0x6d, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x22, 0x68, 0x0a, 0x2d, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c,
+	0x6f, 0x70, 0x65, 0x72, 0x41, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x61, 0x63, 0x6b,
+	0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09,
+	0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x73, 0x5f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x73, 0x4e, 0x22, 0x52, 0x0a, 0x35, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x42, 0x61,
+	0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19,
+	0x0a, 0x08, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x07, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x4e, 0x22, 0x68, 0x0a, 0x30, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54,
+	0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65,
+	0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a,
+	0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x69,
+	0x6d, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x69, 0x6d,
+	0x65, 0x54, 0x6f, 0x22, 0x64, 0x0a, 0x2c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53,
+	0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x6f, 0x6d,
+	0x12, 0x17, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x06, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x6f, 0x22, 0x5f, 0x0a, 0x0a, 0x4d, 0x6f, 0x64,
+	0x65, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1b, 0x0a,
+	0x09, 0x61, 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x08, 0x61, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x73, 0x0a, 0x2d, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64,
+	0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0c, 0x73,
+	0x74, 0x61, 0x74, 0x73, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x73, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x22,
+	0x9a, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x69, 0x5f,
+	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x61, 0x69,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c,
+	0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x73, 0x74,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x43, 0x6f, 0x73, 0x74, 0x22, 0x22, 0x0a, 0x20,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x22, 0x39, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x6c,
+	0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x22, 0x18, 0x0a, 0x16, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xce, 0x03, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44,
+	0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x62, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x74, 0x69,
+	0x6d, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79,
+	0x54, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x73, 0x42,
+	0x79, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x65, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62,
+	0x79, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3f, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74,
+	0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x65, 0x6d, 0x70,
+	0x6f, 0x72, 0x61, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x52, 0x0c,
+	0x73, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x1a, 0x72, 0x0a, 0x11,
+	0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61,
+	0x74, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12,
+	0x3f, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74,
+	0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73,
+	0x1a, 0x74, 0x0a, 0x12, 0x54, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x45, 0x70, 0x6f,
+	0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f,
+	0x70, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x76, 0x65, 0x6c,
+	0x6f, 0x70, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x02, 0x20,
 	0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
-	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42,
-	0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73,
-	0x22, 0x55, 0x0a, 0x28, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72,
-	0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x10,
-	0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x46, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x22,
-	0x43, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65,
-	0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x62, 0x63, 0x5f, 0x64,
-	0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x62, 0x63, 0x44,
-	0x65, 0x6e, 0x6f, 0x6d, 0x22, 0x5e, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72,
-	0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a,
-	0x08, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x07, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x64, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x71,
-	0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x22, 0x71, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64,
-	0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x64,
-	0x65, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x63, 0x6f, 0x64, 0x65, 0x49,
-	0x64, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f,
+	0x70, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52,
+	0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x22, 0x29, 0x0a, 0x27, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x22, 0xb0, 0x01, 0x0a, 0x28, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x69,
+	0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41,
+	0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23,
+	0x0a, 0x0d, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x5f, 0x62, 0x61, 0x73, 0x69, 0x73, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x42, 0x61,
+	0x73, 0x69, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67,
+	0x65, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
 	0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65,
-	0x69, 0x67, 0x68, 0x74, 0x22, 0x17, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f,
-	0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xe6, 0x02,
-	0x0a, 0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b,
-	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x39, 0x0a, 0x06, 0x70,
-	0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06,
-	0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74,
-	0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x69,
+	0x69, 0x67, 0x68, 0x74, 0x22, 0x37, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x73, 0x0a,
+	0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c,
+	0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x51, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61,
+	0x64, 0x65, 0x22, 0x67, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbc, 0x01, 0x0a, 0x1e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55,
+	0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x51,
+	0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f,
+	0x00, 0x52, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64,
+	0x65, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62,
+	0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
+	0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a,
+	0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x01, 0x0a, 0x20, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
+	0x21, 0x0a, 0x0c, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x43, 0x68, 0x61,
+	0x69, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62,
+	0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e,
+	0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74,
+	0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65,
+	0x63, 0x65, 0x69, 0x70, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x81, 0x01, 0x0a, 0x21, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x5c, 0x0a, 0x12, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b,
-	0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x3b, 0x0a, 0x1a, 0x69,
-	0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70,
-	0x6f, 0x63, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x17, 0x69, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
-	0x6f, 0x63, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x6c, 0x0a, 0x1d, 0x61, 0x63, 0x74, 0x69,
-	0x76, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
-	0x70, 0x6f, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x1a, 0x61, 0x63, 0x74, 0x69,
-	0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f,
-	0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x47, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43,
-	0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74,
-	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a,
-	0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x05, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22,
-	0x3c, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43,
-	0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x4b, 0x0a,
-	0x27, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68,
-	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x62,
-	0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x40, 0x0a, 0x28, 0x51, 0x75,
+	0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x12, 0x62, 0x72, 0x69, 0x64,
+	0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x6b,
+	0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+	0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73,
+	0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65,
+	0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xcb, 0x01, 0x0a, 0x22,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72,
+	0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x5c, 0x0a, 0x12, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e,
+	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73,
+	0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x12, 0x62, 0x72,
+	0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61,
+	0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
+	0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70,
+	0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xe0, 0x01, 0x0a, 0x13, 0x57, 0x72,
+	0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63,
+	0x65, 0x12, 0x4e, 0x0a, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64,
+	0x67, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f,
+	0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x09, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x6e, 0x66,
+	0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x61, 0x6c,
+	0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61,
+	0x6e, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12,
+	0x2b, 0x0a, 0x11, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c,
+	0x61, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x66, 0x6f, 0x72, 0x6d,
+	0x61, 0x74, 0x74, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3c, 0x0a, 0x20,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x69, 0x0a, 0x21, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42,
+	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x44, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54,
+	0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x08, 0x62, 0x61, 0x6c,
+	0x61, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x3f, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x72,
+	0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x42, 0x79, 0x43,
+	0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63,
+	0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63,
+	0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x75, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42,
+	0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x42, 0x79,
+	0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a,
+	0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x43, 0x6f, 0x6e,
+	0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0x04, 0xc8, 0xde,
+	0x1f, 0x00, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0x55, 0x0a,
+	0x28, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x57, 0x72,
+	0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61,
+	0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6e,
+	0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x22, 0x46, 0x0a, 0x29, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x22, 0x43, 0x0a, 0x24,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x62, 0x63, 0x5f, 0x64, 0x65, 0x6e, 0x6f,
+	0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f,
+	0x6d, 0x22, 0x5e, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61,
+	0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73,
+	0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c,
+	0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c,
+	0x73, 0x22, 0x1b, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64,
+	0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x71,
+	0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79,
+	0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07,
+	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x64, 0x65, 0x49, 0x64,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x63, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x21,
+	0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x22, 0x17, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49,
+	0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xe6, 0x02, 0x0a, 0x16, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x39, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61,
+	0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50,
+	0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x70, 0x61, 0x72,
+	0x61, 0x6d, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x6c, 0x61, 0x74,
+	0x65, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x3b, 0x0a, 0x1a, 0x69, 0x73, 0x5f, 0x63,
+	0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f,
+	0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, 0x69, 0x73,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x63, 0x41,
+	0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x6c, 0x0a, 0x1d, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f,
+	0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63,
+	0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
+	0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x1a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43,
+	0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x63, 0x45, 0x76,
+	0x65, 0x6e, 0x74, 0x22, 0x47, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e,
+	0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x62, 0x6c,
+	0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3c, 0x0a, 0x24,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74,
+	0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x4b, 0x0a, 0x27, 0x51, 0x75,
 	0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x76, 0x61, 0x6c, 0x69, 0x64,
 	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x24, 0x0a, 0x22,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x22, 0x7f, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x70, 0x70, 0x72, 0x6f,
-	0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x0f, 0x61, 0x70, 0x70,
-	0x72, 0x6f, 0x76, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x04, 0xc8,
-	0xde, 0x1f, 0x00, 0x52, 0x0e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x73, 0x22, 0x3e, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d,
-	0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63,
-	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x49, 0x64, 0x22, 0x50, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d,
-	0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69,
-	0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12,
-	0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05,
-	0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x27, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x3d,
-	0x0a, 0x0a, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x19, 0x0a, 0x08,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x72, 0x0a,
-	0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65,
-	0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0c, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x42, 0x04,
-	0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65,
-	0x73, 0x22, 0x39, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64,
-	0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x51, 0x0a, 0x1d,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70,
-	0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a,
-	0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75,
-	0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22,
-	0x23, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f,
-	0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x22, 0x79, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
-	0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69,
-	0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
-	0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0f,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22,
-	0x46, 0x0a, 0x0d, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79,
-	0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x63,
-	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x63,
-	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x22, 0x76, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f,
-	0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x22,
-	0x3c, 0x0a, 0x07, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x22, 0x5e, 0x0a,
-	0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x08, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x18,
-	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x72, 0x61, 0x6e,
-	0x74, 0x65, 0x65, 0x52, 0x08, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x22, 0x22, 0x0a,
-	0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x22, 0x41, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x65, 0x73, 0x22, 0x1e, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
-	0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x22, 0x70, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
-	0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4f, 0x0a, 0x0e, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f,
-	0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
-	0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x56,
-	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x43, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45,
-	0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x63, 0x0a, 0x21, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x3e, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73,
-	0x22, 0x28, 0x0a, 0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x40, 0x0a, 0x28, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x24, 0x0a, 0x22, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22,
+	0x7f, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x0f, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76,
+	0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
+	0x52, 0x0e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x22, 0x3e, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65,
+	0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64,
+	0x22, 0x50, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65,
+	0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05,
+	0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75,
+	0x6e, 0x64, 0x22, 0x27, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c,
+	0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72,
+	0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x3d, 0x0a, 0x0a, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64,
+	0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64,
+	0x65, 0x6c, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x22, 0x72, 0x0a, 0x26, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65,
+	0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0c, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x70, 0x72,
+	0x69, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f,
+	0x00, 0x52, 0x0b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x22, 0x39,
+	0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19,
+	0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x22, 0x51, 0x0a, 0x1d, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69,
+	0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61,
+	0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x63, 0x61,
+	0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x23, 0x0a, 0x21,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
+	0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x22, 0x79, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c,
+	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70,
+	0x61, 0x63, 0x69, 0x74, 0x79, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0f, 0x6d, 0x6f, 0x64,
+	0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x46, 0x0a, 0x0d,
+	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x19, 0x0a,
+	0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61,
+	0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61,
+	0x63, 0x69, 0x74, 0x79, 0x22, 0x76, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x72, 0x61,
+	0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
+	0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x67, 0x72, 0x61,
+	0x6e, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0e, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79,
+	0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x22, 0x3c, 0x0a, 0x07,
+	0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x22, 0x5e, 0x0a, 0x22, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d, 0x65, 0x73,
+	0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x38, 0x0a, 0x08, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65,
+	0x52, 0x08, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x22, 0x22, 0x0a, 0x20, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c,
+	0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x41,
+	0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x22, 0x1e, 0x0a, 0x1c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x4c, 0x4e,
+	0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x22, 0x70, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x4c, 0x4e,
+	0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x4f, 0x0a, 0x0e, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72,
+	0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x04,
+	0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0d, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73,
+	0x69, 0x6f, 0x6e, 0x22, 0x22, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4c,
+	0x61, 0x73, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x69, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x47, 0x65, 0x74, 0x4c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x13,
+	0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x68, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x55,
+	0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x14, 0x0a, 0x05,
+	0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75,
+	0x6e, 0x64, 0x22, 0x43, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x78, 0x63, 0x6c, 0x75,
+	0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f,
+	0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x63, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x05,
+	0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x28, 0x0a, 0x26,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69,
+	0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x87, 0x01, 0x0a, 0x27, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12,
+	0x3f, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74,
+	0x22, 0x44, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69,
+	0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x67, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43,
 	0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76,
-	0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x87, 0x01, 0x0a, 0x27, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72,
-	0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x61, 0x63, 0x74,
-	0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x41, 0x63, 0x74,
-	0x69, 0x76, 0x65, 0x12, 0x3f, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x05, 0x65,
-	0x76, 0x65, 0x6e, 0x74, 0x22, 0x44, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e,
-	0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e,
-	0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f,
+	0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x06,
+	0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
+	0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22,
+	0x9f, 0x01, 0x0a, 0x16, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x57,
+	0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69,
+	0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x08, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
+	0x73, 0x22, 0x6e, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63,
+	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e,
+	0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72,
+	0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x22, 0xea, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e,
+	0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x55, 0x0a, 0x0c, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x04,
+	0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
+	0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52,
+	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3a,
+	0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x65, 0x65,
+	0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f,
 	0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x67, 0x0a, 0x22, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
-	0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x41, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65,
-	0x6e, 0x74, 0x73, 0x22, 0x9f, 0x01, 0x0a, 0x16, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x48,
-	0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x70, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x3b, 0x0a, 0x08, 0x62, 0x61, 0x6c, 0x61,
-	0x6e, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
-	0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x08, 0x62, 0x61, 0x6c,
-	0x61, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x6e, 0x0a, 0x24, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61,
-	0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a,
-	0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e,
-	0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61,
-	0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xea, 0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42,
-	0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x55, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x18,
-	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e,
-	0x63, 0x65, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76,
-	0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x22, 0x3a, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f,
-	0x6d, 0x53, 0x65, 0x65, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a,
-	0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x51,
-	0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x65, 0x65,
-	0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x73, 0x65,
-	0x65, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x65, 0x65, 0x64, 0x52, 0x05, 0x73, 0x65, 0x65, 0x64,
-	0x73, 0x22, 0x58, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x33, 0x0a, 0x16, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74,
-	0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65,
-	0x53, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x82, 0x01, 0x0a, 0x22,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x46, 0x0a, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
-	0x52, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f,
-	0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64,
-	0x22, 0x24, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76,
-	0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x84, 0x01, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e,
-	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x51, 0x0a, 0x18, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x65, 0x65, 0x64, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x73, 0x65, 0x65, 0x64, 0x73, 0x18,
+	0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x52, 0x61, 0x6e, 0x64,
+	0x6f, 0x6d, 0x53, 0x65, 0x65, 0x64, 0x52, 0x05, 0x73, 0x65, 0x65, 0x64, 0x73, 0x22, 0x58, 0x0a,
+	0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x33, 0x0a, 0x16, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f,
+	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x03, 0x52, 0x13, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x72,
+	0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x82, 0x01, 0x0a, 0x22, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46,
 	0x0a, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64,
-	0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x08, 0x73,
-	0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x2f, 0x0a,
-	0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72,
-	0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e,
-	0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x69, 0x64, 0x22, 0x73,
-	0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61,
-	0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x3b, 0x0a, 0x06, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x23, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45,
-	0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x06, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x14, 0x0a,
-	0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f,
-	0x75, 0x6e, 0x64, 0x22, 0x6a, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44,
-	0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x20, 0x0a,
-	0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22,
-	0x81, 0x01, 0x0a, 0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73,
+	0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x08, 0x73, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x24, 0x0a, 0x22,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f,
+	0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x22, 0x84, 0x01, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x73,
+	0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
+	0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x08, 0x73, 0x6e,
+	0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65,
+	0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x08, 0x73, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x2f, 0x0a, 0x1d, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63,
+	0x72, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x02, 0x69, 0x64, 0x22, 0x73, 0x0a, 0x1e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73,
+	0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x06,
+	0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f,
+	0x77, 0x52, 0x06, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75,
+	0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22,
+	0x6a, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68,
+	0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65,
+	0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x81, 0x01, 0x0a, 0x26,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64,
+	0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73,
 	0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61,
-	0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x05, 0x73, 0x74,
-	0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x74, 0x73, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75,
+	0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22,
+	0x41, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x22, 0x5b, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74,
+	0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x5f, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x63, 0x72, 0x65,
+	0x64, 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75,
+	0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22,
+	0x44, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0x88, 0x01, 0x0a, 0x21, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75,
+	0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x0b, 0x72,
+	0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72,
+	0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f,
+	0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64,
+	0x22, 0x1f, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x22, 0x71, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x4f, 0x0a, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x73, 0x12, 0x14, 0x0a,
-	0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f,
-	0x75, 0x6e, 0x64, 0x32, 0xd8, 0x80, 0x01, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x8f,
-	0x01, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72,
+	0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x22, 0x41, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69,
+	0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x22, 0xb1, 0x02, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x05, 0x73, 0x74,
+	0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61,
-	0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x2c, 0x12, 0x2a, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
-	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73,
-	0x12, 0xa9, 0x01, 0x0a, 0x09, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2d,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
-	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x7b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xa4, 0x01, 0x0a,
-	0x0c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x41, 0x6c, 0x6c, 0x12, 0x2d, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x2f, 0x12, 0x2d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
-	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x12, 0xb1, 0x01, 0x0a, 0x0b, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
-	0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x39, 0x12, 0x37,
-	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x2f,
-	0x7b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xac, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e,
+	0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65,
+	0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x5a, 0x0a, 0x12, 0x61, 0x63, 0x74, 0x69, 0x76,
+	0x65, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x52, 0x11, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x12, 0x60, 0x0a, 0x15, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64,
+	0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
+	0x14, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x3c, 0x0a, 0x22, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43,
+	0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x82, 0x01, 0x0a, 0x23, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x6f,
+	0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f,
+	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x63, 0x6f, 0x6e,
+	0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x30, 0x0a, 0x14,
+	0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x65, 0x72,
+	0x5f, 0x62, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x63,
+	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x42, 0x70, 0x73, 0x22, 0x95,
+	0x01, 0x0a, 0x25, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x27, 0x0a,
+	0x0f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x22, 0x75, 0x0a, 0x26, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75,
+	0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x20, 0x0a, 0x0b, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62,
+	0x6c, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+	0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65,
+	0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x43, 0x0a,
+	0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52,
+	0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x22, 0x6c, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x73, 0x74, 0x43,
+	0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6c,
+	0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73,
+	0x32, 0xee, 0x8f, 0x01, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x8f, 0x01, 0x0a, 0x06,
+	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x27, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x2c, 0x12, 0x2a, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0xa9, 0x01,
+	0x0a, 0x09, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2d, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
-	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0xc6, 0x01, 0x0a, 0x10, 0x41, 0x63, 0x63, 0x6f, 0x75,
-	0x6e, 0x74, 0x42, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x31, 0x2e, 0x69, 0x6e,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x37, 0x12, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x7b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xa4, 0x01, 0x0a, 0x0c, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x41, 0x6c, 0x6c, 0x12, 0x2d, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x2f, 0x12, 0x2d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x12, 0xb1, 0x01, 0x0a, 0x0b, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x3f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x39, 0x12, 0x37, 0x2f, 0x70, 0x72,
+	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x2f, 0x7b, 0x69, 0x6e,
+	0x64, 0x65, 0x78, 0x7d, 0x12, 0xac, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x31, 0x12, 0x2f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x12, 0xc6, 0x01, 0x0a, 0x10, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42,
+	0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x79,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e,
-	0x74, 0x42, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x4b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x45, 0x12, 0x43, 0x2f, 0x70, 0x72, 0x6f,
-	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12,
-	0xbd, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65,
-	0x63, 0x75, 0x74, 0x6f, 0x72, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78,
-	0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3f,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x39, 0x12, 0x37, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
-	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f,
-	0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x12,
-	0xc5, 0x01, 0x0a, 0x0e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61,
-	0x74, 0x61, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x4b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x45, 0x12, 0x43, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xbd, 0x01, 0x0a,
+	0x11, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74,
+	0x6f, 0x72, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52,
+	0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x52,
 	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44,
-	0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4a, 0x82, 0xd3, 0xe4,
-	0x93, 0x02, 0x44, 0x12, 0x42, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
+	0x72, 0x79, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x45, 0x78, 0x65, 0x63, 0x75,
+	0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3f, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x39, 0x12, 0x37, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
 	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67,
-	0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xba, 0x01, 0x0a, 0x11, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x12, 0x32, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34,
-	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f,
-	0x64, 0x61, 0x74, 0x61, 0x12, 0xbc, 0x01, 0x0a, 0x0c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75,
-	0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x47, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x41, 0x12, 0x3f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x7d, 0x12, 0xb1, 0x01, 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d,
-	0x6f, 0x75, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x72, 0x61, 0x6e,
+	0x64, 0x6f, 0x6d, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x12, 0xc5, 0x01, 0x0a,
+	0x0e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12,
+	0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70,
+	0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x44,
+	0x12, 0x42, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75,
+	0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e,
+	0x64, 0x65, 0x78, 0x7d, 0x12, 0xba, 0x01, 0x0a, 0x11, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x41, 0x6c, 0x6c, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f,
+	0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x3c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34, 0x2f, 0x70, 0x72,
+	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74,
+	0x61, 0x12, 0xbc, 0x01, 0x0a, 0x0c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
+	0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x47, 0x65, 0x74, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x47, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x41, 0x12,
+	0x3f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d,
+	0x12, 0xb1, 0x01, 0x0a, 0x0f, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e,
+	0x74, 0x41, 0x6c, 0x6c, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75, 0x6e,
+	0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x39, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x33, 0x12, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x12, 0xdb, 0x01, 0x0a, 0x15, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74,
+	0x65, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x36,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61,
+	0x74, 0x65, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x42, 0x69, 0x74, 0x63, 0x6f, 0x69,
+	0x6e, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x51, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4b, 0x12, 0x49, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x73, 0x74,
+	0x69, 0x6d, 0x61, 0x74, 0x65, 0x5f, 0x62, 0x69, 0x74, 0x63, 0x6f, 0x69, 0x6e, 0x5f, 0x72, 0x65,
+	0x77, 0x61, 0x72, 0x64, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x7d, 0x12, 0xef, 0x01, 0x0a, 0x15, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75,
+	0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x39, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
+	0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d, 0x6f, 0x75,
-	0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x41, 0x6d,
-	0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x39, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x33, 0x12, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
-	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65,
-	0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0xef, 0x01, 0x0a, 0x15, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x5f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x59, 0x12, 0x57, 0x2f, 0x70, 0x72,
+	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e,
+	0x64, 0x65, 0x78, 0x7d, 0x12, 0xd6, 0x01, 0x0a, 0x18, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72,
+	0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x6c,
+	0x6c, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
 	0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
 	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68,
 	0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x59,
-	0x12, 0x57, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x43, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3d,
+	0x12, 0x3b, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
 	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75,
-	0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x70,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x2f, 0x7b, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xd6, 0x01, 0x0a, 0x18, 0x45, 0x70,
-	0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x41, 0x6c, 0x6c, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x43, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x3d, 0x12, 0x3b, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
-	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x12, 0xd1, 0x01, 0x0a, 0x12, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65,
-	0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x12, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x70, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0xd1, 0x01,
+	0x0a, 0x12, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x53,
+	0x74, 0x61, 0x67, 0x65, 0x12, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61,
+	0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
 	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x46,
-	0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74,
-	0x63, 0x68, 0x65, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4a, 0x12, 0x48, 0x2f, 0x70,
-	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x5f, 0x66, 0x6f,
-	0x72, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xe1, 0x01, 0x0a, 0x16, 0x50, 0x6f, 0x63, 0x56, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67,
-	0x65, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74,
-	0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x54, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4e, 0x12, 0x4c, 0x2f, 0x70,
-	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x73, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x2f, 0x7b, 0x62, 0x6c, 0x6f,
-	0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xea, 0x01, 0x0a, 0x18, 0x50,
-	0x6f, 0x63, 0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46,
-	0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x50, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4a, 0x12, 0x48, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63,
+	0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x73, 0x74, 0x61,
+	0x67, 0x65, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x7d, 0x12, 0xe1, 0x01, 0x0a, 0x16, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x12, 0x37, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46,
+	0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x54, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4e, 0x12, 0x4c, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63,
+	0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x66, 0x6f, 0x72,
+	0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xea, 0x01, 0x0a, 0x18, 0x50, 0x6f, 0x63, 0x56, 0x32, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61,
+	0x67, 0x65, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f,
 	0x63, 0x56, 0x32, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f,
-	0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x57,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x51, 0x12, 0x4f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
+	0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x63, 0x56, 0x32, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x57, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x51, 0x12, 0x4f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x32, 0x5f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x73, 0x74,
+	0x61, 0x67, 0x65, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x7d, 0x12, 0xfa, 0x01, 0x0a, 0x10, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72,
+	0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d,
+	0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65,
+	0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7f,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x79, 0x12, 0x77, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
 	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f,
-	0x76, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x66,
-	0x6f, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
-	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xfa, 0x01, 0x0a, 0x10, 0x50, 0x6f, 0x43, 0x56,
-	0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x31, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f,
-	0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x32,
-	0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x7f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x79, 0x12, 0x77, 0x2f, 0x70, 0x72,
-	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x32, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x6f,
-	0x6d, 0x6d, 0x69, 0x74, 0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x7d, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x5f, 0x69, 0x64, 0x7d, 0x12, 0x9b, 0x02, 0x0a, 0x18, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f,
-	0x6e, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x4c, 0x4e,
-	0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62,
-	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69,
+	0x76, 0x32, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2f,
+	0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74,
+	0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x2f, 0x7b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x7d, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x7d, 0x12,
+	0x9b, 0x02, 0x0a, 0x18, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x39, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65,
 	0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x87, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x80, 0x01, 0x12, 0x7e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x77,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69,
-	0x6f, 0x6e, 0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74,
-	0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x7d, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69,
-	0x64, 0x7d, 0x12, 0x82, 0x02, 0x0a, 0x1c, 0x41, 0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53,
-	0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74,
-	0x61, 0x67, 0x65, 0x12, 0x3d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
-	0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d,
-	0x69, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c,
-	0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69,
-	0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x63, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5d, 0x12, 0x5b, 0x2f, 0x70, 0x72, 0x6f,
-	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x61, 0x6c, 0x6c, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x32, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65,
-	0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74,
-	0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
-	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xa1, 0x02, 0x0a, 0x24, 0x41, 0x6c, 0x6c, 0x4d,
-	0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72,
-	0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65,
-	0x12, 0x45, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d,
-	0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72,
-	0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x46, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46,
-	0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x6a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x64, 0x12, 0x62, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
-	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c,
-	0x5f, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64,
-	0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x70, 0x6f,
-	0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c,
-	0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xb5, 0x01, 0x0a, 0x0f,
-	0x47, 0x65, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12,
-	0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x75,
-	0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
-	0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x70,
-	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70,
-	0x6f, 0x63, 0x68, 0x12, 0xb6, 0x01, 0x0a, 0x0e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69,
-	0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44,
-	0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d,
-	0x69, 0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x3b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x35, 0x12, 0x33, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
-	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x74, 0x6f, 0x6b,
-	0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x12, 0xf0, 0x01, 0x0a,
-	0x1d, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74,
-	0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x3e,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x69,
-	0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50,
-	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3f,
+	0x65, 0x72, 0x79, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44,
+	0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x87, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x80, 0x01, 0x12, 0x7e, 0x2f,
+	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x5f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x70,
+	0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x2f, 0x7b, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x7d, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x82, 0x02,
+	0x0a, 0x1c, 0x41, 0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x12, 0x3d,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x69,
-	0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50,
-	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x4e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x48, 0x12, 0x46, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x6f, 0x43,
+	0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x46, 0x6f,
+	0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3e, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x6f, 0x43, 0x56,
+	0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x46, 0x6f, 0x72,
+	0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x63, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x5d, 0x12, 0x5b, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x70,
+	0x6f, 0x63, 0x5f, 0x76, 0x32, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d,
+	0x69, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73,
+	0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x7d, 0x12, 0xa1, 0x02, 0x0a, 0x24, 0x41, 0x6c, 0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65,
+	0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x12, 0x45, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65,
+	0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x46, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c,
+	0x6c, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73,
+	0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x53, 0x74, 0x61,
+	0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x64, 0x12, 0x62, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x6c, 0x6e, 0x6f,
+	0x64, 0x65, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69,
+	0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61,
+	0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xb5, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x43, 0x75,
+	0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+	0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65,
+	0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
 	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74,
-	0x5f, 0x75, 0x6e, 0x69, 0x74, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65,
-	0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12,
-	0xce, 0x01, 0x0a, 0x15, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x12, 0xb6,
+	0x01, 0x0a, 0x0e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61, 0x74,
+	0x61, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x63, 0x73, 0x44, 0x61,
+	0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3b, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x35, 0x12, 0x33, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x6f, 0x6d, 0x69,
+	0x63, 0x73, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x12, 0xf0, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x55,
+	0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63,
+	0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x75, 0x72,
-	0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61,
-	0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x3e, 0x12, 0x3c, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f,
+	0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f,
+	0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4e, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x48, 0x12, 0x46, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
 	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61,
-	0x12, 0x9c, 0x01, 0x0a, 0x09, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x12, 0x2a,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
-	0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12,
-	0x2e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x12,
-	0xdf, 0x01, 0x0a, 0x10, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d,
-	0x65, 0x6f, 0x75, 0x74, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x75, 0x6e, 0x69, 0x74,
+	0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63,
+	0x65, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0xce, 0x01, 0x0a, 0x15, 0x43,
+	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70,
+	0x44, 0x61, 0x74, 0x61, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65,
+	0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75,
+	0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x45,
+	0x70, 0x6f, 0x63, 0x68, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3e, 0x12, 0x3c, 0x2f,
+	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+	0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x12, 0x9c, 0x01, 0x0a, 0x09,
+	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x70, 0x72, 0x6f,
+	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x12, 0xdf, 0x01, 0x0a, 0x10, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12,
+	0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d,
+	0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5e, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x58, 0x12, 0x56, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
+	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x2f, 0x7b, 0x65, 0x78, 0x70,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x2f, 0x7b,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x7d, 0x12, 0xc1, 0x01, 0x0a,
+	0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75,
+	0x74, 0x41, 0x6c, 0x6c, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65,
 	0x6f, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x5e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x58, 0x12, 0x56, 0x2f, 0x70, 0x72, 0x6f, 0x64,
+	0x65, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x64,
 	0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
-	0x2f, 0x7b, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x7d, 0x2f, 0x7b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64,
-	0x7d, 0x12, 0xc1, 0x01, 0x0a, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54,
-	0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x41, 0x6c, 0x6c, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35,
-	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x69,
-	0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0xff, 0x01, 0x0a, 0x1a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74,
-	0x61, 0x69, 0x6c, 0x73, 0x12, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x12, 0xff, 0x01, 0x0a, 0x1a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12,
+	0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x60, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5a, 0x12, 0x58, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
+	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x49, 0x64, 0x7d, 0x2f, 0x7b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49,
+	0x64, 0x7d, 0x12, 0xea, 0x01, 0x0a, 0x1d, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c,
+	0x73, 0x41, 0x6c, 0x6c, 0x12, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69,
+	0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69,
 	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71,
 	0x75, 0x65, 0x73, 0x74, 0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69,
+	0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69,
 	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5a, 0x12, 0x58, 0x2f,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x48, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x12, 0x40, 0x2f,
 	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2f,
-	0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x64, 0x7d, 0x2f, 0x7b, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x7d, 0x12, 0xea, 0x01, 0x0a, 0x1d, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44,
-	0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x41, 0x6c, 0x6c, 0x12, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69,
-	0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69,
-	0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x48, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x42, 0x12, 0x40, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74,
-	0x61, 0x69, 0x6c, 0x73, 0x12, 0x8c, 0x02, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
-	0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x41, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d,
-	0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x42, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61,
-	0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x61, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5b, 0x12, 0x59, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
-	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65,
-	0x74, 0x5f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69,
-	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72,
-	0x73, 0x2f, 0x7b, 0x69, 0x64, 0x73, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x65, 0x72, 0x7d, 0x12, 0xf1, 0x01, 0x0a, 0x17, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72,
-	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12,
-	0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61,
-	0x72, 0x79, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x40, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d,
-	0x61, 0x72, 0x79, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x53, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4d, 0x12, 0x4b, 0x2f, 0x70, 0x72, 0x6f,
-	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63,
-	0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0x9a, 0x02, 0x0a, 0x24, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d,
-	0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x12, 0x45, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d,
-	0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x46, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61,
-	0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x63, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5d, 0x12, 0x5b, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
-	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x5f, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73,
-	0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e,
-	0x64, 0x65, 0x78, 0x7d, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x49, 0x64, 0x7d, 0x12, 0xde, 0x01, 0x0a, 0x1a, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65,
-	0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79,
-	0x41, 0x6c, 0x6c, 0x12, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
-	0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e,
-	0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45,
-	0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53,
-	0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x45,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
-	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63,
-	0x68, 0x5f, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x75,
-	0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0xba, 0x01, 0x0a, 0x0d, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61,
-	0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x48, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42,
-	0x12, 0x40, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x5f, 0x6e,
-	0x6f, 0x64, 0x65, 0x73, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x7d, 0x12, 0xb9, 0x01, 0x0a, 0x10, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e,
-	0x6f, 0x64, 0x65, 0x73, 0x41, 0x6c, 0x6c, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12,
+	0x8c, 0x02, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
+	0x74, 0x65, 0x72, 0x73, 0x12, 0x41, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x42, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73,
-	0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f,
-	0x64, 0x65, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
-	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x68, 0x61, 0x72, 0x64,
-	0x77, 0x61, 0x72, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x12, 0xf2,
-	0x01, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3b, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74,
-	0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
+	0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x61, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x5b, 0x12, 0x59, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64,
+	0x73, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x72, 0x7d, 0x12, 0xf1,
+	0x01, 0x0a, 0x17, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61,
+	0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x3f, 0x2e, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x59, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x53,
-	0x12, 0x51, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74,
-	0x61, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x49, 0x64, 0x7d, 0x12, 0xef, 0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f,
+	0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79, 0x45,
+	0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x40, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66,
+	0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79,
+	0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x53, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x4d, 0x12, 0x4b, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+	0x5f, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d,
+	0x6d, 0x61, 0x72, 0x79, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65,
+	0x78, 0x7d, 0x12, 0x9a, 0x02, 0x0a, 0x24, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66,
+	0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x45, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66,
+	0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x46, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70,
+	0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75,
+	0x6d, 0x6d, 0x61, 0x72, 0x79, 0x42, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x63, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x5d, 0x12, 0x5b, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x65,
+	0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72,
+	0x79, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x2f,
+	0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x7d, 0x12,
+	0xde, 0x01, 0x0a, 0x1a, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d,
+	0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x12, 0x3b,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f,
+	0x63, 0x68, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d,
+	0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x50,
+	0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72,
+	0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x45, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x3f, 0x12, 0x3d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x70, 0x65, 0x72,
+	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79,
+	0x12, 0xba, 0x01, 0x0a, 0x0d, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64,
+	0x65, 0x73, 0x12, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61,
+	0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61,
+	0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x48, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x12, 0x40, 0x2f, 0x70, 0x72,
+	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x2f,
+	0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x12, 0xb9, 0x01,
+	0x0a, 0x10, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x41,
+	0x6c, 0x6c, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x61,
+	0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x41, 0x6c, 0x6c, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x79, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x41, 0x6c,
+	0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x38, 0x12, 0x36, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x5f,
+	0x6e, 0x6f, 0x64, 0x65, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x12, 0xf2, 0x01, 0x0a, 0x1a, 0x47, 0x65,
+	0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72,
+	0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
 	0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x47, 0x12, 0x45,
-	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x70, 0x61, 0x72, 0x74,
-	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f,
-	0x73, 0x74, 0x61, 0x74, 0x73, 0x12, 0xcb, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61,
-	0x74, 0x73, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74,
-	0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x70, 0x72,
+	0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43,
+	0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x59, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x53, 0x12, 0x51, 0x2f, 0x70, 0x72,
 	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x5f, 0x73, 0x74,
-	0x61, 0x74, 0x73, 0x12, 0xee, 0x01, 0x0a, 0x1c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54,
-	0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c,
-	0x6f, 0x70, 0x65, 0x72, 0x12, 0x3d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f,
-	0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53,
-	0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64,
-	0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x4f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70, 0x72,
-	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x2f, 0x7b, 0x64, 0x65, 0x76, 0x65,
-	0x6c, 0x6f, 0x70, 0x65, 0x72, 0x7d, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f,
-	0x74, 0x69, 0x6d, 0x65, 0x12, 0x81, 0x02, 0x0a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79,
-	0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x42, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x44, 0x65,
-	0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x41, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42,
-	0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74,
-	0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5b, 0x82, 0xd3, 0xe4,
-	0x93, 0x02, 0x55, 0x12, 0x53, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
-	0x65, 0x72, 0x2f, 0x7b, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x7d, 0x2f, 0x73,
-	0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x62,
-	0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0xc2, 0x01, 0x0a, 0x11, 0x43, 0x6f, 0x75,
-	0x6e, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x35,
+	0x2f, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2f, 0x7b,
+	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x7d, 0x12, 0xef,
+	0x01, 0x0a, 0x1d, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73,
+	0x12, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41,
+	0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41,
+	0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x43, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x4d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x47, 0x12, 0x45, 0x2f, 0x70, 0x72, 0x6f, 0x64,
+	0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67,
+	0x65, 0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73,
+	0x12, 0xcb, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x36, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x75, 0x6c,
+	0x6c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
+	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x12, 0xee,
+	0x01, 0x0a, 0x1c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65,
+	0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x12,
+	0x3d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73,
+	0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65,
+	0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3e,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x41,
-	0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42,
+	0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x79, 0x44, 0x65, 0x76,
+	0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
+	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x65,
+	0x6c, 0x6f, 0x70, 0x65, 0x72, 0x2f, 0x7b, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72,
+	0x7d, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x12,
+	0x81, 0x02, 0x0a, 0x22, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c,
+	0x6f, 0x70, 0x65, 0x72, 0x41, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x42, 0x61, 0x63,
+	0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x42, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
+	0x65, 0x72, 0x41, 0x6e, 0x64, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x42, 0x61, 0x63, 0x6b, 0x77, 0x61,
+	0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73,
+	0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x55, 0x12, 0x53,
+	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x2f, 0x7b, 0x64,
+	0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x7d, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f,
+	0x62, 0x79, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61,
+	0x72, 0x64, 0x73, 0x12, 0xc2, 0x01, 0x0a, 0x11, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e,
+	0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38,
+	0x12, 0x36, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x73, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0xbc, 0x01, 0x0a, 0x18, 0x44, 0x65, 0x62,
+	0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65,
+	0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x45, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
+	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65,
+	0x62, 0x75, 0x67, 0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x2f, 0x61, 0x6c,
+	0x6c, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x12, 0x84, 0x02, 0x0a, 0x29, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53,
+	0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x42, 0x61, 0x63, 0x6b,
+	0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x4a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+	0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
+	0x73, 0x42, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
 	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0xbc, 0x01,
-	0x0a, 0x18, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x65, 0x76, 0x65,
-	0x6c, 0x6f, 0x70, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c,
+	0x6f, 0x70, 0x65, 0x72, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x65, 0x70,
+	0x6f, 0x63, 0x68, 0x73, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0xe8,
+	0x01, 0x0a, 0x24, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d,
+	0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x45, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x45, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f,
+	0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x54, 0x69, 0x6d,
+	0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x37, 0x12, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x73, 0x74, 0x61, 0x74,
+	0x73, 0x5f, 0x62, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x12, 0xeb, 0x01, 0x0a, 0x20, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x12, 0x41,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x42, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x40, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x12, 0x38, 0x2f,
 	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x64, 0x65, 0x62, 0x75, 0x67, 0x2f, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
-	0x65, 0x72, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x12, 0x84, 0x02, 0x0a,
-	0x29, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f,
-	0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68,
-	0x73, 0x42, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x4a, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73,
-	0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x42, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x4f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70, 0x72, 0x6f,
-	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f,
-	0x62, 0x79, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x73, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61,
-	0x72, 0x64, 0x73, 0x12, 0xe8, 0x01, 0x0a, 0x24, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x45, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73,
-	0x42, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
-	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c,
-	0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x12, 0xeb,
-	0x01, 0x0a, 0x20, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64,
-	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64,
-	0x65, 0x6c, 0x73, 0x12, 0x41, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x42, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x41, 0x6e, 0x64, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x53, 0x74, 0x61, 0x74, 0x73, 0x42, 0x79, 0x4d, 0x6f, 0x64, 0x65,
-	0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x40, 0x82, 0xd3, 0xe4, 0x93,
-	0x02, 0x3a, 0x12, 0x38, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x5f, 0x73,
-	0x74, 0x61, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x12, 0xe6, 0x01, 0x0a,
-	0x1b, 0x47, 0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x3c, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d,
-	0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72,
-	0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3d, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4a, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x44, 0x12, 0x42, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x6d, 0x69, 0x6e, 0x69, 0x6d,
-	0x75, 0x6d, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x76,
-	0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0xbf, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61,
-	0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x63, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f,
+	0x62, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x12, 0xe6, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x4d,
+	0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x12, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x47, 0x65, 0x74, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x44, 0x12, 0x42, 0x2f, 0x70,
+	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x67, 0x65, 0x74, 0x5f, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65,
+	0x12, 0xbf, 0x01, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72,
+	0x61, 0x64, 0x65, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67,
+	0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x3e, 0x12, 0x3c, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
+	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61,
+	0x6c, 0x5f, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2f, 0x7b, 0x68, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x7d, 0x12, 0xb9, 0x01, 0x0a, 0x11, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70,
+	0x67, 0x72, 0x61, 0x64, 0x65, 0x41, 0x6c, 0x6c, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70,
 	0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69,
 	0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3e, 0x12, 0x3c, 0x2f, 0x70, 0x72, 0x6f, 0x64,
+	0x65, 0x22, 0x3b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x35, 0x12, 0x33, 0x2f, 0x70, 0x72, 0x6f, 0x64,
 	0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70,
-	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x2f, 0x7b,
-	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xb9, 0x01, 0x0a, 0x11, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x41, 0x6c, 0x6c, 0x12, 0x32, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x72, 0x74,
-	0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x35, 0x12, 0x33,
-	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x67, 0x72,
-	0x61, 0x64, 0x65, 0x12, 0xf0, 0x01, 0x0a, 0x11, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72,
-	0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72,
-	0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x66,
-	0x12, 0x64, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x74, 0x72, 0x61,
-	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e,
-	0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x7d, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e,
-	0x75, 0x6d, 0x62, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x5f,
-	0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xc6, 0x01, 0x0a, 0x12, 0x42, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x36, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69, 0x64,
-	0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61,
-	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3f,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x39, 0x12, 0x37, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
-	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x72, 0x69, 0x64,
-	0x67, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12,
-	0xd4, 0x01, 0x0a, 0x16, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x65, 0x73, 0x42, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72,
-	0x65, 0x73, 0x73, 0x65, 0x73, 0x42, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x42, 0x79,
-	0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x47, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x41, 0x12, 0x3f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
-	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x2f, 0x7b, 0x63, 0x68, 0x61,
-	0x69, 0x6e, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xac, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x71, 0x75, 0x69,
-	0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f,
-	0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x12, 0xf0,
+	0x01, 0x0a, 0x11, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+	0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x6c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x66, 0x12, 0x64, 0x2f, 0x70, 0x72,
+	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74,
+	0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69,
+	0x6e, 0x7d, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+	0x7d, 0x2f, 0x7b, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78,
+	0x7d, 0x12, 0xc6, 0x01, 0x0a, 0x12, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e,
+	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f,
-	0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02,
-	0x34, 0x12, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61,
+	0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42,
+	0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3f, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x39, 0x12, 0x37, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
 	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79,
-	0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x12, 0xd3, 0x01, 0x0a, 0x14, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65,
-	0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x35,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65,
-	0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x74, 0x72,
+	0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0xd4, 0x01, 0x0a, 0x16, 0x42,
+	0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x42, 0x79,
+	0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c,
-	0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4c, 0x82,
-	0xd3, 0xe4, 0x93, 0x02, 0x46, 0x12, 0x44, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
-	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70,
-	0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
-	0x73, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xfe, 0x01, 0x0a, 0x1c,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x3d, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65,
-	0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54,
-	0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3e, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x57,
-	0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72,
-	0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5f, 0x82, 0xd3, 0xe4,
-	0x93, 0x02, 0x59, 0x12, 0x57, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x65, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f,
-	0x66, 0x6f, 0x72, 0x5f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x72,
-	0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xe7, 0x01, 0x0a,
-	0x18, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63,
-	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
-	0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x54, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4e, 0x12, 0x4c, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
-	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x76, 0x61,
-	0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x62, 0x63, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
-	0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x2f, 0x7b, 0x69, 0x62, 0x63, 0x5f,
-	0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x7d, 0x12, 0xd2, 0x01, 0x0a, 0x16, 0x41, 0x70, 0x70, 0x72, 0x6f,
-	0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64,
-	0x65, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x70, 0x70,
-	0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72,
-	0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f,
-	0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x45, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f, 0x70,
+	0x79, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73,
+	0x42, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x42, 0x79, 0x43, 0x68, 0x61, 0x69, 0x6e,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x47, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x41,
+	0x12, 0x3f, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x2f, 0x7b, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64,
+	0x7d, 0x12, 0xac, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50,
+	0x6f, 0x6f, 0x6c, 0x12, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c,
+	0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c,
+	0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x34, 0x12, 0x32, 0x2f, 0x70,
 	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
-	0x73, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x12, 0x9c, 0x01, 0x0a, 0x09,
-	0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x65, 0x2f, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x5f, 0x70, 0x6f, 0x6f, 0x6c,
+	0x12, 0xd3, 0x01, 0x0a, 0x14, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
-	0x79, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x70, 0x72, 0x6f,
-	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0xe6, 0x01, 0x0a, 0x17, 0x43,
-	0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74,
-	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x57, 0x72, 0x61, 0x70,
+	0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x46,
+	0x12, 0x44, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x74, 0x6f,
+	0x6b, 0x65, 0x6e, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xfe, 0x01, 0x0a, 0x1c, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46,
+	0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x3d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70,
+	0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65,
-	0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e,
-	0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x56, 0x82, 0xd3, 0xe4,
-	0x93, 0x02, 0x50, 0x12, 0x4e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
+	0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65,
+	0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x59, 0x12, 0x57,
+	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x77, 0x72, 0x61,
+	0x70, 0x70, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x74,
+	0x72, 0x61, 0x64, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xe7, 0x01, 0x0a, 0x18, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54,
+	0x72, 0x61, 0x64, 0x65, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
+	0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72,
+	0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x54, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x4e, 0x12, 0x4c, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
 	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x70,
-	0x6f, 0x5f, 0x63, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x5f, 0x68,
-	0x65, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67,
-	0x68, 0x74, 0x7d, 0x12, 0xf6, 0x01, 0x0a, 0x1b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x12, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43,
-	0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x3d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x65, 0x5f, 0x69, 0x62, 0x63, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x5f,
+	0x74, 0x72, 0x61, 0x64, 0x65, 0x2f, 0x7b, 0x69, 0x62, 0x63, 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d,
+	0x7d, 0x12, 0xd2, 0x01, 0x0a, 0x16, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x12, 0x37, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x46,
+	0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x45, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x70, 0x70,
+	0x72, 0x6f, 0x76, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x5f, 0x66, 0x6f, 0x72,
+	0x5f, 0x74, 0x72, 0x61, 0x64, 0x65, 0x12, 0x9c, 0x01, 0x0a, 0x09, 0x45, 0x70, 0x6f, 0x63, 0x68,
+	0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x45, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x70, 0x6f, 0x63,
+	0x68, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+	0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0xe6, 0x01, 0x0a, 0x17, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50,
+	0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68,
+	0x74, 0x12, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75,
-	0x6e, 0x74, 0x50, 0x6f, 0x43, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x5a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x54, 0x12, 0x52, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
-	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f,
-	0x75, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x5f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x61, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x7b,
-	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xd6, 0x01, 0x0a,
-	0x15, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37,
+	0x6e, 0x74, 0x50, 0x6f, 0x43, 0x62, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x39, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x62,
+	0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x56, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x50, 0x12, 0x4e,
+	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x70, 0x6f, 0x5f, 0x63, 0x5f, 0x62,
+	0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x5f, 0x61, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xf6,
+	0x01, 0x0a, 0x1b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x3c,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64,
-	0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x46, 0x12,
-	0x44, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74,
-	0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xdc, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c,
-	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69,
-	0x63, 0x65, 0x73, 0x12, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
-	0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c,
-	0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72,
-	0x69, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x40, 0x12, 0x3e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
-	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72,
-	0x69, 0x63, 0x65, 0x73, 0x12, 0xc0, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65,
-	0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70,
-	0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50,
+	0x6f, 0x43, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3d, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
-	0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x45, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
-	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x2f, 0x7b, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xca, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x41,
-	0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65,
-	0x73, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x50, 0x6f, 0x43,
+	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x41, 0x74, 0x48, 0x65, 0x69,
+	0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5a, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x54, 0x12, 0x52, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x70,
+	0x6f, 0x5f, 0x63, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f,
+	0x61, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+	0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xd6, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63,
+	0x65, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
-	0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69,
-	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69,
+	0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
-	0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x40, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x12, 0x38, 0x2f, 0x70, 0x72, 0x6f,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x4c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x46, 0x12, 0x44, 0x2f, 0x70, 0x72, 0x6f,
 	0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69,
-	0x74, 0x69, 0x65, 0x73, 0x12, 0xf3, 0x01, 0x0a, 0x15, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65,
-	0x73, 0x42, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x36,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f,
+	0x70, 0x72, 0x69, 0x63, 0x65, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x7d,
+	0x12, 0xdc, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
+	0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x12, 0x3a,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65,
-	0x65, 0x73, 0x42, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x69, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x63, 0x12, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
-	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x72, 0x61,
-	0x6e, 0x74, 0x65, 0x65, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x2f, 0x7b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x7d, 0x12, 0xb2, 0x01, 0x0a, 0x0d, 0x4d,
-	0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x4c, 0x4e, 0x6f, 0x64,
-	0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x4c,
-	0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x34, 0x12, 0x32, 0x2f, 0x70, 0x72,
-	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x6d, 0x6c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
-	0xc9, 0x01, 0x0a, 0x14, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41,
-	0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41,
-	0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x42, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3c, 0x12,
-	0x3a, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c,
+	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69,
+	0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3b, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65,
+	0x6c, 0x50, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12,
+	0x3e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65,
 	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0xd6, 0x01, 0x0a, 0x14,
-	0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x73, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x70,
+	0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, 0x12,
+	0xc0, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61,
+	0x63, 0x69, 0x74, 0x79, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x4f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70, 0x72,
-	0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
-	0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e,
-	0x64, 0x65, 0x78, 0x7d, 0x12, 0xe2, 0x01, 0x0a, 0x1a, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43,
-	0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76,
-	0x65, 0x6e, 0x74, 0x12, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41,
-	0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x74, 0x69,
-	0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f,
-	0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x49,
-	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x43, 0x12, 0x41, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
+	0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63,
+	0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x45, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x3f, 0x12, 0x3d, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x63,
+	0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x2f, 0x7b, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x69,
+	0x64, 0x7d, 0x12, 0xca, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64,
+	0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x36, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f,
+	0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63,
+	0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x40, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x12, 0x38, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x6c, 0x6c, 0x5f, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12,
+	0xf3, 0x01, 0x0a, 0x15, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x72, 0x61,
+	0x6e, 0x74, 0x65, 0x65, 0x73, 0x42, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79,
+	0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x69, 0x82, 0xd3, 0xe4, 0x93,
+	0x02, 0x63, 0x12, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65, 0x73,
+	0x5f, 0x62, 0x79, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x2f, 0x7b, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
+	0x73, 0x7d, 0x2f, 0x7b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x5f, 0x75, 0x72, 0x6c, 0x7d, 0x12, 0xb2, 0x01, 0x0a, 0x0d, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65,
+	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73,
+	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x56,
+	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3a,
+	0x82, 0xd3, 0xe4, 0x93, 0x02, 0x34, 0x12, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
 	0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x63, 0x74, 0x69,
-	0x76, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
-	0x70, 0x6f, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0xdf, 0x01, 0x0a, 0x19, 0x4c, 0x69,
-	0x73, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f,
-	0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x6c, 0x6e, 0x6f,
+	0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0xc3, 0x01, 0x0a, 0x11, 0x4c,
+	0x61, 0x73, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4c,
+	0x61, 0x73, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
-	0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
-	0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69,
-	0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x51, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4b,
-	0x12, 0x49, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64,
+	0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x3f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x39, 0x12, 0x37, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6c, 0x61, 0x73,
+	0x74, 0x5f, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x12, 0xc9, 0x01, 0x0a, 0x14, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
+	0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x42, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3c,
+	0x12, 0x3a, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
 	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x7b, 0x65,
-	0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xb6, 0x01, 0x0a, 0x0f,
-	0x4c, 0x69, 0x73, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x65, 0x65, 0x64, 0x73, 0x12,
-	0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f,
-	0x6d, 0x53, 0x65, 0x65, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0xd6, 0x01, 0x0a,
+	0x14, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x73, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70,
+	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69,
+	0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xe2, 0x01, 0x0a, 0x1a, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45,
+	0x76, 0x65, 0x6e, 0x74, 0x12, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
+	0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x63, 0x74,
+	0x69, 0x76, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
+	0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x49, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x43, 0x12, 0x41, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x61, 0x63, 0x74,
+	0x69, 0x76, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0xdf, 0x01, 0x0a, 0x19, 0x4c,
+	0x69, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50,
+	0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66,
+	0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x43, 0x45, 0x76, 0x65, 0x6e, 0x74,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x51, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x4b, 0x12, 0x49, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x7b,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xb6, 0x01, 0x0a,
+	0x0f, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x65, 0x65, 0x64, 0x73,
+	0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64,
+	0x6f, 0x6d, 0x53, 0x65, 0x65, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d,
+	0x53, 0x65, 0x65, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82,
+	0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12, 0x3e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+	0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f,
+	0x6d, 0x5f, 0x73, 0x65, 0x65, 0x64, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69,
+	0x6e, 0x64, 0x65, 0x78, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x18, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63,
+	0x65, 0x73, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61,
+	0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e,
 	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53,
-	0x65, 0x65, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3,
-	0xe4, 0x93, 0x02, 0x40, 0x12, 0x3e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
-	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d,
-	0x5f, 0x73, 0x65, 0x65, 0x64, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e,
-	0x64, 0x65, 0x78, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x18, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
 	0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
-	0x73, 0x12, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72,
-	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c,
-	0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3, 0xe4, 0x93, 0x02,
+	0x40, 0x12, 0x3e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x73, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
+	0x73, 0x12, 0xe6, 0x01, 0x0a, 0x15, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x36, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+	0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70,
+	0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5c, 0x82, 0xd3,
+	0xe4, 0x93, 0x02, 0x56, 0x12, 0x54, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63,
+	0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f,
+	0x74, 0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xbb, 0x01, 0x0a, 0x0e, 0x44,
+	0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x32, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73,
+	0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74,
+	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x40, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x12, 0x38,
+	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x65, 0x73, 0x63,
+	0x72, 0x6f, 0x77, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xd1, 0x01, 0x0a, 0x16, 0x50, 0x72, 0x65,
+	0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73,
+	0x68, 0x6f, 0x74, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
+	0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61,
+	0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
-	0x61, 0x6e, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40,
-	0x12, 0x3e, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63,
-	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x73, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73,
-	0x12, 0xe6, 0x01, 0x0a, 0x15, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x36, 0x2e, 0x69, 0x6e, 0x66,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65,
+	0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3e, 0x12, 0x3c,
+	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x6f,
+	0x64, 0x65, 0x73, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0xf4, 0x01, 0x0a,
+	0x16, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f,
+	0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75,
+	0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f,
+	0x73, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47,
+	0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70,
+	0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x61, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5b, 0x12, 0x59, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
+	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65,
+	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63,
+	0x68, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69,
+	0x6e, 0x64, 0x65, 0x78, 0x7d, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x7d, 0x12, 0xba, 0x01, 0x0a, 0x0d, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72,
+	0x79, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x48, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x12, 0x40,
+	0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d,
+	0x12, 0xca, 0x01, 0x0a, 0x11, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65,
+	0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x72, 0x65,
+	0x64, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6f,
-	0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6e, 0x61, 0x70, 0x73,
-	0x68, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5c, 0x82, 0xd3, 0xe4,
-	0x93, 0x02, 0x56, 0x12, 0x54, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69,
-	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
-	0x2f, 0x7b, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72,
-	0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0xbb, 0x01, 0x0a, 0x0e, 0x44, 0x65,
-	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x32, 0x2e, 0x69,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63,
+	0x65, 0x43, 0x72, 0x65, 0x64, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x4c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x46, 0x12, 0x44, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
+	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69,
+	0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x2f,
+	0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x12, 0xd6, 0x01,
+	0x0a, 0x14, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x63, 0x68,
+	0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x12, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x63, 0x68,
+	0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f,
+	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73,
+	0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x12, 0xbc, 0x01, 0x0a, 0x11, 0x4d, 0x61, 0x69, 0x6e, 0x74,
+	0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x32, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68,
-	0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
 	0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x44,
-	0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x40, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x12, 0x38, 0x2f,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e,
+	0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f,
 	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x65, 0x73, 0x63, 0x72,
-	0x6f, 0x77, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xd1, 0x01, 0x0a, 0x16, 0x50, 0x72, 0x65, 0x73,
-	0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68,
-	0x6f, 0x74, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72,
-	0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70,
-	0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e,
+	0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x61,
+	0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0xca, 0x01, 0x0a, 0x11, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x32, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64,
-	0x4e, 0x6f, 0x64, 0x65, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3e, 0x12, 0x3c, 0x2f,
+	0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74,
+	0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x46, 0x12, 0x44, 0x2f, 0x70,
+	0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x74,
+	0x61, 0x74, 0x75, 0x73, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x16, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x37, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
+	0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x6f, 0x6e,
+	0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x4c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x46, 0x12, 0x44, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75,
+	0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x61,
+	0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72,
+	0x72, 0x65, 0x6e, 0x63, 0x79, 0x2f, 0x7b, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x12, 0x8b,
+	0x02, 0x0a, 0x19, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x63,
+	0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x3a, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
+	0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x53,
+	0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x75, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x6f, 0x12, 0x6d, 0x2f,
 	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64,
-	0x65, 0x73, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0xf4, 0x01, 0x0a, 0x16,
-	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f, 0x63,
-	0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x47, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73,
-	0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x3b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65,
-	0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x45, 0x70, 0x6f,
-	0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x61, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5b, 0x12, 0x59, 0x2f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63,
-	0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x76,
-	0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
-	0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x2f, 0x7b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e,
-	0x64, 0x65, 0x78, 0x7d, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x7d, 0x12, 0xba, 0x01, 0x0a, 0x0d, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x73,
+	0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2f, 0x7b, 0x70,
+	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x2f, 0x7b, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x7d, 0x2f, 0x7b, 0x64, 0x75, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x7d, 0x12, 0xd3, 0x01, 0x0a,
+	0x13, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69,
+	0x65, 0x6e, 0x74, 0x73, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79,
-	0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x48, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x12, 0x40, 0x2f,
-	0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69,
+	0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65,
+	0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52,
+	0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x4f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x49, 0x12, 0x47, 0x2f, 0x70, 0x72, 0x6f, 0x64,
+	0x75, 0x63, 0x74, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6c,
+	0x69, 0x73, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69,
+	0x65, 0x6e, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x7d, 0x42, 0xb8, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x0a,
+	0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x2f, 0x7b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x7d, 0x42,
-	0xb8, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x0a, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
-	0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2,
-	0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64,
-	0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a,
-	0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x33,
+	0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02,
+	0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65,
+	0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -86761,7 +95828,7 @@ func file_inference_inference_query_proto_rawDescGZIP() []byte {
 	return file_inference_inference_query_proto_rawDescData
 }
 
-var file_inference_inference_query_proto_msgTypes = make([]protoimpl.MessageInfo, 166)
+var file_inference_inference_query_proto_msgTypes = make([]protoimpl.MessageInfo, 184)
 var file_inference_inference_query_proto_goTypes = []interface{}{
 	(*QueryParamsRequest)(nil),                                    // 0: inference.inference.QueryParamsRequest
 	(*QueryParamsResponse)(nil),                                   // 1: inference.inference.QueryParamsResponse
@@ -86785,445 +95852,491 @@ var file_inference_inference_query_proto_goTypes = []interface{}{
 	(*QueryGetSettleAmountResponse)(nil),                          // 19: inference.inference.QueryGetSettleAmountResponse
 	(*QueryAllSettleAmountRequest)(nil),                           // 20: inference.inference.QueryAllSettleAmountRequest
 	(*QueryAllSettleAmountResponse)(nil),                          // 21: inference.inference.QueryAllSettleAmountResponse
-	(*QueryGetEpochGroupValidationsRequest)(nil),                  // 22: inference.inference.QueryGetEpochGroupValidationsRequest
-	(*QueryGetEpochGroupValidationsResponse)(nil),                 // 23: inference.inference.QueryGetEpochGroupValidationsResponse
-	(*QueryAllEpochGroupValidationsRequest)(nil),                  // 24: inference.inference.QueryAllEpochGroupValidationsRequest
-	(*QueryAllEpochGroupValidationsResponse)(nil),                 // 25: inference.inference.QueryAllEpochGroupValidationsResponse
-	(*QueryPocBatchesForStageRequest)(nil),                        // 26: inference.inference.QueryPocBatchesForStageRequest
-	(*QueryPocBatchesForStageResponse)(nil),                       // 27: inference.inference.QueryPocBatchesForStageResponse
-	(*PoCBatchesWithParticipants)(nil),                            // 28: inference.inference.PoCBatchesWithParticipants
-	(*QueryPocValidationsForStageRequest)(nil),                    // 29: inference.inference.QueryPocValidationsForStageRequest
-	(*QueryPocValidationsForStageResponse)(nil),                   // 30: inference.inference.QueryPocValidationsForStageResponse
-	(*PoCValidationsWithParticipants)(nil),                        // 31: inference.inference.PoCValidationsWithParticipants
-	(*QueryPocV2ValidationsForStageRequest)(nil),                  // 32: inference.inference.QueryPocV2ValidationsForStageRequest
-	(*QueryPocV2ValidationsForStageResponse)(nil),                 // 33: inference.inference.QueryPocV2ValidationsForStageResponse
-	(*PoCValidationsWithParticipantsV2)(nil),                      // 34: inference.inference.PoCValidationsWithParticipantsV2
-	(*QueryPoCV2StoreCommitRequest)(nil),                          // 35: inference.inference.QueryPoCV2StoreCommitRequest
-	(*QueryPoCV2StoreCommitResponse)(nil),                         // 36: inference.inference.QueryPoCV2StoreCommitResponse
-	(*QueryMLNodeWeightDistributionRequest)(nil),                  // 37: inference.inference.QueryMLNodeWeightDistributionRequest
-	(*QueryMLNodeWeightDistributionResponse)(nil),                 // 38: inference.inference.QueryMLNodeWeightDistributionResponse
-	(*QueryAllPoCV2StoreCommitsForStageRequest)(nil),              // 39: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest
-	(*QueryAllPoCV2StoreCommitsForStageResponse)(nil),             // 40: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse
-	(*PoCV2StoreCommitWithAddress)(nil),                           // 41: inference.inference.PoCV2StoreCommitWithAddress
-	(*QueryAllMLNodeWeightDistributionsForStageRequest)(nil),      // 42: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest
-	(*QueryAllMLNodeWeightDistributionsForStageResponse)(nil),     // 43: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse
-	(*MLNodeWeightDistributionWithAddress)(nil),                   // 44: inference.inference.MLNodeWeightDistributionWithAddress
-	(*QueryGetCurrentEpochRequest)(nil),                           // 45: inference.inference.QueryGetCurrentEpochRequest
-	(*QueryGetCurrentEpochResponse)(nil),                          // 46: inference.inference.QueryGetCurrentEpochResponse
-	(*QueryGetTokenomicsDataRequest)(nil),                         // 47: inference.inference.QueryGetTokenomicsDataRequest
-	(*QueryGetTokenomicsDataResponse)(nil),                        // 48: inference.inference.QueryGetTokenomicsDataResponse
-	(*QueryGetUnitOfComputePriceProposalRequest)(nil),             // 49: inference.inference.QueryGetUnitOfComputePriceProposalRequest
-	(*QueryGetUnitOfComputePriceProposalResponse)(nil),            // 50: inference.inference.QueryGetUnitOfComputePriceProposalResponse
-	(*QueryCurrentEpochGroupDataRequest)(nil),                     // 51: inference.inference.QueryCurrentEpochGroupDataRequest
-	(*QueryCurrentEpochGroupDataResponse)(nil),                    // 52: inference.inference.QueryCurrentEpochGroupDataResponse
-	(*QueryPreviousEpochGroupDataRequest)(nil),                    // 53: inference.inference.QueryPreviousEpochGroupDataRequest
-	(*QueryPreviousEpochGroupDataResponse)(nil),                   // 54: inference.inference.QueryPreviousEpochGroupDataResponse
-	(*QueryModelsAllRequest)(nil),                                 // 55: inference.inference.QueryModelsAllRequest
-	(*QueryModelsAllResponse)(nil),                                // 56: inference.inference.QueryModelsAllResponse
-	(*QueryGetInferenceTimeoutRequest)(nil),                       // 57: inference.inference.QueryGetInferenceTimeoutRequest
-	(*QueryGetInferenceTimeoutResponse)(nil),                      // 58: inference.inference.QueryGetInferenceTimeoutResponse
-	(*QueryAllInferenceTimeoutRequest)(nil),                       // 59: inference.inference.QueryAllInferenceTimeoutRequest
-	(*QueryAllInferenceTimeoutResponse)(nil),                      // 60: inference.inference.QueryAllInferenceTimeoutResponse
-	(*QueryGetInferenceValidationDetailsRequest)(nil),             // 61: inference.inference.QueryGetInferenceValidationDetailsRequest
-	(*QueryGetInferenceValidationDetailsResponse)(nil),            // 62: inference.inference.QueryGetInferenceValidationDetailsResponse
-	(*QueryAllInferenceValidationDetailsRequest)(nil),             // 63: inference.inference.QueryAllInferenceValidationDetailsRequest
-	(*QueryAllInferenceValidationDetailsResponse)(nil),            // 64: inference.inference.QueryAllInferenceValidationDetailsResponse
-	(*QueryGetInferenceValidationParametersRequest)(nil),          // 65: inference.inference.QueryGetInferenceValidationParametersRequest
-	(*QueryGetInferenceValidationParametersResponse)(nil),         // 66: inference.inference.QueryGetInferenceValidationParametersResponse
-	(*ValidatorPower)(nil),                                        // 67: inference.inference.ValidatorPower
-	(*QueryEpochPerformanceSummaryByEpochRequest)(nil),            // 68: inference.inference.QueryEpochPerformanceSummaryByEpochRequest
-	(*QueryEpochPerformanceSummaryByEpochResponse)(nil),           // 69: inference.inference.QueryEpochPerformanceSummaryByEpochResponse
-	(*QueryEpochPerformanceSummaryByParticipantRequest)(nil),      // 70: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest
-	(*QueryEpochPerformanceSummaryByParticipantResponse)(nil),     // 71: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse
-	(*QueryAllEpochPerformanceSummaryRequest)(nil),                // 72: inference.inference.QueryAllEpochPerformanceSummaryRequest
-	(*QueryAllEpochPerformanceSummaryResponse)(nil),               // 73: inference.inference.QueryAllEpochPerformanceSummaryResponse
-	(*QueryHardwareNodesRequest)(nil),                             // 74: inference.inference.QueryHardwareNodesRequest
-	(*QueryHardwareNodesResponse)(nil),                            // 75: inference.inference.QueryHardwareNodesResponse
-	(*QueryHardwareNodesAllRequest)(nil),                          // 76: inference.inference.QueryHardwareNodesAllRequest
-	(*QueryHardwareNodesAllResponse)(nil),                         // 77: inference.inference.QueryHardwareNodesAllResponse
-	(*QueryGetParticipantCurrentStatsRequest)(nil),                // 78: inference.inference.QueryGetParticipantCurrentStatsRequest
-	(*QueryGetParticipantCurrentStatsResponse)(nil),               // 79: inference.inference.QueryGetParticipantCurrentStatsResponse
-	(*QueryGetAllParticipantCurrentStatsRequest)(nil),             // 80: inference.inference.QueryGetAllParticipantCurrentStatsRequest
-	(*QueryGetAllParticipantCurrentStatsResponse)(nil),            // 81: inference.inference.QueryGetAllParticipantCurrentStatsResponse
-	(*ParticipantCurrentStats)(nil),                               // 82: inference.inference.ParticipantCurrentStats
-	(*ParticipantFullStats)(nil),                                  // 83: inference.inference.ParticipantFullStats
-	(*QueryParticipantsFullStatsRequest)(nil),                     // 84: inference.inference.QueryParticipantsFullStatsRequest
-	(*QueryParticipantsFullStatsResponse)(nil),                    // 85: inference.inference.QueryParticipantsFullStatsResponse
-	(*QueryStatsByTimePeriodByDeveloperRequest)(nil),              // 86: inference.inference.QueryStatsByTimePeriodByDeveloperRequest
-	(*QueryStatsByTimePeriodByDeveloperResponse)(nil),             // 87: inference.inference.QueryStatsByTimePeriodByDeveloperResponse
-	(*QueryStatsByDeveloperAndEpochBackwardsRequest)(nil),         // 88: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest
-	(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil), // 89: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest
-	(*QueryInferencesAndTokensStatsByTimePeriodRequest)(nil),      // 90: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest
-	(*QueryInferencesAndTokensStatsByModelsRequest)(nil),          // 91: inference.inference.QueryInferencesAndTokensStatsByModelsRequest
-	(*ModelStats)(nil),                                            // 92: inference.inference.ModelStats
-	(*QueryInferencesAndTokensStatsByModelsResponse)(nil),         // 93: inference.inference.QueryInferencesAndTokensStatsByModelsResponse
-	(*QueryInferencesAndTokensStatsResponse)(nil),                 // 94: inference.inference.QueryInferencesAndTokensStatsResponse
-	(*QueryCountAllParticipantsRequest)(nil),                      // 95: inference.inference.QueryCountAllParticipantsRequest
-	(*QueryCountAllParticipantsResponse)(nil),                     // 96: inference.inference.QueryCountAllParticipantsResponse
-	(*QueryDebugStatsRequest)(nil),                                // 97: inference.inference.QueryDebugStatsRequest
-	(*QueryDebugStatsResponse)(nil),                               // 98: inference.inference.QueryDebugStatsResponse
-	(*QueryGetMinimumValidationAverageRequest)(nil),               // 99: inference.inference.QueryGetMinimumValidationAverageRequest
-	(*QueryGetMinimumValidationAverageResponse)(nil),              // 100: inference.inference.QueryGetMinimumValidationAverageResponse
-	(*QueryGetPartialUpgradeRequest)(nil),                         // 101: inference.inference.QueryGetPartialUpgradeRequest
-	(*QueryGetPartialUpgradeResponse)(nil),                        // 102: inference.inference.QueryGetPartialUpgradeResponse
-	(*QueryAllPartialUpgradeRequest)(nil),                         // 103: inference.inference.QueryAllPartialUpgradeRequest
-	(*QueryAllPartialUpgradeResponse)(nil),                        // 104: inference.inference.QueryAllPartialUpgradeResponse
-	(*QueryGetBridgeTransactionRequest)(nil),                      // 105: inference.inference.QueryGetBridgeTransactionRequest
-	(*QueryGetBridgeTransactionResponse)(nil),                     // 106: inference.inference.QueryGetBridgeTransactionResponse
-	(*QueryAllBridgeTransactionsRequest)(nil),                     // 107: inference.inference.QueryAllBridgeTransactionsRequest
-	(*QueryAllBridgeTransactionsResponse)(nil),                    // 108: inference.inference.QueryAllBridgeTransactionsResponse
-	(*WrappedTokenBalance)(nil),                                   // 109: inference.inference.WrappedTokenBalance
-	(*QueryWrappedTokenBalancesRequest)(nil),                      // 110: inference.inference.QueryWrappedTokenBalancesRequest
-	(*QueryWrappedTokenBalancesResponse)(nil),                     // 111: inference.inference.QueryWrappedTokenBalancesResponse
-	(*QueryBridgeAddressesByChainRequest)(nil),                    // 112: inference.inference.QueryBridgeAddressesByChainRequest
-	(*QueryBridgeAddressesByChainResponse)(nil),                   // 113: inference.inference.QueryBridgeAddressesByChainResponse
-	(*QueryValidateWrappedTokenForTradeRequest)(nil),              // 114: inference.inference.QueryValidateWrappedTokenForTradeRequest
-	(*QueryValidateWrappedTokenForTradeResponse)(nil),             // 115: inference.inference.QueryValidateWrappedTokenForTradeResponse
-	(*QueryValidateIbcTokenForTradeRequest)(nil),                  // 116: inference.inference.QueryValidateIbcTokenForTradeRequest
-	(*QueryValidateIbcTokenForTradeResponse)(nil),                 // 117: inference.inference.QueryValidateIbcTokenForTradeResponse
-	(*QueryLiquidityPoolRequest)(nil),                             // 118: inference.inference.QueryLiquidityPoolRequest
-	(*QueryLiquidityPoolResponse)(nil),                            // 119: inference.inference.QueryLiquidityPoolResponse
-	(*QueryEpochInfoRequest)(nil),                                 // 120: inference.inference.QueryEpochInfoRequest
-	(*QueryEpochInfoResponse)(nil),                                // 121: inference.inference.QueryEpochInfoResponse
-	(*QueryCountPoCbatchesAtHeightRequest)(nil),                   // 122: inference.inference.QueryCountPoCbatchesAtHeightRequest
-	(*QueryCountPoCbatchesAtHeightResponse)(nil),                  // 123: inference.inference.QueryCountPoCbatchesAtHeightResponse
-	(*QueryCountPoCvalidationsAtHeightRequest)(nil),               // 124: inference.inference.QueryCountPoCvalidationsAtHeightRequest
-	(*QueryCountPoCvalidationsAtHeightResponse)(nil),              // 125: inference.inference.QueryCountPoCvalidationsAtHeightResponse
-	(*QueryApprovedTokensForTradeRequest)(nil),                    // 126: inference.inference.QueryApprovedTokensForTradeRequest
-	(*QueryApprovedTokensForTradeResponse)(nil),                   // 127: inference.inference.QueryApprovedTokensForTradeResponse
-	(*QueryGetModelPerTokenPriceRequest)(nil),                     // 128: inference.inference.QueryGetModelPerTokenPriceRequest
-	(*QueryGetModelPerTokenPriceResponse)(nil),                    // 129: inference.inference.QueryGetModelPerTokenPriceResponse
-	(*QueryGetAllModelPerTokenPricesRequest)(nil),                 // 130: inference.inference.QueryGetAllModelPerTokenPricesRequest
-	(*ModelPrice)(nil),                                            // 131: inference.inference.ModelPrice
-	(*QueryGetAllModelPerTokenPricesResponse)(nil),                // 132: inference.inference.QueryGetAllModelPerTokenPricesResponse
-	(*QueryGetModelCapacityRequest)(nil),                          // 133: inference.inference.QueryGetModelCapacityRequest
-	(*QueryGetModelCapacityResponse)(nil),                         // 134: inference.inference.QueryGetModelCapacityResponse
-	(*QueryGetAllModelCapacitiesRequest)(nil),                     // 135: inference.inference.QueryGetAllModelCapacitiesRequest
-	(*QueryGetAllModelCapacitiesResponse)(nil),                    // 136: inference.inference.QueryGetAllModelCapacitiesResponse
-	(*ModelCapacity)(nil),                                         // 137: inference.inference.ModelCapacity
-	(*QueryGranteesByMessageTypeRequest)(nil),                     // 138: inference.inference.QueryGranteesByMessageTypeRequest
-	(*Grantee)(nil), // 139: inference.inference.Grantee
-	(*QueryGranteesByMessageTypeResponse)(nil),         // 140: inference.inference.QueryGranteesByMessageTypeResponse
-	(*QueryParticipantAllowListRequest)(nil),           // 141: inference.inference.QueryParticipantAllowListRequest
-	(*QueryParticipantAllowListResponse)(nil),          // 142: inference.inference.QueryParticipantAllowListResponse
-	(*QueryGetMLNodeVersionRequest)(nil),               // 143: inference.inference.QueryGetMLNodeVersionRequest
-	(*QueryGetMLNodeVersionResponse)(nil),              // 144: inference.inference.QueryGetMLNodeVersionResponse
-	(*QueryExcludedParticipantsRequest)(nil),           // 145: inference.inference.QueryExcludedParticipantsRequest
-	(*QueryExcludedParticipantsResponse)(nil),          // 146: inference.inference.QueryExcludedParticipantsResponse
-	(*QueryActiveConfirmationPoCEventRequest)(nil),     // 147: inference.inference.QueryActiveConfirmationPoCEventRequest
-	(*QueryActiveConfirmationPoCEventResponse)(nil),    // 148: inference.inference.QueryActiveConfirmationPoCEventResponse
-	(*QueryConfirmationPoCEventsRequest)(nil),          // 149: inference.inference.QueryConfirmationPoCEventsRequest
-	(*QueryConfirmationPoCEventsResponse)(nil),         // 150: inference.inference.QueryConfirmationPoCEventsResponse
-	(*ParticipantWithBalance)(nil),                     // 151: inference.inference.ParticipantWithBalance
-	(*QueryParticipantsWithBalancesRequest)(nil),       // 152: inference.inference.QueryParticipantsWithBalancesRequest
-	(*QueryParticipantsWithBalancesResponse)(nil),      // 153: inference.inference.QueryParticipantsWithBalancesResponse
-	(*QueryRandomSeedsRequest)(nil),                    // 154: inference.inference.QueryRandomSeedsRequest
-	(*QueryRandomSeedsResponse)(nil),                   // 155: inference.inference.QueryRandomSeedsResponse
-	(*QueryPoCValidationSnapshotRequest)(nil),          // 156: inference.inference.QueryPoCValidationSnapshotRequest
-	(*QueryPoCValidationSnapshotResponse)(nil),         // 157: inference.inference.QueryPoCValidationSnapshotResponse
-	(*QueryPreservedNodesSnapshotRequest)(nil),         // 158: inference.inference.QueryPreservedNodesSnapshotRequest
-	(*QueryPreservedNodesSnapshotResponse)(nil),        // 159: inference.inference.QueryPreservedNodesSnapshotResponse
-	(*QueryGetDevshardEscrowRequest)(nil),              // 160: inference.inference.QueryGetDevshardEscrowRequest
-	(*QueryGetDevshardEscrowResponse)(nil),             // 161: inference.inference.QueryGetDevshardEscrowResponse
-	(*QueryGetDevshardHostEpochStatsRequest)(nil),      // 162: inference.inference.QueryGetDevshardHostEpochStatsRequest
-	(*QueryGetDevshardHostEpochStatsResponse)(nil),     // 163: inference.inference.QueryGetDevshardHostEpochStatsResponse
-	(*QueryDebugStatsResponse_TemporaryTimeStat)(nil),  // 164: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat
-	(*QueryDebugStatsResponse_TemporaryEpochStat)(nil), // 165: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat
-	(*Params)(nil),                     // 166: inference.inference.Params
-	(*Inference)(nil),                  // 167: inference.inference.Inference
-	(*v1beta1.PageRequest)(nil),        // 168: cosmos.base.query.v1beta1.PageRequest
-	(*v1beta1.PageResponse)(nil),       // 169: cosmos.base.query.v1beta1.PageResponse
-	(*Participant)(nil),                // 170: inference.inference.Participant
-	(*EpochGroupData)(nil),             // 171: inference.inference.EpochGroupData
-	(*SettleAmount)(nil),               // 172: inference.inference.SettleAmount
-	(*EpochGroupValidations)(nil),      // 173: inference.inference.EpochGroupValidations
-	(*PoCBatch)(nil),                   // 174: inference.inference.PoCBatch
-	(*PoCValidation)(nil),              // 175: inference.inference.PoCValidation
-	(*PoCValidationV2)(nil),            // 176: inference.inference.PoCValidationV2
-	(*MLNodeWeight)(nil),               // 177: inference.inference.MLNodeWeight
-	(*TokenomicsData)(nil),             // 178: inference.inference.TokenomicsData
-	(*UnitOfComputePriceProposal)(nil), // 179: inference.inference.UnitOfComputePriceProposal
-	(*Model)(nil),                      // 180: inference.inference.Model
-	(*InferenceTimeout)(nil),           // 181: inference.inference.InferenceTimeout
-	(*InferenceValidationDetails)(nil), // 182: inference.inference.InferenceValidationDetails
-	(*ValidationParams)(nil),           // 183: inference.inference.ValidationParams
-	(*EpochPerformanceSummary)(nil),    // 184: inference.inference.EpochPerformanceSummary
-	(*HardwareNodes)(nil),              // 185: inference.inference.HardwareNodes
-	(*DeveloperStatsByTime)(nil),       // 186: inference.inference.DeveloperStatsByTime
-	(*PartialUpgrade)(nil),             // 187: inference.inference.PartialUpgrade
-	(*BridgeTransaction)(nil),          // 188: inference.inference.BridgeTransaction
-	(*BridgeWrappedTokenContract)(nil), // 189: inference.inference.BridgeWrappedTokenContract
-	(*BridgeContractAddress)(nil),      // 190: inference.inference.BridgeContractAddress
-	(*Epoch)(nil),                      // 191: inference.inference.Epoch
-	(*ConfirmationPoCEvent)(nil),       // 192: inference.inference.ConfirmationPoCEvent
-	(*BridgeTokenReference)(nil),       // 193: inference.inference.BridgeTokenReference
-	(*MLNodeVersion)(nil),              // 194: inference.inference.MLNodeVersion
-	(*ExcludedParticipant)(nil),        // 195: inference.inference.ExcludedParticipant
-	(*v1beta11.Coin)(nil),              // 196: cosmos.base.v1beta1.Coin
-	(*RandomSeed)(nil),                 // 197: inference.inference.RandomSeed
-	(*PoCValidationSnapshot)(nil),      // 198: inference.inference.PoCValidationSnapshot
-	(*PreservedNodesSnapshot)(nil),     // 199: inference.inference.PreservedNodesSnapshot
-	(*DevshardEscrow)(nil),             // 200: inference.inference.DevshardEscrow
-	(*DevshardHostEpochStats)(nil),     // 201: inference.inference.DevshardHostEpochStats
-	(*DeveloperStatsByEpoch)(nil),      // 202: inference.inference.DeveloperStatsByEpoch
-	(*QueryPoCDelegationRequest)(nil),  // 203: inference.inference.QueryPoCDelegationRequest
-	(*QueryPoCDelegationResponse)(nil), // 204: inference.inference.QueryPoCDelegationResponse
+	(*QueryEstimateBitcoinRewardRequest)(nil),                     // 22: inference.inference.QueryEstimateBitcoinRewardRequest
+	(*QueryEstimateBitcoinRewardResponse)(nil),                    // 23: inference.inference.QueryEstimateBitcoinRewardResponse
+	(*QueryGetEpochGroupValidationsRequest)(nil),                  // 24: inference.inference.QueryGetEpochGroupValidationsRequest
+	(*QueryGetEpochGroupValidationsResponse)(nil),                 // 25: inference.inference.QueryGetEpochGroupValidationsResponse
+	(*QueryAllEpochGroupValidationsRequest)(nil),                  // 26: inference.inference.QueryAllEpochGroupValidationsRequest
+	(*QueryAllEpochGroupValidationsResponse)(nil),                 // 27: inference.inference.QueryAllEpochGroupValidationsResponse
+	(*QueryPocBatchesForStageRequest)(nil),                        // 28: inference.inference.QueryPocBatchesForStageRequest
+	(*QueryPocBatchesForStageResponse)(nil),                       // 29: inference.inference.QueryPocBatchesForStageResponse
+	(*PoCBatchesWithParticipants)(nil),                            // 30: inference.inference.PoCBatchesWithParticipants
+	(*QueryPocValidationsForStageRequest)(nil),                    // 31: inference.inference.QueryPocValidationsForStageRequest
+	(*QueryPocValidationsForStageResponse)(nil),                   // 32: inference.inference.QueryPocValidationsForStageResponse
+	(*PoCValidationsWithParticipants)(nil),                        // 33: inference.inference.PoCValidationsWithParticipants
+	(*QueryPocV2ValidationsForStageRequest)(nil),                  // 34: inference.inference.QueryPocV2ValidationsForStageRequest
+	(*QueryPocV2ValidationsForStageResponse)(nil),                 // 35: inference.inference.QueryPocV2ValidationsForStageResponse
+	(*PoCValidationsWithParticipantsV2)(nil),                      // 36: inference.inference.PoCValidationsWithParticipantsV2
+	(*QueryPoCV2StoreCommitRequest)(nil),                          // 37: inference.inference.QueryPoCV2StoreCommitRequest
+	(*QueryPoCV2StoreCommitResponse)(nil),                         // 38: inference.inference.QueryPoCV2StoreCommitResponse
+	(*QueryMLNodeWeightDistributionRequest)(nil),                  // 39: inference.inference.QueryMLNodeWeightDistributionRequest
+	(*QueryMLNodeWeightDistributionResponse)(nil),                 // 40: inference.inference.QueryMLNodeWeightDistributionResponse
+	(*QueryAllPoCV2StoreCommitsForStageRequest)(nil),              // 41: inference.inference.QueryAllPoCV2StoreCommitsForStageRequest
+	(*QueryAllPoCV2StoreCommitsForStageResponse)(nil),             // 42: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse
+	(*PoCV2StoreCommitWithAddress)(nil),                           // 43: inference.inference.PoCV2StoreCommitWithAddress
+	(*QueryAllMLNodeWeightDistributionsForStageRequest)(nil),      // 44: inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest
+	(*QueryAllMLNodeWeightDistributionsForStageResponse)(nil),     // 45: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse
+	(*MLNodeWeightDistributionWithAddress)(nil),                   // 46: inference.inference.MLNodeWeightDistributionWithAddress
+	(*QueryGetCurrentEpochRequest)(nil),                           // 47: inference.inference.QueryGetCurrentEpochRequest
+	(*QueryGetCurrentEpochResponse)(nil),                          // 48: inference.inference.QueryGetCurrentEpochResponse
+	(*QueryGetTokenomicsDataRequest)(nil),                         // 49: inference.inference.QueryGetTokenomicsDataRequest
+	(*QueryGetTokenomicsDataResponse)(nil),                        // 50: inference.inference.QueryGetTokenomicsDataResponse
+	(*QueryGetUnitOfComputePriceProposalRequest)(nil),             // 51: inference.inference.QueryGetUnitOfComputePriceProposalRequest
+	(*QueryGetUnitOfComputePriceProposalResponse)(nil),            // 52: inference.inference.QueryGetUnitOfComputePriceProposalResponse
+	(*QueryCurrentEpochGroupDataRequest)(nil),                     // 53: inference.inference.QueryCurrentEpochGroupDataRequest
+	(*QueryCurrentEpochGroupDataResponse)(nil),                    // 54: inference.inference.QueryCurrentEpochGroupDataResponse
+	(*QueryPreviousEpochGroupDataRequest)(nil),                    // 55: inference.inference.QueryPreviousEpochGroupDataRequest
+	(*QueryPreviousEpochGroupDataResponse)(nil),                   // 56: inference.inference.QueryPreviousEpochGroupDataResponse
+	(*QueryModelsAllRequest)(nil),                                 // 57: inference.inference.QueryModelsAllRequest
+	(*QueryModelsAllResponse)(nil),                                // 58: inference.inference.QueryModelsAllResponse
+	(*QueryGetInferenceTimeoutRequest)(nil),                       // 59: inference.inference.QueryGetInferenceTimeoutRequest
+	(*QueryGetInferenceTimeoutResponse)(nil),                      // 60: inference.inference.QueryGetInferenceTimeoutResponse
+	(*QueryAllInferenceTimeoutRequest)(nil),                       // 61: inference.inference.QueryAllInferenceTimeoutRequest
+	(*QueryAllInferenceTimeoutResponse)(nil),                      // 62: inference.inference.QueryAllInferenceTimeoutResponse
+	(*QueryGetInferenceValidationDetailsRequest)(nil),             // 63: inference.inference.QueryGetInferenceValidationDetailsRequest
+	(*QueryGetInferenceValidationDetailsResponse)(nil),            // 64: inference.inference.QueryGetInferenceValidationDetailsResponse
+	(*QueryAllInferenceValidationDetailsRequest)(nil),             // 65: inference.inference.QueryAllInferenceValidationDetailsRequest
+	(*QueryAllInferenceValidationDetailsResponse)(nil),            // 66: inference.inference.QueryAllInferenceValidationDetailsResponse
+	(*QueryGetInferenceValidationParametersRequest)(nil),          // 67: inference.inference.QueryGetInferenceValidationParametersRequest
+	(*QueryGetInferenceValidationParametersResponse)(nil),         // 68: inference.inference.QueryGetInferenceValidationParametersResponse
+	(*ValidatorPower)(nil),                                        // 69: inference.inference.ValidatorPower
+	(*QueryEpochPerformanceSummaryByEpochRequest)(nil),            // 70: inference.inference.QueryEpochPerformanceSummaryByEpochRequest
+	(*QueryEpochPerformanceSummaryByEpochResponse)(nil),           // 71: inference.inference.QueryEpochPerformanceSummaryByEpochResponse
+	(*QueryEpochPerformanceSummaryByParticipantRequest)(nil),      // 72: inference.inference.QueryEpochPerformanceSummaryByParticipantRequest
+	(*QueryEpochPerformanceSummaryByParticipantResponse)(nil),     // 73: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse
+	(*QueryAllEpochPerformanceSummaryRequest)(nil),                // 74: inference.inference.QueryAllEpochPerformanceSummaryRequest
+	(*QueryAllEpochPerformanceSummaryResponse)(nil),               // 75: inference.inference.QueryAllEpochPerformanceSummaryResponse
+	(*QueryHardwareNodesRequest)(nil),                             // 76: inference.inference.QueryHardwareNodesRequest
+	(*QueryHardwareNodesResponse)(nil),                            // 77: inference.inference.QueryHardwareNodesResponse
+	(*QueryHardwareNodesAllRequest)(nil),                          // 78: inference.inference.QueryHardwareNodesAllRequest
+	(*QueryHardwareNodesAllResponse)(nil),                         // 79: inference.inference.QueryHardwareNodesAllResponse
+	(*QueryGetParticipantCurrentStatsRequest)(nil),                // 80: inference.inference.QueryGetParticipantCurrentStatsRequest
+	(*QueryGetParticipantCurrentStatsResponse)(nil),               // 81: inference.inference.QueryGetParticipantCurrentStatsResponse
+	(*QueryGetAllParticipantCurrentStatsRequest)(nil),             // 82: inference.inference.QueryGetAllParticipantCurrentStatsRequest
+	(*QueryGetAllParticipantCurrentStatsResponse)(nil),            // 83: inference.inference.QueryGetAllParticipantCurrentStatsResponse
+	(*ParticipantCurrentStats)(nil),                               // 84: inference.inference.ParticipantCurrentStats
+	(*ParticipantFullStats)(nil),                                  // 85: inference.inference.ParticipantFullStats
+	(*QueryParticipantsFullStatsRequest)(nil),                     // 86: inference.inference.QueryParticipantsFullStatsRequest
+	(*QueryParticipantsFullStatsResponse)(nil),                    // 87: inference.inference.QueryParticipantsFullStatsResponse
+	(*QueryStatsByTimePeriodByDeveloperRequest)(nil),              // 88: inference.inference.QueryStatsByTimePeriodByDeveloperRequest
+	(*QueryStatsByTimePeriodByDeveloperResponse)(nil),             // 89: inference.inference.QueryStatsByTimePeriodByDeveloperResponse
+	(*QueryStatsByDeveloperAndEpochBackwardsRequest)(nil),         // 90: inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest
+	(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil), // 91: inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest
+	(*QueryInferencesAndTokensStatsByTimePeriodRequest)(nil),      // 92: inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest
+	(*QueryInferencesAndTokensStatsByModelsRequest)(nil),          // 93: inference.inference.QueryInferencesAndTokensStatsByModelsRequest
+	(*ModelStats)(nil),                                            // 94: inference.inference.ModelStats
+	(*QueryInferencesAndTokensStatsByModelsResponse)(nil),         // 95: inference.inference.QueryInferencesAndTokensStatsByModelsResponse
+	(*QueryInferencesAndTokensStatsResponse)(nil),                 // 96: inference.inference.QueryInferencesAndTokensStatsResponse
+	(*QueryCountAllParticipantsRequest)(nil),                      // 97: inference.inference.QueryCountAllParticipantsRequest
+	(*QueryCountAllParticipantsResponse)(nil),                     // 98: inference.inference.QueryCountAllParticipantsResponse
+	(*QueryDebugStatsRequest)(nil),                                // 99: inference.inference.QueryDebugStatsRequest
+	(*QueryDebugStatsResponse)(nil),                               // 100: inference.inference.QueryDebugStatsResponse
+	(*QueryGetMinimumValidationAverageRequest)(nil),               // 101: inference.inference.QueryGetMinimumValidationAverageRequest
+	(*QueryGetMinimumValidationAverageResponse)(nil),              // 102: inference.inference.QueryGetMinimumValidationAverageResponse
+	(*QueryGetPartialUpgradeRequest)(nil),                         // 103: inference.inference.QueryGetPartialUpgradeRequest
+	(*QueryGetPartialUpgradeResponse)(nil),                        // 104: inference.inference.QueryGetPartialUpgradeResponse
+	(*QueryAllPartialUpgradeRequest)(nil),                         // 105: inference.inference.QueryAllPartialUpgradeRequest
+	(*QueryAllPartialUpgradeResponse)(nil),                        // 106: inference.inference.QueryAllPartialUpgradeResponse
+	(*QueryGetBridgeTransactionRequest)(nil),                      // 107: inference.inference.QueryGetBridgeTransactionRequest
+	(*QueryGetBridgeTransactionResponse)(nil),                     // 108: inference.inference.QueryGetBridgeTransactionResponse
+	(*QueryAllBridgeTransactionsRequest)(nil),                     // 109: inference.inference.QueryAllBridgeTransactionsRequest
+	(*QueryAllBridgeTransactionsResponse)(nil),                    // 110: inference.inference.QueryAllBridgeTransactionsResponse
+	(*WrappedTokenBalance)(nil),                                   // 111: inference.inference.WrappedTokenBalance
+	(*QueryWrappedTokenBalancesRequest)(nil),                      // 112: inference.inference.QueryWrappedTokenBalancesRequest
+	(*QueryWrappedTokenBalancesResponse)(nil),                     // 113: inference.inference.QueryWrappedTokenBalancesResponse
+	(*QueryBridgeAddressesByChainRequest)(nil),                    // 114: inference.inference.QueryBridgeAddressesByChainRequest
+	(*QueryBridgeAddressesByChainResponse)(nil),                   // 115: inference.inference.QueryBridgeAddressesByChainResponse
+	(*QueryValidateWrappedTokenForTradeRequest)(nil),              // 116: inference.inference.QueryValidateWrappedTokenForTradeRequest
+	(*QueryValidateWrappedTokenForTradeResponse)(nil),             // 117: inference.inference.QueryValidateWrappedTokenForTradeResponse
+	(*QueryValidateIbcTokenForTradeRequest)(nil),                  // 118: inference.inference.QueryValidateIbcTokenForTradeRequest
+	(*QueryValidateIbcTokenForTradeResponse)(nil),                 // 119: inference.inference.QueryValidateIbcTokenForTradeResponse
+	(*QueryLiquidityPoolRequest)(nil),                             // 120: inference.inference.QueryLiquidityPoolRequest
+	(*QueryLiquidityPoolResponse)(nil),                            // 121: inference.inference.QueryLiquidityPoolResponse
+	(*QueryEpochInfoRequest)(nil),                                 // 122: inference.inference.QueryEpochInfoRequest
+	(*QueryEpochInfoResponse)(nil),                                // 123: inference.inference.QueryEpochInfoResponse
+	(*QueryCountPoCbatchesAtHeightRequest)(nil),                   // 124: inference.inference.QueryCountPoCbatchesAtHeightRequest
+	(*QueryCountPoCbatchesAtHeightResponse)(nil),                  // 125: inference.inference.QueryCountPoCbatchesAtHeightResponse
+	(*QueryCountPoCvalidationsAtHeightRequest)(nil),               // 126: inference.inference.QueryCountPoCvalidationsAtHeightRequest
+	(*QueryCountPoCvalidationsAtHeightResponse)(nil),              // 127: inference.inference.QueryCountPoCvalidationsAtHeightResponse
+	(*QueryApprovedTokensForTradeRequest)(nil),                    // 128: inference.inference.QueryApprovedTokensForTradeRequest
+	(*QueryApprovedTokensForTradeResponse)(nil),                   // 129: inference.inference.QueryApprovedTokensForTradeResponse
+	(*QueryGetModelPerTokenPriceRequest)(nil),                     // 130: inference.inference.QueryGetModelPerTokenPriceRequest
+	(*QueryGetModelPerTokenPriceResponse)(nil),                    // 131: inference.inference.QueryGetModelPerTokenPriceResponse
+	(*QueryGetAllModelPerTokenPricesRequest)(nil),                 // 132: inference.inference.QueryGetAllModelPerTokenPricesRequest
+	(*ModelPrice)(nil),                                            // 133: inference.inference.ModelPrice
+	(*QueryGetAllModelPerTokenPricesResponse)(nil),                // 134: inference.inference.QueryGetAllModelPerTokenPricesResponse
+	(*QueryGetModelCapacityRequest)(nil),                          // 135: inference.inference.QueryGetModelCapacityRequest
+	(*QueryGetModelCapacityResponse)(nil),                         // 136: inference.inference.QueryGetModelCapacityResponse
+	(*QueryGetAllModelCapacitiesRequest)(nil),                     // 137: inference.inference.QueryGetAllModelCapacitiesRequest
+	(*QueryGetAllModelCapacitiesResponse)(nil),                    // 138: inference.inference.QueryGetAllModelCapacitiesResponse
+	(*ModelCapacity)(nil),                                         // 139: inference.inference.ModelCapacity
+	(*QueryGranteesByMessageTypeRequest)(nil),                     // 140: inference.inference.QueryGranteesByMessageTypeRequest
+	(*Grantee)(nil), // 141: inference.inference.Grantee
+	(*QueryGranteesByMessageTypeResponse)(nil),         // 142: inference.inference.QueryGranteesByMessageTypeResponse
+	(*QueryParticipantAllowListRequest)(nil),           // 143: inference.inference.QueryParticipantAllowListRequest
+	(*QueryParticipantAllowListResponse)(nil),          // 144: inference.inference.QueryParticipantAllowListResponse
+	(*QueryGetMLNodeVersionRequest)(nil),               // 145: inference.inference.QueryGetMLNodeVersionRequest
+	(*QueryGetMLNodeVersionResponse)(nil),              // 146: inference.inference.QueryGetMLNodeVersionResponse
+	(*QueryGetLastUpgradeHeightRequest)(nil),           // 147: inference.inference.QueryGetLastUpgradeHeightRequest
+	(*QueryGetLastUpgradeHeightResponse)(nil),          // 148: inference.inference.QueryGetLastUpgradeHeightResponse
+	(*QueryExcludedParticipantsRequest)(nil),           // 149: inference.inference.QueryExcludedParticipantsRequest
+	(*QueryExcludedParticipantsResponse)(nil),          // 150: inference.inference.QueryExcludedParticipantsResponse
+	(*QueryActiveConfirmationPoCEventRequest)(nil),     // 151: inference.inference.QueryActiveConfirmationPoCEventRequest
+	(*QueryActiveConfirmationPoCEventResponse)(nil),    // 152: inference.inference.QueryActiveConfirmationPoCEventResponse
+	(*QueryConfirmationPoCEventsRequest)(nil),          // 153: inference.inference.QueryConfirmationPoCEventsRequest
+	(*QueryConfirmationPoCEventsResponse)(nil),         // 154: inference.inference.QueryConfirmationPoCEventsResponse
+	(*ParticipantWithBalance)(nil),                     // 155: inference.inference.ParticipantWithBalance
+	(*QueryParticipantsWithBalancesRequest)(nil),       // 156: inference.inference.QueryParticipantsWithBalancesRequest
+	(*QueryParticipantsWithBalancesResponse)(nil),      // 157: inference.inference.QueryParticipantsWithBalancesResponse
+	(*QueryRandomSeedsRequest)(nil),                    // 158: inference.inference.QueryRandomSeedsRequest
+	(*QueryRandomSeedsResponse)(nil),                   // 159: inference.inference.QueryRandomSeedsResponse
+	(*QueryPoCValidationSnapshotRequest)(nil),          // 160: inference.inference.QueryPoCValidationSnapshotRequest
+	(*QueryPoCValidationSnapshotResponse)(nil),         // 161: inference.inference.QueryPoCValidationSnapshotResponse
+	(*QueryPreservedNodesSnapshotRequest)(nil),         // 162: inference.inference.QueryPreservedNodesSnapshotRequest
+	(*QueryPreservedNodesSnapshotResponse)(nil),        // 163: inference.inference.QueryPreservedNodesSnapshotResponse
+	(*QueryGetDevshardEscrowRequest)(nil),              // 164: inference.inference.QueryGetDevshardEscrowRequest
+	(*QueryGetDevshardEscrowResponse)(nil),             // 165: inference.inference.QueryGetDevshardEscrowResponse
+	(*QueryGetDevshardHostEpochStatsRequest)(nil),      // 166: inference.inference.QueryGetDevshardHostEpochStatsRequest
+	(*QueryGetDevshardHostEpochStatsResponse)(nil),     // 167: inference.inference.QueryGetDevshardHostEpochStatsResponse
+	(*QueryMaintenanceCreditRequest)(nil),              // 168: inference.inference.QueryMaintenanceCreditRequest
+	(*QueryMaintenanceCreditResponse)(nil),             // 169: inference.inference.QueryMaintenanceCreditResponse
+	(*QueryMaintenanceScheduledRequest)(nil),           // 170: inference.inference.QueryMaintenanceScheduledRequest
+	(*QueryMaintenanceScheduledResponse)(nil),          // 171: inference.inference.QueryMaintenanceScheduledResponse
+	(*QueryMaintenanceActiveRequest)(nil),              // 172: inference.inference.QueryMaintenanceActiveRequest
+	(*QueryMaintenanceActiveResponse)(nil),             // 173: inference.inference.QueryMaintenanceActiveResponse
+	(*QueryMaintenanceStatusRequest)(nil),              // 174: inference.inference.QueryMaintenanceStatusRequest
+	(*QueryMaintenanceStatusResponse)(nil),             // 175: inference.inference.QueryMaintenanceStatusResponse
+	(*QueryMaintenanceConcurrencyRequest)(nil),         // 176: inference.inference.QueryMaintenanceConcurrencyRequest
+	(*QueryMaintenanceConcurrencyResponse)(nil),        // 177: inference.inference.QueryMaintenanceConcurrencyResponse
+	(*QueryMaintenanceSchedulabilityRequest)(nil),      // 178: inference.inference.QueryMaintenanceSchedulabilityRequest
+	(*QueryMaintenanceSchedulabilityResponse)(nil),     // 179: inference.inference.QueryMaintenanceSchedulabilityResponse
+	(*QueryListClaimRecipientsRequest)(nil),            // 180: inference.inference.QueryListClaimRecipientsRequest
+	(*QueryListClaimRecipientsResponse)(nil),           // 181: inference.inference.QueryListClaimRecipientsResponse
+	(*QueryDebugStatsResponse_TemporaryTimeStat)(nil),  // 182: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat
+	(*QueryDebugStatsResponse_TemporaryEpochStat)(nil), // 183: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat
+	(*Params)(nil),                     // 184: inference.inference.Params
+	(*Inference)(nil),                  // 185: inference.inference.Inference
+	(*v1beta1.PageRequest)(nil),        // 186: cosmos.base.query.v1beta1.PageRequest
+	(*v1beta1.PageResponse)(nil),       // 187: cosmos.base.query.v1beta1.PageResponse
+	(*Participant)(nil),                // 188: inference.inference.Participant
+	(*EpochGroupData)(nil),             // 189: inference.inference.EpochGroupData
+	(*SettleAmount)(nil),               // 190: inference.inference.SettleAmount
+	(*EpochGroupValidations)(nil),      // 191: inference.inference.EpochGroupValidations
+	(*PoCBatch)(nil),                   // 192: inference.inference.PoCBatch
+	(*PoCValidation)(nil),              // 193: inference.inference.PoCValidation
+	(*PoCValidationV2)(nil),            // 194: inference.inference.PoCValidationV2
+	(*MLNodeWeight)(nil),               // 195: inference.inference.MLNodeWeight
+	(*TokenomicsData)(nil),             // 196: inference.inference.TokenomicsData
+	(*UnitOfComputePriceProposal)(nil), // 197: inference.inference.UnitOfComputePriceProposal
+	(*Model)(nil),                      // 198: inference.inference.Model
+	(*InferenceTimeout)(nil),           // 199: inference.inference.InferenceTimeout
+	(*InferenceValidationDetails)(nil), // 200: inference.inference.InferenceValidationDetails
+	(*ValidationParams)(nil),           // 201: inference.inference.ValidationParams
+	(*EpochPerformanceSummary)(nil),    // 202: inference.inference.EpochPerformanceSummary
+	(*HardwareNodes)(nil),              // 203: inference.inference.HardwareNodes
+	(*DeveloperStatsByTime)(nil),       // 204: inference.inference.DeveloperStatsByTime
+	(*PartialUpgrade)(nil),             // 205: inference.inference.PartialUpgrade
+	(*BridgeTransaction)(nil),          // 206: inference.inference.BridgeTransaction
+	(*BridgeWrappedTokenContract)(nil), // 207: inference.inference.BridgeWrappedTokenContract
+	(*BridgeContractAddress)(nil),      // 208: inference.inference.BridgeContractAddress
+	(*Epoch)(nil),                      // 209: inference.inference.Epoch
+	(*ConfirmationPoCEvent)(nil),       // 210: inference.inference.ConfirmationPoCEvent
+	(*BridgeTokenReference)(nil),       // 211: inference.inference.BridgeTokenReference
+	(*MLNodeVersion)(nil),              // 212: inference.inference.MLNodeVersion
+	(*ExcludedParticipant)(nil),        // 213: inference.inference.ExcludedParticipant
+	(*v1beta11.Coin)(nil),              // 214: cosmos.base.v1beta1.Coin
+	(*RandomSeed)(nil),                 // 215: inference.inference.RandomSeed
+	(*PoCValidationSnapshot)(nil),      // 216: inference.inference.PoCValidationSnapshot
+	(*PreservedNodesSnapshot)(nil),     // 217: inference.inference.PreservedNodesSnapshot
+	(*DevshardEscrow)(nil),             // 218: inference.inference.DevshardEscrow
+	(*DevshardHostEpochStats)(nil),     // 219: inference.inference.DevshardHostEpochStats
+	(*MaintenanceReservation)(nil),     // 220: inference.inference.MaintenanceReservation
+	(*MaintenanceState)(nil),           // 221: inference.inference.MaintenanceState
+	(*ClaimRecipientEntry)(nil),        // 222: inference.inference.ClaimRecipientEntry
+	(*DeveloperStatsByEpoch)(nil),      // 223: inference.inference.DeveloperStatsByEpoch
+	(*QueryPoCDelegationRequest)(nil),  // 224: inference.inference.QueryPoCDelegationRequest
+	(*QueryPoCDelegationResponse)(nil), // 225: inference.inference.QueryPoCDelegationResponse
 }
 var file_inference_inference_query_proto_depIdxs = []int32{
-	166, // 0: inference.inference.QueryParamsResponse.params:type_name -> inference.inference.Params
-	167, // 1: inference.inference.QueryGetInferenceResponse.inference:type_name -> inference.inference.Inference
-	168, // 2: inference.inference.QueryAllInferenceRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	167, // 3: inference.inference.QueryAllInferenceResponse.inference:type_name -> inference.inference.Inference
-	169, // 4: inference.inference.QueryAllInferenceResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	170, // 5: inference.inference.QueryGetParticipantResponse.participant:type_name -> inference.inference.Participant
-	168, // 6: inference.inference.QueryAllParticipantRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	170, // 7: inference.inference.QueryAllParticipantResponse.participant:type_name -> inference.inference.Participant
-	169, // 8: inference.inference.QueryAllParticipantResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	170, // 9: inference.inference.QueryGetRandomExecutorResponse.executor:type_name -> inference.inference.Participant
-	171, // 10: inference.inference.QueryGetEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
-	168, // 11: inference.inference.QueryAllEpochGroupDataRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	171, // 12: inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
-	169, // 13: inference.inference.QueryAllEpochGroupDataResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	172, // 14: inference.inference.QueryGetSettleAmountResponse.settle_amount:type_name -> inference.inference.SettleAmount
-	168, // 15: inference.inference.QueryAllSettleAmountRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	172, // 16: inference.inference.QueryAllSettleAmountResponse.settle_amount:type_name -> inference.inference.SettleAmount
-	169, // 17: inference.inference.QueryAllSettleAmountResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	173, // 18: inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations:type_name -> inference.inference.EpochGroupValidations
-	168, // 19: inference.inference.QueryAllEpochGroupValidationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	173, // 20: inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations:type_name -> inference.inference.EpochGroupValidations
-	169, // 21: inference.inference.QueryAllEpochGroupValidationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	28,  // 22: inference.inference.QueryPocBatchesForStageResponse.poc_batch:type_name -> inference.inference.PoCBatchesWithParticipants
-	174, // 23: inference.inference.PoCBatchesWithParticipants.poc_batch:type_name -> inference.inference.PoCBatch
-	31,  // 24: inference.inference.QueryPocValidationsForStageResponse.poc_validation:type_name -> inference.inference.PoCValidationsWithParticipants
-	175, // 25: inference.inference.PoCValidationsWithParticipants.poc_validation:type_name -> inference.inference.PoCValidation
-	34,  // 26: inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation:type_name -> inference.inference.PoCValidationsWithParticipantsV2
-	176, // 27: inference.inference.PoCValidationsWithParticipantsV2.poc_validation:type_name -> inference.inference.PoCValidationV2
-	177, // 28: inference.inference.QueryMLNodeWeightDistributionResponse.weights:type_name -> inference.inference.MLNodeWeight
-	41,  // 29: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits:type_name -> inference.inference.PoCV2StoreCommitWithAddress
-	44,  // 30: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions:type_name -> inference.inference.MLNodeWeightDistributionWithAddress
-	177, // 31: inference.inference.MLNodeWeightDistributionWithAddress.weights:type_name -> inference.inference.MLNodeWeight
-	178, // 32: inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data:type_name -> inference.inference.TokenomicsData
-	179, // 33: inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal:type_name -> inference.inference.UnitOfComputePriceProposal
-	171, // 34: inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
-	171, // 35: inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
-	168, // 36: inference.inference.QueryModelsAllRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	180, // 37: inference.inference.QueryModelsAllResponse.model:type_name -> inference.inference.Model
-	169, // 38: inference.inference.QueryModelsAllResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	181, // 39: inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout:type_name -> inference.inference.InferenceTimeout
-	168, // 40: inference.inference.QueryAllInferenceTimeoutRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	181, // 41: inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout:type_name -> inference.inference.InferenceTimeout
-	169, // 42: inference.inference.QueryAllInferenceTimeoutResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	182, // 43: inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails:type_name -> inference.inference.InferenceValidationDetails
-	168, // 44: inference.inference.QueryAllInferenceValidationDetailsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	182, // 45: inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails:type_name -> inference.inference.InferenceValidationDetails
-	169, // 46: inference.inference.QueryAllInferenceValidationDetailsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	67,  // 47: inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers:type_name -> inference.inference.ValidatorPower
-	182, // 48: inference.inference.QueryGetInferenceValidationParametersResponse.details:type_name -> inference.inference.InferenceValidationDetails
-	183, // 49: inference.inference.QueryGetInferenceValidationParametersResponse.parameters:type_name -> inference.inference.ValidationParams
-	184, // 50: inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary:type_name -> inference.inference.EpochPerformanceSummary
-	184, // 51: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary:type_name -> inference.inference.EpochPerformanceSummary
-	168, // 52: inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	184, // 53: inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary:type_name -> inference.inference.EpochPerformanceSummary
-	169, // 54: inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	185, // 55: inference.inference.QueryHardwareNodesResponse.nodes:type_name -> inference.inference.HardwareNodes
-	185, // 56: inference.inference.QueryHardwareNodesAllResponse.nodes:type_name -> inference.inference.HardwareNodes
-	82,  // 57: inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats:type_name -> inference.inference.ParticipantCurrentStats
-	83,  // 58: inference.inference.QueryParticipantsFullStatsResponse.participants_stats:type_name -> inference.inference.ParticipantFullStats
-	186, // 59: inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats:type_name -> inference.inference.DeveloperStatsByTime
-	92,  // 60: inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models:type_name -> inference.inference.ModelStats
-	164, // 61: inference.inference.QueryDebugStatsResponse.stats_by_time:type_name -> inference.inference.QueryDebugStatsResponse.TemporaryTimeStat
-	165, // 62: inference.inference.QueryDebugStatsResponse.stats_by_epoch:type_name -> inference.inference.QueryDebugStatsResponse.TemporaryEpochStat
-	187, // 63: inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade:type_name -> inference.inference.PartialUpgrade
-	168, // 64: inference.inference.QueryAllPartialUpgradeRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	187, // 65: inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade:type_name -> inference.inference.PartialUpgrade
-	169, // 66: inference.inference.QueryAllPartialUpgradeResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	188, // 67: inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions:type_name -> inference.inference.BridgeTransaction
-	168, // 68: inference.inference.QueryAllBridgeTransactionsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	188, // 69: inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions:type_name -> inference.inference.BridgeTransaction
-	169, // 70: inference.inference.QueryAllBridgeTransactionsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	189, // 71: inference.inference.WrappedTokenBalance.token_info:type_name -> inference.inference.BridgeWrappedTokenContract
-	109, // 72: inference.inference.QueryWrappedTokenBalancesResponse.balances:type_name -> inference.inference.WrappedTokenBalance
-	190, // 73: inference.inference.QueryBridgeAddressesByChainResponse.addresses:type_name -> inference.inference.BridgeContractAddress
-	166, // 74: inference.inference.QueryEpochInfoResponse.params:type_name -> inference.inference.Params
-	191, // 75: inference.inference.QueryEpochInfoResponse.latest_epoch:type_name -> inference.inference.Epoch
-	192, // 76: inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event:type_name -> inference.inference.ConfirmationPoCEvent
-	193, // 77: inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens:type_name -> inference.inference.BridgeTokenReference
-	131, // 78: inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices:type_name -> inference.inference.ModelPrice
-	137, // 79: inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities:type_name -> inference.inference.ModelCapacity
-	139, // 80: inference.inference.QueryGranteesByMessageTypeResponse.grantees:type_name -> inference.inference.Grantee
-	194, // 81: inference.inference.QueryGetMLNodeVersionResponse.mlnode_version:type_name -> inference.inference.MLNodeVersion
-	195, // 82: inference.inference.QueryExcludedParticipantsResponse.items:type_name -> inference.inference.ExcludedParticipant
-	192, // 83: inference.inference.QueryActiveConfirmationPoCEventResponse.event:type_name -> inference.inference.ConfirmationPoCEvent
-	192, // 84: inference.inference.QueryConfirmationPoCEventsResponse.events:type_name -> inference.inference.ConfirmationPoCEvent
-	170, // 85: inference.inference.ParticipantWithBalance.participant:type_name -> inference.inference.Participant
-	196, // 86: inference.inference.ParticipantWithBalance.balances:type_name -> cosmos.base.v1beta1.Coin
-	168, // 87: inference.inference.QueryParticipantsWithBalancesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
-	151, // 88: inference.inference.QueryParticipantsWithBalancesResponse.participants:type_name -> inference.inference.ParticipantWithBalance
-	169, // 89: inference.inference.QueryParticipantsWithBalancesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
-	197, // 90: inference.inference.QueryRandomSeedsResponse.seeds:type_name -> inference.inference.RandomSeed
-	198, // 91: inference.inference.QueryPoCValidationSnapshotResponse.snapshot:type_name -> inference.inference.PoCValidationSnapshot
-	199, // 92: inference.inference.QueryPreservedNodesSnapshotResponse.snapshot:type_name -> inference.inference.PreservedNodesSnapshot
-	200, // 93: inference.inference.QueryGetDevshardEscrowResponse.escrow:type_name -> inference.inference.DevshardEscrow
-	201, // 94: inference.inference.QueryGetDevshardHostEpochStatsResponse.stats:type_name -> inference.inference.DevshardHostEpochStats
-	186, // 95: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats:type_name -> inference.inference.DeveloperStatsByTime
-	202, // 96: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats:type_name -> inference.inference.DeveloperStatsByEpoch
-	0,   // 97: inference.inference.Query.Params:input_type -> inference.inference.QueryParamsRequest
-	2,   // 98: inference.inference.Query.Inference:input_type -> inference.inference.QueryGetInferenceRequest
-	4,   // 99: inference.inference.Query.InferenceAll:input_type -> inference.inference.QueryAllInferenceRequest
-	6,   // 100: inference.inference.Query.Participant:input_type -> inference.inference.QueryGetParticipantRequest
-	8,   // 101: inference.inference.Query.ParticipantAll:input_type -> inference.inference.QueryAllParticipantRequest
-	10,  // 102: inference.inference.Query.AccountByAddress:input_type -> inference.inference.QueryAccountByAddressRequest
-	12,  // 103: inference.inference.Query.GetRandomExecutor:input_type -> inference.inference.QueryGetRandomExecutorRequest
-	14,  // 104: inference.inference.Query.EpochGroupData:input_type -> inference.inference.QueryGetEpochGroupDataRequest
-	16,  // 105: inference.inference.Query.EpochGroupDataAll:input_type -> inference.inference.QueryAllEpochGroupDataRequest
-	18,  // 106: inference.inference.Query.SettleAmount:input_type -> inference.inference.QueryGetSettleAmountRequest
-	20,  // 107: inference.inference.Query.SettleAmountAll:input_type -> inference.inference.QueryAllSettleAmountRequest
-	22,  // 108: inference.inference.Query.EpochGroupValidations:input_type -> inference.inference.QueryGetEpochGroupValidationsRequest
-	24,  // 109: inference.inference.Query.EpochGroupValidationsAll:input_type -> inference.inference.QueryAllEpochGroupValidationsRequest
-	26,  // 110: inference.inference.Query.PocBatchesForStage:input_type -> inference.inference.QueryPocBatchesForStageRequest
-	29,  // 111: inference.inference.Query.PocValidationsForStage:input_type -> inference.inference.QueryPocValidationsForStageRequest
-	32,  // 112: inference.inference.Query.PocV2ValidationsForStage:input_type -> inference.inference.QueryPocV2ValidationsForStageRequest
-	35,  // 113: inference.inference.Query.PoCV2StoreCommit:input_type -> inference.inference.QueryPoCV2StoreCommitRequest
-	37,  // 114: inference.inference.Query.MLNodeWeightDistribution:input_type -> inference.inference.QueryMLNodeWeightDistributionRequest
-	39,  // 115: inference.inference.Query.AllPoCV2StoreCommitsForStage:input_type -> inference.inference.QueryAllPoCV2StoreCommitsForStageRequest
-	42,  // 116: inference.inference.Query.AllMLNodeWeightDistributionsForStage:input_type -> inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest
-	45,  // 117: inference.inference.Query.GetCurrentEpoch:input_type -> inference.inference.QueryGetCurrentEpochRequest
-	47,  // 118: inference.inference.Query.TokenomicsData:input_type -> inference.inference.QueryGetTokenomicsDataRequest
-	49,  // 119: inference.inference.Query.GetUnitOfComputePriceProposal:input_type -> inference.inference.QueryGetUnitOfComputePriceProposalRequest
-	51,  // 120: inference.inference.Query.CurrentEpochGroupData:input_type -> inference.inference.QueryCurrentEpochGroupDataRequest
-	55,  // 121: inference.inference.Query.ModelsAll:input_type -> inference.inference.QueryModelsAllRequest
-	57,  // 122: inference.inference.Query.InferenceTimeout:input_type -> inference.inference.QueryGetInferenceTimeoutRequest
-	59,  // 123: inference.inference.Query.InferenceTimeoutAll:input_type -> inference.inference.QueryAllInferenceTimeoutRequest
-	61,  // 124: inference.inference.Query.InferenceValidationDetails:input_type -> inference.inference.QueryGetInferenceValidationDetailsRequest
-	63,  // 125: inference.inference.Query.InferenceValidationDetailsAll:input_type -> inference.inference.QueryAllInferenceValidationDetailsRequest
-	65,  // 126: inference.inference.Query.GetInferenceValidationParameters:input_type -> inference.inference.QueryGetInferenceValidationParametersRequest
-	68,  // 127: inference.inference.Query.EpochPerformanceSummary:input_type -> inference.inference.QueryEpochPerformanceSummaryByEpochRequest
-	70,  // 128: inference.inference.Query.EpochPerformanceSummaryByParticipant:input_type -> inference.inference.QueryEpochPerformanceSummaryByParticipantRequest
-	72,  // 129: inference.inference.Query.EpochPerformanceSummaryAll:input_type -> inference.inference.QueryAllEpochPerformanceSummaryRequest
-	74,  // 130: inference.inference.Query.HardwareNodes:input_type -> inference.inference.QueryHardwareNodesRequest
-	76,  // 131: inference.inference.Query.HardwareNodesAll:input_type -> inference.inference.QueryHardwareNodesAllRequest
-	78,  // 132: inference.inference.Query.GetParticipantCurrentStats:input_type -> inference.inference.QueryGetParticipantCurrentStatsRequest
-	80,  // 133: inference.inference.Query.GetAllParticipantCurrentStats:input_type -> inference.inference.QueryGetAllParticipantCurrentStatsRequest
-	84,  // 134: inference.inference.Query.GetParticipantsFullStats:input_type -> inference.inference.QueryParticipantsFullStatsRequest
-	86,  // 135: inference.inference.Query.StatsByTimePeriodByDeveloper:input_type -> inference.inference.QueryStatsByTimePeriodByDeveloperRequest
-	88,  // 136: inference.inference.Query.StatsByDeveloperAndEpochsBackwards:input_type -> inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest
-	95,  // 137: inference.inference.Query.CountParticipants:input_type -> inference.inference.QueryCountAllParticipantsRequest
-	97,  // 138: inference.inference.Query.DebugStatsDeveloperStats:input_type -> inference.inference.QueryDebugStatsRequest
-	89,  // 139: inference.inference.Query.InferencesAndTokensStatsByEpochsBackwards:input_type -> inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest
-	90,  // 140: inference.inference.Query.InferencesAndTokensStatsByTimePeriod:input_type -> inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest
-	91,  // 141: inference.inference.Query.InferencesAndTokensStatsByModels:input_type -> inference.inference.QueryInferencesAndTokensStatsByModelsRequest
-	99,  // 142: inference.inference.Query.GetMinimumValidationAverage:input_type -> inference.inference.QueryGetMinimumValidationAverageRequest
-	101, // 143: inference.inference.Query.PartialUpgrade:input_type -> inference.inference.QueryGetPartialUpgradeRequest
-	103, // 144: inference.inference.Query.PartialUpgradeAll:input_type -> inference.inference.QueryAllPartialUpgradeRequest
-	105, // 145: inference.inference.Query.BridgeTransaction:input_type -> inference.inference.QueryGetBridgeTransactionRequest
-	107, // 146: inference.inference.Query.BridgeTransactions:input_type -> inference.inference.QueryAllBridgeTransactionsRequest
-	112, // 147: inference.inference.Query.BridgeAddressesByChain:input_type -> inference.inference.QueryBridgeAddressesByChainRequest
-	118, // 148: inference.inference.Query.LiquidityPool:input_type -> inference.inference.QueryLiquidityPoolRequest
-	110, // 149: inference.inference.Query.WrappedTokenBalances:input_type -> inference.inference.QueryWrappedTokenBalancesRequest
-	114, // 150: inference.inference.Query.ValidateWrappedTokenForTrade:input_type -> inference.inference.QueryValidateWrappedTokenForTradeRequest
-	116, // 151: inference.inference.Query.ValidateIbcTokenForTrade:input_type -> inference.inference.QueryValidateIbcTokenForTradeRequest
-	126, // 152: inference.inference.Query.ApprovedTokensForTrade:input_type -> inference.inference.QueryApprovedTokensForTradeRequest
-	120, // 153: inference.inference.Query.EpochInfo:input_type -> inference.inference.QueryEpochInfoRequest
-	122, // 154: inference.inference.Query.CountPoCbatchesAtHeight:input_type -> inference.inference.QueryCountPoCbatchesAtHeightRequest
-	124, // 155: inference.inference.Query.CountPoCvalidationsAtHeight:input_type -> inference.inference.QueryCountPoCvalidationsAtHeightRequest
-	128, // 156: inference.inference.Query.GetModelPerTokenPrice:input_type -> inference.inference.QueryGetModelPerTokenPriceRequest
-	130, // 157: inference.inference.Query.GetAllModelPerTokenPrices:input_type -> inference.inference.QueryGetAllModelPerTokenPricesRequest
-	133, // 158: inference.inference.Query.GetModelCapacity:input_type -> inference.inference.QueryGetModelCapacityRequest
-	135, // 159: inference.inference.Query.GetAllModelCapacities:input_type -> inference.inference.QueryGetAllModelCapacitiesRequest
-	138, // 160: inference.inference.Query.GranteesByMessageType:input_type -> inference.inference.QueryGranteesByMessageTypeRequest
-	143, // 161: inference.inference.Query.MLNodeVersion:input_type -> inference.inference.QueryGetMLNodeVersionRequest
-	141, // 162: inference.inference.Query.ParticipantAllowList:input_type -> inference.inference.QueryParticipantAllowListRequest
-	145, // 163: inference.inference.Query.ExcludedParticipants:input_type -> inference.inference.QueryExcludedParticipantsRequest
-	147, // 164: inference.inference.Query.ActiveConfirmationPoCEvent:input_type -> inference.inference.QueryActiveConfirmationPoCEventRequest
-	149, // 165: inference.inference.Query.ListConfirmationPoCEvents:input_type -> inference.inference.QueryConfirmationPoCEventsRequest
-	154, // 166: inference.inference.Query.ListRandomSeeds:input_type -> inference.inference.QueryRandomSeedsRequest
-	152, // 167: inference.inference.Query.ParticipantsWithBalances:input_type -> inference.inference.QueryParticipantsWithBalancesRequest
-	156, // 168: inference.inference.Query.PoCValidationSnapshot:input_type -> inference.inference.QueryPoCValidationSnapshotRequest
-	160, // 169: inference.inference.Query.DevshardEscrow:input_type -> inference.inference.QueryGetDevshardEscrowRequest
-	158, // 170: inference.inference.Query.PreservedNodesSnapshot:input_type -> inference.inference.QueryPreservedNodesSnapshotRequest
-	162, // 171: inference.inference.Query.DevshardHostEpochStats:input_type -> inference.inference.QueryGetDevshardHostEpochStatsRequest
-	203, // 172: inference.inference.Query.PoCDelegation:input_type -> inference.inference.QueryPoCDelegationRequest
-	1,   // 173: inference.inference.Query.Params:output_type -> inference.inference.QueryParamsResponse
-	3,   // 174: inference.inference.Query.Inference:output_type -> inference.inference.QueryGetInferenceResponse
-	5,   // 175: inference.inference.Query.InferenceAll:output_type -> inference.inference.QueryAllInferenceResponse
-	7,   // 176: inference.inference.Query.Participant:output_type -> inference.inference.QueryGetParticipantResponse
-	9,   // 177: inference.inference.Query.ParticipantAll:output_type -> inference.inference.QueryAllParticipantResponse
-	11,  // 178: inference.inference.Query.AccountByAddress:output_type -> inference.inference.QueryAccountByAddressResponse
-	13,  // 179: inference.inference.Query.GetRandomExecutor:output_type -> inference.inference.QueryGetRandomExecutorResponse
-	15,  // 180: inference.inference.Query.EpochGroupData:output_type -> inference.inference.QueryGetEpochGroupDataResponse
-	17,  // 181: inference.inference.Query.EpochGroupDataAll:output_type -> inference.inference.QueryAllEpochGroupDataResponse
-	19,  // 182: inference.inference.Query.SettleAmount:output_type -> inference.inference.QueryGetSettleAmountResponse
-	21,  // 183: inference.inference.Query.SettleAmountAll:output_type -> inference.inference.QueryAllSettleAmountResponse
-	23,  // 184: inference.inference.Query.EpochGroupValidations:output_type -> inference.inference.QueryGetEpochGroupValidationsResponse
-	25,  // 185: inference.inference.Query.EpochGroupValidationsAll:output_type -> inference.inference.QueryAllEpochGroupValidationsResponse
-	27,  // 186: inference.inference.Query.PocBatchesForStage:output_type -> inference.inference.QueryPocBatchesForStageResponse
-	30,  // 187: inference.inference.Query.PocValidationsForStage:output_type -> inference.inference.QueryPocValidationsForStageResponse
-	33,  // 188: inference.inference.Query.PocV2ValidationsForStage:output_type -> inference.inference.QueryPocV2ValidationsForStageResponse
-	36,  // 189: inference.inference.Query.PoCV2StoreCommit:output_type -> inference.inference.QueryPoCV2StoreCommitResponse
-	38,  // 190: inference.inference.Query.MLNodeWeightDistribution:output_type -> inference.inference.QueryMLNodeWeightDistributionResponse
-	40,  // 191: inference.inference.Query.AllPoCV2StoreCommitsForStage:output_type -> inference.inference.QueryAllPoCV2StoreCommitsForStageResponse
-	43,  // 192: inference.inference.Query.AllMLNodeWeightDistributionsForStage:output_type -> inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse
-	46,  // 193: inference.inference.Query.GetCurrentEpoch:output_type -> inference.inference.QueryGetCurrentEpochResponse
-	48,  // 194: inference.inference.Query.TokenomicsData:output_type -> inference.inference.QueryGetTokenomicsDataResponse
-	50,  // 195: inference.inference.Query.GetUnitOfComputePriceProposal:output_type -> inference.inference.QueryGetUnitOfComputePriceProposalResponse
-	52,  // 196: inference.inference.Query.CurrentEpochGroupData:output_type -> inference.inference.QueryCurrentEpochGroupDataResponse
-	56,  // 197: inference.inference.Query.ModelsAll:output_type -> inference.inference.QueryModelsAllResponse
-	58,  // 198: inference.inference.Query.InferenceTimeout:output_type -> inference.inference.QueryGetInferenceTimeoutResponse
-	60,  // 199: inference.inference.Query.InferenceTimeoutAll:output_type -> inference.inference.QueryAllInferenceTimeoutResponse
-	62,  // 200: inference.inference.Query.InferenceValidationDetails:output_type -> inference.inference.QueryGetInferenceValidationDetailsResponse
-	64,  // 201: inference.inference.Query.InferenceValidationDetailsAll:output_type -> inference.inference.QueryAllInferenceValidationDetailsResponse
-	66,  // 202: inference.inference.Query.GetInferenceValidationParameters:output_type -> inference.inference.QueryGetInferenceValidationParametersResponse
-	69,  // 203: inference.inference.Query.EpochPerformanceSummary:output_type -> inference.inference.QueryEpochPerformanceSummaryByEpochResponse
-	71,  // 204: inference.inference.Query.EpochPerformanceSummaryByParticipant:output_type -> inference.inference.QueryEpochPerformanceSummaryByParticipantResponse
-	73,  // 205: inference.inference.Query.EpochPerformanceSummaryAll:output_type -> inference.inference.QueryAllEpochPerformanceSummaryResponse
-	75,  // 206: inference.inference.Query.HardwareNodes:output_type -> inference.inference.QueryHardwareNodesResponse
-	77,  // 207: inference.inference.Query.HardwareNodesAll:output_type -> inference.inference.QueryHardwareNodesAllResponse
-	79,  // 208: inference.inference.Query.GetParticipantCurrentStats:output_type -> inference.inference.QueryGetParticipantCurrentStatsResponse
-	81,  // 209: inference.inference.Query.GetAllParticipantCurrentStats:output_type -> inference.inference.QueryGetAllParticipantCurrentStatsResponse
-	85,  // 210: inference.inference.Query.GetParticipantsFullStats:output_type -> inference.inference.QueryParticipantsFullStatsResponse
-	87,  // 211: inference.inference.Query.StatsByTimePeriodByDeveloper:output_type -> inference.inference.QueryStatsByTimePeriodByDeveloperResponse
-	94,  // 212: inference.inference.Query.StatsByDeveloperAndEpochsBackwards:output_type -> inference.inference.QueryInferencesAndTokensStatsResponse
-	96,  // 213: inference.inference.Query.CountParticipants:output_type -> inference.inference.QueryCountAllParticipantsResponse
-	98,  // 214: inference.inference.Query.DebugStatsDeveloperStats:output_type -> inference.inference.QueryDebugStatsResponse
-	94,  // 215: inference.inference.Query.InferencesAndTokensStatsByEpochsBackwards:output_type -> inference.inference.QueryInferencesAndTokensStatsResponse
-	94,  // 216: inference.inference.Query.InferencesAndTokensStatsByTimePeriod:output_type -> inference.inference.QueryInferencesAndTokensStatsResponse
-	93,  // 217: inference.inference.Query.InferencesAndTokensStatsByModels:output_type -> inference.inference.QueryInferencesAndTokensStatsByModelsResponse
-	100, // 218: inference.inference.Query.GetMinimumValidationAverage:output_type -> inference.inference.QueryGetMinimumValidationAverageResponse
-	102, // 219: inference.inference.Query.PartialUpgrade:output_type -> inference.inference.QueryGetPartialUpgradeResponse
-	104, // 220: inference.inference.Query.PartialUpgradeAll:output_type -> inference.inference.QueryAllPartialUpgradeResponse
-	106, // 221: inference.inference.Query.BridgeTransaction:output_type -> inference.inference.QueryGetBridgeTransactionResponse
-	108, // 222: inference.inference.Query.BridgeTransactions:output_type -> inference.inference.QueryAllBridgeTransactionsResponse
-	113, // 223: inference.inference.Query.BridgeAddressesByChain:output_type -> inference.inference.QueryBridgeAddressesByChainResponse
-	119, // 224: inference.inference.Query.LiquidityPool:output_type -> inference.inference.QueryLiquidityPoolResponse
-	111, // 225: inference.inference.Query.WrappedTokenBalances:output_type -> inference.inference.QueryWrappedTokenBalancesResponse
-	115, // 226: inference.inference.Query.ValidateWrappedTokenForTrade:output_type -> inference.inference.QueryValidateWrappedTokenForTradeResponse
-	117, // 227: inference.inference.Query.ValidateIbcTokenForTrade:output_type -> inference.inference.QueryValidateIbcTokenForTradeResponse
-	127, // 228: inference.inference.Query.ApprovedTokensForTrade:output_type -> inference.inference.QueryApprovedTokensForTradeResponse
-	121, // 229: inference.inference.Query.EpochInfo:output_type -> inference.inference.QueryEpochInfoResponse
-	123, // 230: inference.inference.Query.CountPoCbatchesAtHeight:output_type -> inference.inference.QueryCountPoCbatchesAtHeightResponse
-	125, // 231: inference.inference.Query.CountPoCvalidationsAtHeight:output_type -> inference.inference.QueryCountPoCvalidationsAtHeightResponse
-	129, // 232: inference.inference.Query.GetModelPerTokenPrice:output_type -> inference.inference.QueryGetModelPerTokenPriceResponse
-	132, // 233: inference.inference.Query.GetAllModelPerTokenPrices:output_type -> inference.inference.QueryGetAllModelPerTokenPricesResponse
-	134, // 234: inference.inference.Query.GetModelCapacity:output_type -> inference.inference.QueryGetModelCapacityResponse
-	136, // 235: inference.inference.Query.GetAllModelCapacities:output_type -> inference.inference.QueryGetAllModelCapacitiesResponse
-	140, // 236: inference.inference.Query.GranteesByMessageType:output_type -> inference.inference.QueryGranteesByMessageTypeResponse
-	144, // 237: inference.inference.Query.MLNodeVersion:output_type -> inference.inference.QueryGetMLNodeVersionResponse
-	142, // 238: inference.inference.Query.ParticipantAllowList:output_type -> inference.inference.QueryParticipantAllowListResponse
-	146, // 239: inference.inference.Query.ExcludedParticipants:output_type -> inference.inference.QueryExcludedParticipantsResponse
-	148, // 240: inference.inference.Query.ActiveConfirmationPoCEvent:output_type -> inference.inference.QueryActiveConfirmationPoCEventResponse
-	150, // 241: inference.inference.Query.ListConfirmationPoCEvents:output_type -> inference.inference.QueryConfirmationPoCEventsResponse
-	155, // 242: inference.inference.Query.ListRandomSeeds:output_type -> inference.inference.QueryRandomSeedsResponse
-	153, // 243: inference.inference.Query.ParticipantsWithBalances:output_type -> inference.inference.QueryParticipantsWithBalancesResponse
-	157, // 244: inference.inference.Query.PoCValidationSnapshot:output_type -> inference.inference.QueryPoCValidationSnapshotResponse
-	161, // 245: inference.inference.Query.DevshardEscrow:output_type -> inference.inference.QueryGetDevshardEscrowResponse
-	159, // 246: inference.inference.Query.PreservedNodesSnapshot:output_type -> inference.inference.QueryPreservedNodesSnapshotResponse
-	163, // 247: inference.inference.Query.DevshardHostEpochStats:output_type -> inference.inference.QueryGetDevshardHostEpochStatsResponse
-	204, // 248: inference.inference.Query.PoCDelegation:output_type -> inference.inference.QueryPoCDelegationResponse
-	173, // [173:249] is the sub-list for method output_type
-	97,  // [97:173] is the sub-list for method input_type
-	97,  // [97:97] is the sub-list for extension type_name
-	97,  // [97:97] is the sub-list for extension extendee
-	0,   // [0:97] is the sub-list for field type_name
+	184, // 0: inference.inference.QueryParamsResponse.params:type_name -> inference.inference.Params
+	185, // 1: inference.inference.QueryGetInferenceResponse.inference:type_name -> inference.inference.Inference
+	186, // 2: inference.inference.QueryAllInferenceRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	185, // 3: inference.inference.QueryAllInferenceResponse.inference:type_name -> inference.inference.Inference
+	187, // 4: inference.inference.QueryAllInferenceResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	188, // 5: inference.inference.QueryGetParticipantResponse.participant:type_name -> inference.inference.Participant
+	186, // 6: inference.inference.QueryAllParticipantRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	188, // 7: inference.inference.QueryAllParticipantResponse.participant:type_name -> inference.inference.Participant
+	187, // 8: inference.inference.QueryAllParticipantResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	188, // 9: inference.inference.QueryGetRandomExecutorResponse.executor:type_name -> inference.inference.Participant
+	189, // 10: inference.inference.QueryGetEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
+	186, // 11: inference.inference.QueryAllEpochGroupDataRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	189, // 12: inference.inference.QueryAllEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
+	187, // 13: inference.inference.QueryAllEpochGroupDataResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	190, // 14: inference.inference.QueryGetSettleAmountResponse.settle_amount:type_name -> inference.inference.SettleAmount
+	186, // 15: inference.inference.QueryAllSettleAmountRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	190, // 16: inference.inference.QueryAllSettleAmountResponse.settle_amount:type_name -> inference.inference.SettleAmount
+	187, // 17: inference.inference.QueryAllSettleAmountResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	190, // 18: inference.inference.QueryEstimateBitcoinRewardResponse.settle_amount:type_name -> inference.inference.SettleAmount
+	191, // 19: inference.inference.QueryGetEpochGroupValidationsResponse.epoch_group_validations:type_name -> inference.inference.EpochGroupValidations
+	186, // 20: inference.inference.QueryAllEpochGroupValidationsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	191, // 21: inference.inference.QueryAllEpochGroupValidationsResponse.epoch_group_validations:type_name -> inference.inference.EpochGroupValidations
+	187, // 22: inference.inference.QueryAllEpochGroupValidationsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	30,  // 23: inference.inference.QueryPocBatchesForStageResponse.poc_batch:type_name -> inference.inference.PoCBatchesWithParticipants
+	192, // 24: inference.inference.PoCBatchesWithParticipants.poc_batch:type_name -> inference.inference.PoCBatch
+	33,  // 25: inference.inference.QueryPocValidationsForStageResponse.poc_validation:type_name -> inference.inference.PoCValidationsWithParticipants
+	193, // 26: inference.inference.PoCValidationsWithParticipants.poc_validation:type_name -> inference.inference.PoCValidation
+	36,  // 27: inference.inference.QueryPocV2ValidationsForStageResponse.poc_validation:type_name -> inference.inference.PoCValidationsWithParticipantsV2
+	194, // 28: inference.inference.PoCValidationsWithParticipantsV2.poc_validation:type_name -> inference.inference.PoCValidationV2
+	195, // 29: inference.inference.QueryMLNodeWeightDistributionResponse.weights:type_name -> inference.inference.MLNodeWeight
+	43,  // 30: inference.inference.QueryAllPoCV2StoreCommitsForStageResponse.commits:type_name -> inference.inference.PoCV2StoreCommitWithAddress
+	46,  // 31: inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse.distributions:type_name -> inference.inference.MLNodeWeightDistributionWithAddress
+	195, // 32: inference.inference.MLNodeWeightDistributionWithAddress.weights:type_name -> inference.inference.MLNodeWeight
+	196, // 33: inference.inference.QueryGetTokenomicsDataResponse.tokenomics_data:type_name -> inference.inference.TokenomicsData
+	197, // 34: inference.inference.QueryGetUnitOfComputePriceProposalResponse.proposal:type_name -> inference.inference.UnitOfComputePriceProposal
+	189, // 35: inference.inference.QueryCurrentEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
+	189, // 36: inference.inference.QueryPreviousEpochGroupDataResponse.epoch_group_data:type_name -> inference.inference.EpochGroupData
+	186, // 37: inference.inference.QueryModelsAllRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	198, // 38: inference.inference.QueryModelsAllResponse.model:type_name -> inference.inference.Model
+	187, // 39: inference.inference.QueryModelsAllResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	199, // 40: inference.inference.QueryGetInferenceTimeoutResponse.inference_timeout:type_name -> inference.inference.InferenceTimeout
+	186, // 41: inference.inference.QueryAllInferenceTimeoutRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	199, // 42: inference.inference.QueryAllInferenceTimeoutResponse.inference_timeout:type_name -> inference.inference.InferenceTimeout
+	187, // 43: inference.inference.QueryAllInferenceTimeoutResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	200, // 44: inference.inference.QueryGetInferenceValidationDetailsResponse.inferenceValidationDetails:type_name -> inference.inference.InferenceValidationDetails
+	186, // 45: inference.inference.QueryAllInferenceValidationDetailsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	200, // 46: inference.inference.QueryAllInferenceValidationDetailsResponse.inferenceValidationDetails:type_name -> inference.inference.InferenceValidationDetails
+	187, // 47: inference.inference.QueryAllInferenceValidationDetailsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	69,  // 48: inference.inference.QueryGetInferenceValidationParametersResponse.validator_powers:type_name -> inference.inference.ValidatorPower
+	200, // 49: inference.inference.QueryGetInferenceValidationParametersResponse.details:type_name -> inference.inference.InferenceValidationDetails
+	201, // 50: inference.inference.QueryGetInferenceValidationParametersResponse.parameters:type_name -> inference.inference.ValidationParams
+	202, // 51: inference.inference.QueryEpochPerformanceSummaryByEpochResponse.epochPerformanceSummary:type_name -> inference.inference.EpochPerformanceSummary
+	202, // 52: inference.inference.QueryEpochPerformanceSummaryByParticipantResponse.epochPerformanceSummary:type_name -> inference.inference.EpochPerformanceSummary
+	186, // 53: inference.inference.QueryAllEpochPerformanceSummaryRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	202, // 54: inference.inference.QueryAllEpochPerformanceSummaryResponse.epochPerformanceSummary:type_name -> inference.inference.EpochPerformanceSummary
+	187, // 55: inference.inference.QueryAllEpochPerformanceSummaryResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	203, // 56: inference.inference.QueryHardwareNodesResponse.nodes:type_name -> inference.inference.HardwareNodes
+	203, // 57: inference.inference.QueryHardwareNodesAllResponse.nodes:type_name -> inference.inference.HardwareNodes
+	84,  // 58: inference.inference.QueryGetAllParticipantCurrentStatsResponse.participant_current_stats:type_name -> inference.inference.ParticipantCurrentStats
+	85,  // 59: inference.inference.QueryParticipantsFullStatsResponse.participants_stats:type_name -> inference.inference.ParticipantFullStats
+	204, // 60: inference.inference.QueryStatsByTimePeriodByDeveloperResponse.stats:type_name -> inference.inference.DeveloperStatsByTime
+	94,  // 61: inference.inference.QueryInferencesAndTokensStatsByModelsResponse.stats_models:type_name -> inference.inference.ModelStats
+	182, // 62: inference.inference.QueryDebugStatsResponse.stats_by_time:type_name -> inference.inference.QueryDebugStatsResponse.TemporaryTimeStat
+	183, // 63: inference.inference.QueryDebugStatsResponse.stats_by_epoch:type_name -> inference.inference.QueryDebugStatsResponse.TemporaryEpochStat
+	205, // 64: inference.inference.QueryGetPartialUpgradeResponse.partialUpgrade:type_name -> inference.inference.PartialUpgrade
+	186, // 65: inference.inference.QueryAllPartialUpgradeRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	205, // 66: inference.inference.QueryAllPartialUpgradeResponse.partialUpgrade:type_name -> inference.inference.PartialUpgrade
+	187, // 67: inference.inference.QueryAllPartialUpgradeResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	206, // 68: inference.inference.QueryGetBridgeTransactionResponse.bridgeTransactions:type_name -> inference.inference.BridgeTransaction
+	186, // 69: inference.inference.QueryAllBridgeTransactionsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	206, // 70: inference.inference.QueryAllBridgeTransactionsResponse.bridgeTransactions:type_name -> inference.inference.BridgeTransaction
+	187, // 71: inference.inference.QueryAllBridgeTransactionsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	207, // 72: inference.inference.WrappedTokenBalance.token_info:type_name -> inference.inference.BridgeWrappedTokenContract
+	111, // 73: inference.inference.QueryWrappedTokenBalancesResponse.balances:type_name -> inference.inference.WrappedTokenBalance
+	208, // 74: inference.inference.QueryBridgeAddressesByChainResponse.addresses:type_name -> inference.inference.BridgeContractAddress
+	184, // 75: inference.inference.QueryEpochInfoResponse.params:type_name -> inference.inference.Params
+	209, // 76: inference.inference.QueryEpochInfoResponse.latest_epoch:type_name -> inference.inference.Epoch
+	210, // 77: inference.inference.QueryEpochInfoResponse.active_confirmation_poc_event:type_name -> inference.inference.ConfirmationPoCEvent
+	211, // 78: inference.inference.QueryApprovedTokensForTradeResponse.approved_tokens:type_name -> inference.inference.BridgeTokenReference
+	133, // 79: inference.inference.QueryGetAllModelPerTokenPricesResponse.model_prices:type_name -> inference.inference.ModelPrice
+	139, // 80: inference.inference.QueryGetAllModelCapacitiesResponse.model_capacities:type_name -> inference.inference.ModelCapacity
+	141, // 81: inference.inference.QueryGranteesByMessageTypeResponse.grantees:type_name -> inference.inference.Grantee
+	212, // 82: inference.inference.QueryGetMLNodeVersionResponse.mlnode_version:type_name -> inference.inference.MLNodeVersion
+	213, // 83: inference.inference.QueryExcludedParticipantsResponse.items:type_name -> inference.inference.ExcludedParticipant
+	210, // 84: inference.inference.QueryActiveConfirmationPoCEventResponse.event:type_name -> inference.inference.ConfirmationPoCEvent
+	210, // 85: inference.inference.QueryConfirmationPoCEventsResponse.events:type_name -> inference.inference.ConfirmationPoCEvent
+	188, // 86: inference.inference.ParticipantWithBalance.participant:type_name -> inference.inference.Participant
+	214, // 87: inference.inference.ParticipantWithBalance.balances:type_name -> cosmos.base.v1beta1.Coin
+	186, // 88: inference.inference.QueryParticipantsWithBalancesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest
+	155, // 89: inference.inference.QueryParticipantsWithBalancesResponse.participants:type_name -> inference.inference.ParticipantWithBalance
+	187, // 90: inference.inference.QueryParticipantsWithBalancesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse
+	215, // 91: inference.inference.QueryRandomSeedsResponse.seeds:type_name -> inference.inference.RandomSeed
+	216, // 92: inference.inference.QueryPoCValidationSnapshotResponse.snapshot:type_name -> inference.inference.PoCValidationSnapshot
+	217, // 93: inference.inference.QueryPreservedNodesSnapshotResponse.snapshot:type_name -> inference.inference.PreservedNodesSnapshot
+	218, // 94: inference.inference.QueryGetDevshardEscrowResponse.escrow:type_name -> inference.inference.DevshardEscrow
+	219, // 95: inference.inference.QueryGetDevshardHostEpochStatsResponse.stats:type_name -> inference.inference.DevshardHostEpochStats
+	220, // 96: inference.inference.QueryMaintenanceScheduledResponse.reservation:type_name -> inference.inference.MaintenanceReservation
+	220, // 97: inference.inference.QueryMaintenanceActiveResponse.reservations:type_name -> inference.inference.MaintenanceReservation
+	221, // 98: inference.inference.QueryMaintenanceStatusResponse.state:type_name -> inference.inference.MaintenanceState
+	220, // 99: inference.inference.QueryMaintenanceStatusResponse.active_reservation:type_name -> inference.inference.MaintenanceReservation
+	220, // 100: inference.inference.QueryMaintenanceStatusResponse.scheduled_reservation:type_name -> inference.inference.MaintenanceReservation
+	222, // 101: inference.inference.QueryListClaimRecipientsResponse.entries:type_name -> inference.inference.ClaimRecipientEntry
+	204, // 102: inference.inference.QueryDebugStatsResponse.TemporaryTimeStat.stats:type_name -> inference.inference.DeveloperStatsByTime
+	223, // 103: inference.inference.QueryDebugStatsResponse.TemporaryEpochStat.stats:type_name -> inference.inference.DeveloperStatsByEpoch
+	0,   // 104: inference.inference.Query.Params:input_type -> inference.inference.QueryParamsRequest
+	2,   // 105: inference.inference.Query.Inference:input_type -> inference.inference.QueryGetInferenceRequest
+	4,   // 106: inference.inference.Query.InferenceAll:input_type -> inference.inference.QueryAllInferenceRequest
+	6,   // 107: inference.inference.Query.Participant:input_type -> inference.inference.QueryGetParticipantRequest
+	8,   // 108: inference.inference.Query.ParticipantAll:input_type -> inference.inference.QueryAllParticipantRequest
+	10,  // 109: inference.inference.Query.AccountByAddress:input_type -> inference.inference.QueryAccountByAddressRequest
+	12,  // 110: inference.inference.Query.GetRandomExecutor:input_type -> inference.inference.QueryGetRandomExecutorRequest
+	14,  // 111: inference.inference.Query.EpochGroupData:input_type -> inference.inference.QueryGetEpochGroupDataRequest
+	16,  // 112: inference.inference.Query.EpochGroupDataAll:input_type -> inference.inference.QueryAllEpochGroupDataRequest
+	18,  // 113: inference.inference.Query.SettleAmount:input_type -> inference.inference.QueryGetSettleAmountRequest
+	20,  // 114: inference.inference.Query.SettleAmountAll:input_type -> inference.inference.QueryAllSettleAmountRequest
+	22,  // 115: inference.inference.Query.EstimateBitcoinReward:input_type -> inference.inference.QueryEstimateBitcoinRewardRequest
+	24,  // 116: inference.inference.Query.EpochGroupValidations:input_type -> inference.inference.QueryGetEpochGroupValidationsRequest
+	26,  // 117: inference.inference.Query.EpochGroupValidationsAll:input_type -> inference.inference.QueryAllEpochGroupValidationsRequest
+	28,  // 118: inference.inference.Query.PocBatchesForStage:input_type -> inference.inference.QueryPocBatchesForStageRequest
+	31,  // 119: inference.inference.Query.PocValidationsForStage:input_type -> inference.inference.QueryPocValidationsForStageRequest
+	34,  // 120: inference.inference.Query.PocV2ValidationsForStage:input_type -> inference.inference.QueryPocV2ValidationsForStageRequest
+	37,  // 121: inference.inference.Query.PoCV2StoreCommit:input_type -> inference.inference.QueryPoCV2StoreCommitRequest
+	39,  // 122: inference.inference.Query.MLNodeWeightDistribution:input_type -> inference.inference.QueryMLNodeWeightDistributionRequest
+	41,  // 123: inference.inference.Query.AllPoCV2StoreCommitsForStage:input_type -> inference.inference.QueryAllPoCV2StoreCommitsForStageRequest
+	44,  // 124: inference.inference.Query.AllMLNodeWeightDistributionsForStage:input_type -> inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest
+	47,  // 125: inference.inference.Query.GetCurrentEpoch:input_type -> inference.inference.QueryGetCurrentEpochRequest
+	49,  // 126: inference.inference.Query.TokenomicsData:input_type -> inference.inference.QueryGetTokenomicsDataRequest
+	51,  // 127: inference.inference.Query.GetUnitOfComputePriceProposal:input_type -> inference.inference.QueryGetUnitOfComputePriceProposalRequest
+	53,  // 128: inference.inference.Query.CurrentEpochGroupData:input_type -> inference.inference.QueryCurrentEpochGroupDataRequest
+	57,  // 129: inference.inference.Query.ModelsAll:input_type -> inference.inference.QueryModelsAllRequest
+	59,  // 130: inference.inference.Query.InferenceTimeout:input_type -> inference.inference.QueryGetInferenceTimeoutRequest
+	61,  // 131: inference.inference.Query.InferenceTimeoutAll:input_type -> inference.inference.QueryAllInferenceTimeoutRequest
+	63,  // 132: inference.inference.Query.InferenceValidationDetails:input_type -> inference.inference.QueryGetInferenceValidationDetailsRequest
+	65,  // 133: inference.inference.Query.InferenceValidationDetailsAll:input_type -> inference.inference.QueryAllInferenceValidationDetailsRequest
+	67,  // 134: inference.inference.Query.GetInferenceValidationParameters:input_type -> inference.inference.QueryGetInferenceValidationParametersRequest
+	70,  // 135: inference.inference.Query.EpochPerformanceSummary:input_type -> inference.inference.QueryEpochPerformanceSummaryByEpochRequest
+	72,  // 136: inference.inference.Query.EpochPerformanceSummaryByParticipant:input_type -> inference.inference.QueryEpochPerformanceSummaryByParticipantRequest
+	74,  // 137: inference.inference.Query.EpochPerformanceSummaryAll:input_type -> inference.inference.QueryAllEpochPerformanceSummaryRequest
+	76,  // 138: inference.inference.Query.HardwareNodes:input_type -> inference.inference.QueryHardwareNodesRequest
+	78,  // 139: inference.inference.Query.HardwareNodesAll:input_type -> inference.inference.QueryHardwareNodesAllRequest
+	80,  // 140: inference.inference.Query.GetParticipantCurrentStats:input_type -> inference.inference.QueryGetParticipantCurrentStatsRequest
+	82,  // 141: inference.inference.Query.GetAllParticipantCurrentStats:input_type -> inference.inference.QueryGetAllParticipantCurrentStatsRequest
+	86,  // 142: inference.inference.Query.GetParticipantsFullStats:input_type -> inference.inference.QueryParticipantsFullStatsRequest
+	88,  // 143: inference.inference.Query.StatsByTimePeriodByDeveloper:input_type -> inference.inference.QueryStatsByTimePeriodByDeveloperRequest
+	90,  // 144: inference.inference.Query.StatsByDeveloperAndEpochsBackwards:input_type -> inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest
+	97,  // 145: inference.inference.Query.CountParticipants:input_type -> inference.inference.QueryCountAllParticipantsRequest
+	99,  // 146: inference.inference.Query.DebugStatsDeveloperStats:input_type -> inference.inference.QueryDebugStatsRequest
+	91,  // 147: inference.inference.Query.InferencesAndTokensStatsByEpochsBackwards:input_type -> inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest
+	92,  // 148: inference.inference.Query.InferencesAndTokensStatsByTimePeriod:input_type -> inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest
+	93,  // 149: inference.inference.Query.InferencesAndTokensStatsByModels:input_type -> inference.inference.QueryInferencesAndTokensStatsByModelsRequest
+	101, // 150: inference.inference.Query.GetMinimumValidationAverage:input_type -> inference.inference.QueryGetMinimumValidationAverageRequest
+	103, // 151: inference.inference.Query.PartialUpgrade:input_type -> inference.inference.QueryGetPartialUpgradeRequest
+	105, // 152: inference.inference.Query.PartialUpgradeAll:input_type -> inference.inference.QueryAllPartialUpgradeRequest
+	107, // 153: inference.inference.Query.BridgeTransaction:input_type -> inference.inference.QueryGetBridgeTransactionRequest
+	109, // 154: inference.inference.Query.BridgeTransactions:input_type -> inference.inference.QueryAllBridgeTransactionsRequest
+	114, // 155: inference.inference.Query.BridgeAddressesByChain:input_type -> inference.inference.QueryBridgeAddressesByChainRequest
+	120, // 156: inference.inference.Query.LiquidityPool:input_type -> inference.inference.QueryLiquidityPoolRequest
+	112, // 157: inference.inference.Query.WrappedTokenBalances:input_type -> inference.inference.QueryWrappedTokenBalancesRequest
+	116, // 158: inference.inference.Query.ValidateWrappedTokenForTrade:input_type -> inference.inference.QueryValidateWrappedTokenForTradeRequest
+	118, // 159: inference.inference.Query.ValidateIbcTokenForTrade:input_type -> inference.inference.QueryValidateIbcTokenForTradeRequest
+	128, // 160: inference.inference.Query.ApprovedTokensForTrade:input_type -> inference.inference.QueryApprovedTokensForTradeRequest
+	122, // 161: inference.inference.Query.EpochInfo:input_type -> inference.inference.QueryEpochInfoRequest
+	124, // 162: inference.inference.Query.CountPoCbatchesAtHeight:input_type -> inference.inference.QueryCountPoCbatchesAtHeightRequest
+	126, // 163: inference.inference.Query.CountPoCvalidationsAtHeight:input_type -> inference.inference.QueryCountPoCvalidationsAtHeightRequest
+	130, // 164: inference.inference.Query.GetModelPerTokenPrice:input_type -> inference.inference.QueryGetModelPerTokenPriceRequest
+	132, // 165: inference.inference.Query.GetAllModelPerTokenPrices:input_type -> inference.inference.QueryGetAllModelPerTokenPricesRequest
+	135, // 166: inference.inference.Query.GetModelCapacity:input_type -> inference.inference.QueryGetModelCapacityRequest
+	137, // 167: inference.inference.Query.GetAllModelCapacities:input_type -> inference.inference.QueryGetAllModelCapacitiesRequest
+	140, // 168: inference.inference.Query.GranteesByMessageType:input_type -> inference.inference.QueryGranteesByMessageTypeRequest
+	145, // 169: inference.inference.Query.MLNodeVersion:input_type -> inference.inference.QueryGetMLNodeVersionRequest
+	147, // 170: inference.inference.Query.LastUpgradeHeight:input_type -> inference.inference.QueryGetLastUpgradeHeightRequest
+	143, // 171: inference.inference.Query.ParticipantAllowList:input_type -> inference.inference.QueryParticipantAllowListRequest
+	149, // 172: inference.inference.Query.ExcludedParticipants:input_type -> inference.inference.QueryExcludedParticipantsRequest
+	151, // 173: inference.inference.Query.ActiveConfirmationPoCEvent:input_type -> inference.inference.QueryActiveConfirmationPoCEventRequest
+	153, // 174: inference.inference.Query.ListConfirmationPoCEvents:input_type -> inference.inference.QueryConfirmationPoCEventsRequest
+	158, // 175: inference.inference.Query.ListRandomSeeds:input_type -> inference.inference.QueryRandomSeedsRequest
+	156, // 176: inference.inference.Query.ParticipantsWithBalances:input_type -> inference.inference.QueryParticipantsWithBalancesRequest
+	160, // 177: inference.inference.Query.PoCValidationSnapshot:input_type -> inference.inference.QueryPoCValidationSnapshotRequest
+	164, // 178: inference.inference.Query.DevshardEscrow:input_type -> inference.inference.QueryGetDevshardEscrowRequest
+	162, // 179: inference.inference.Query.PreservedNodesSnapshot:input_type -> inference.inference.QueryPreservedNodesSnapshotRequest
+	166, // 180: inference.inference.Query.DevshardHostEpochStats:input_type -> inference.inference.QueryGetDevshardHostEpochStatsRequest
+	224, // 181: inference.inference.Query.PoCDelegation:input_type -> inference.inference.QueryPoCDelegationRequest
+	168, // 182: inference.inference.Query.MaintenanceCredit:input_type -> inference.inference.QueryMaintenanceCreditRequest
+	170, // 183: inference.inference.Query.MaintenanceScheduled:input_type -> inference.inference.QueryMaintenanceScheduledRequest
+	172, // 184: inference.inference.Query.MaintenanceActive:input_type -> inference.inference.QueryMaintenanceActiveRequest
+	174, // 185: inference.inference.Query.MaintenanceStatus:input_type -> inference.inference.QueryMaintenanceStatusRequest
+	176, // 186: inference.inference.Query.MaintenanceConcurrency:input_type -> inference.inference.QueryMaintenanceConcurrencyRequest
+	178, // 187: inference.inference.Query.MaintenanceSchedulability:input_type -> inference.inference.QueryMaintenanceSchedulabilityRequest
+	180, // 188: inference.inference.Query.ListClaimRecipients:input_type -> inference.inference.QueryListClaimRecipientsRequest
+	1,   // 189: inference.inference.Query.Params:output_type -> inference.inference.QueryParamsResponse
+	3,   // 190: inference.inference.Query.Inference:output_type -> inference.inference.QueryGetInferenceResponse
+	5,   // 191: inference.inference.Query.InferenceAll:output_type -> inference.inference.QueryAllInferenceResponse
+	7,   // 192: inference.inference.Query.Participant:output_type -> inference.inference.QueryGetParticipantResponse
+	9,   // 193: inference.inference.Query.ParticipantAll:output_type -> inference.inference.QueryAllParticipantResponse
+	11,  // 194: inference.inference.Query.AccountByAddress:output_type -> inference.inference.QueryAccountByAddressResponse
+	13,  // 195: inference.inference.Query.GetRandomExecutor:output_type -> inference.inference.QueryGetRandomExecutorResponse
+	15,  // 196: inference.inference.Query.EpochGroupData:output_type -> inference.inference.QueryGetEpochGroupDataResponse
+	17,  // 197: inference.inference.Query.EpochGroupDataAll:output_type -> inference.inference.QueryAllEpochGroupDataResponse
+	19,  // 198: inference.inference.Query.SettleAmount:output_type -> inference.inference.QueryGetSettleAmountResponse
+	21,  // 199: inference.inference.Query.SettleAmountAll:output_type -> inference.inference.QueryAllSettleAmountResponse
+	23,  // 200: inference.inference.Query.EstimateBitcoinReward:output_type -> inference.inference.QueryEstimateBitcoinRewardResponse
+	25,  // 201: inference.inference.Query.EpochGroupValidations:output_type -> inference.inference.QueryGetEpochGroupValidationsResponse
+	27,  // 202: inference.inference.Query.EpochGroupValidationsAll:output_type -> inference.inference.QueryAllEpochGroupValidationsResponse
+	29,  // 203: inference.inference.Query.PocBatchesForStage:output_type -> inference.inference.QueryPocBatchesForStageResponse
+	32,  // 204: inference.inference.Query.PocValidationsForStage:output_type -> inference.inference.QueryPocValidationsForStageResponse
+	35,  // 205: inference.inference.Query.PocV2ValidationsForStage:output_type -> inference.inference.QueryPocV2ValidationsForStageResponse
+	38,  // 206: inference.inference.Query.PoCV2StoreCommit:output_type -> inference.inference.QueryPoCV2StoreCommitResponse
+	40,  // 207: inference.inference.Query.MLNodeWeightDistribution:output_type -> inference.inference.QueryMLNodeWeightDistributionResponse
+	42,  // 208: inference.inference.Query.AllPoCV2StoreCommitsForStage:output_type -> inference.inference.QueryAllPoCV2StoreCommitsForStageResponse
+	45,  // 209: inference.inference.Query.AllMLNodeWeightDistributionsForStage:output_type -> inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse
+	48,  // 210: inference.inference.Query.GetCurrentEpoch:output_type -> inference.inference.QueryGetCurrentEpochResponse
+	50,  // 211: inference.inference.Query.TokenomicsData:output_type -> inference.inference.QueryGetTokenomicsDataResponse
+	52,  // 212: inference.inference.Query.GetUnitOfComputePriceProposal:output_type -> inference.inference.QueryGetUnitOfComputePriceProposalResponse
+	54,  // 213: inference.inference.Query.CurrentEpochGroupData:output_type -> inference.inference.QueryCurrentEpochGroupDataResponse
+	58,  // 214: inference.inference.Query.ModelsAll:output_type -> inference.inference.QueryModelsAllResponse
+	60,  // 215: inference.inference.Query.InferenceTimeout:output_type -> inference.inference.QueryGetInferenceTimeoutResponse
+	62,  // 216: inference.inference.Query.InferenceTimeoutAll:output_type -> inference.inference.QueryAllInferenceTimeoutResponse
+	64,  // 217: inference.inference.Query.InferenceValidationDetails:output_type -> inference.inference.QueryGetInferenceValidationDetailsResponse
+	66,  // 218: inference.inference.Query.InferenceValidationDetailsAll:output_type -> inference.inference.QueryAllInferenceValidationDetailsResponse
+	68,  // 219: inference.inference.Query.GetInferenceValidationParameters:output_type -> inference.inference.QueryGetInferenceValidationParametersResponse
+	71,  // 220: inference.inference.Query.EpochPerformanceSummary:output_type -> inference.inference.QueryEpochPerformanceSummaryByEpochResponse
+	73,  // 221: inference.inference.Query.EpochPerformanceSummaryByParticipant:output_type -> inference.inference.QueryEpochPerformanceSummaryByParticipantResponse
+	75,  // 222: inference.inference.Query.EpochPerformanceSummaryAll:output_type -> inference.inference.QueryAllEpochPerformanceSummaryResponse
+	77,  // 223: inference.inference.Query.HardwareNodes:output_type -> inference.inference.QueryHardwareNodesResponse
+	79,  // 224: inference.inference.Query.HardwareNodesAll:output_type -> inference.inference.QueryHardwareNodesAllResponse
+	81,  // 225: inference.inference.Query.GetParticipantCurrentStats:output_type -> inference.inference.QueryGetParticipantCurrentStatsResponse
+	83,  // 226: inference.inference.Query.GetAllParticipantCurrentStats:output_type -> inference.inference.QueryGetAllParticipantCurrentStatsResponse
+	87,  // 227: inference.inference.Query.GetParticipantsFullStats:output_type -> inference.inference.QueryParticipantsFullStatsResponse
+	89,  // 228: inference.inference.Query.StatsByTimePeriodByDeveloper:output_type -> inference.inference.QueryStatsByTimePeriodByDeveloperResponse
+	96,  // 229: inference.inference.Query.StatsByDeveloperAndEpochsBackwards:output_type -> inference.inference.QueryInferencesAndTokensStatsResponse
+	98,  // 230: inference.inference.Query.CountParticipants:output_type -> inference.inference.QueryCountAllParticipantsResponse
+	100, // 231: inference.inference.Query.DebugStatsDeveloperStats:output_type -> inference.inference.QueryDebugStatsResponse
+	96,  // 232: inference.inference.Query.InferencesAndTokensStatsByEpochsBackwards:output_type -> inference.inference.QueryInferencesAndTokensStatsResponse
+	96,  // 233: inference.inference.Query.InferencesAndTokensStatsByTimePeriod:output_type -> inference.inference.QueryInferencesAndTokensStatsResponse
+	95,  // 234: inference.inference.Query.InferencesAndTokensStatsByModels:output_type -> inference.inference.QueryInferencesAndTokensStatsByModelsResponse
+	102, // 235: inference.inference.Query.GetMinimumValidationAverage:output_type -> inference.inference.QueryGetMinimumValidationAverageResponse
+	104, // 236: inference.inference.Query.PartialUpgrade:output_type -> inference.inference.QueryGetPartialUpgradeResponse
+	106, // 237: inference.inference.Query.PartialUpgradeAll:output_type -> inference.inference.QueryAllPartialUpgradeResponse
+	108, // 238: inference.inference.Query.BridgeTransaction:output_type -> inference.inference.QueryGetBridgeTransactionResponse
+	110, // 239: inference.inference.Query.BridgeTransactions:output_type -> inference.inference.QueryAllBridgeTransactionsResponse
+	115, // 240: inference.inference.Query.BridgeAddressesByChain:output_type -> inference.inference.QueryBridgeAddressesByChainResponse
+	121, // 241: inference.inference.Query.LiquidityPool:output_type -> inference.inference.QueryLiquidityPoolResponse
+	113, // 242: inference.inference.Query.WrappedTokenBalances:output_type -> inference.inference.QueryWrappedTokenBalancesResponse
+	117, // 243: inference.inference.Query.ValidateWrappedTokenForTrade:output_type -> inference.inference.QueryValidateWrappedTokenForTradeResponse
+	119, // 244: inference.inference.Query.ValidateIbcTokenForTrade:output_type -> inference.inference.QueryValidateIbcTokenForTradeResponse
+	129, // 245: inference.inference.Query.ApprovedTokensForTrade:output_type -> inference.inference.QueryApprovedTokensForTradeResponse
+	123, // 246: inference.inference.Query.EpochInfo:output_type -> inference.inference.QueryEpochInfoResponse
+	125, // 247: inference.inference.Query.CountPoCbatchesAtHeight:output_type -> inference.inference.QueryCountPoCbatchesAtHeightResponse
+	127, // 248: inference.inference.Query.CountPoCvalidationsAtHeight:output_type -> inference.inference.QueryCountPoCvalidationsAtHeightResponse
+	131, // 249: inference.inference.Query.GetModelPerTokenPrice:output_type -> inference.inference.QueryGetModelPerTokenPriceResponse
+	134, // 250: inference.inference.Query.GetAllModelPerTokenPrices:output_type -> inference.inference.QueryGetAllModelPerTokenPricesResponse
+	136, // 251: inference.inference.Query.GetModelCapacity:output_type -> inference.inference.QueryGetModelCapacityResponse
+	138, // 252: inference.inference.Query.GetAllModelCapacities:output_type -> inference.inference.QueryGetAllModelCapacitiesResponse
+	142, // 253: inference.inference.Query.GranteesByMessageType:output_type -> inference.inference.QueryGranteesByMessageTypeResponse
+	146, // 254: inference.inference.Query.MLNodeVersion:output_type -> inference.inference.QueryGetMLNodeVersionResponse
+	148, // 255: inference.inference.Query.LastUpgradeHeight:output_type -> inference.inference.QueryGetLastUpgradeHeightResponse
+	144, // 256: inference.inference.Query.ParticipantAllowList:output_type -> inference.inference.QueryParticipantAllowListResponse
+	150, // 257: inference.inference.Query.ExcludedParticipants:output_type -> inference.inference.QueryExcludedParticipantsResponse
+	152, // 258: inference.inference.Query.ActiveConfirmationPoCEvent:output_type -> inference.inference.QueryActiveConfirmationPoCEventResponse
+	154, // 259: inference.inference.Query.ListConfirmationPoCEvents:output_type -> inference.inference.QueryConfirmationPoCEventsResponse
+	159, // 260: inference.inference.Query.ListRandomSeeds:output_type -> inference.inference.QueryRandomSeedsResponse
+	157, // 261: inference.inference.Query.ParticipantsWithBalances:output_type -> inference.inference.QueryParticipantsWithBalancesResponse
+	161, // 262: inference.inference.Query.PoCValidationSnapshot:output_type -> inference.inference.QueryPoCValidationSnapshotResponse
+	165, // 263: inference.inference.Query.DevshardEscrow:output_type -> inference.inference.QueryGetDevshardEscrowResponse
+	163, // 264: inference.inference.Query.PreservedNodesSnapshot:output_type -> inference.inference.QueryPreservedNodesSnapshotResponse
+	167, // 265: inference.inference.Query.DevshardHostEpochStats:output_type -> inference.inference.QueryGetDevshardHostEpochStatsResponse
+	225, // 266: inference.inference.Query.PoCDelegation:output_type -> inference.inference.QueryPoCDelegationResponse
+	169, // 267: inference.inference.Query.MaintenanceCredit:output_type -> inference.inference.QueryMaintenanceCreditResponse
+	171, // 268: inference.inference.Query.MaintenanceScheduled:output_type -> inference.inference.QueryMaintenanceScheduledResponse
+	173, // 269: inference.inference.Query.MaintenanceActive:output_type -> inference.inference.QueryMaintenanceActiveResponse
+	175, // 270: inference.inference.Query.MaintenanceStatus:output_type -> inference.inference.QueryMaintenanceStatusResponse
+	177, // 271: inference.inference.Query.MaintenanceConcurrency:output_type -> inference.inference.QueryMaintenanceConcurrencyResponse
+	179, // 272: inference.inference.Query.MaintenanceSchedulability:output_type -> inference.inference.QueryMaintenanceSchedulabilityResponse
+	181, // 273: inference.inference.Query.ListClaimRecipients:output_type -> inference.inference.QueryListClaimRecipientsResponse
+	189, // [189:274] is the sub-list for method output_type
+	104, // [104:189] is the sub-list for method input_type
+	104, // [104:104] is the sub-list for extension type_name
+	104, // [104:104] is the sub-list for extension extendee
+	0,   // [0:104] is the sub-list for field type_name
 }
 
 func init() { file_inference_inference_query_proto_init() }
@@ -87257,8 +96370,10 @@ func file_inference_inference_query_proto_init() {
 	file_inference_inference_random_seed_proto_init()
 	file_inference_inference_poc_validation_snapshot_proto_init()
 	file_inference_inference_devshard_escrow_proto_init()
+	file_inference_inference_maintenance_proto_init()
 	file_inference_inference_preserved_nodes_snapshot_proto_init()
 	file_inference_inference_poc_delegation_proto_init()
+	file_inference_inference_claim_recipient_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_inference_inference_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*QueryParamsRequest); i {
@@ -87525,7 +96640,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetEpochGroupValidationsRequest); i {
+			switch v := v.(*QueryEstimateBitcoinRewardRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87537,7 +96652,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetEpochGroupValidationsResponse); i {
+			switch v := v.(*QueryEstimateBitcoinRewardResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87549,7 +96664,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllEpochGroupValidationsRequest); i {
+			switch v := v.(*QueryGetEpochGroupValidationsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87561,7 +96676,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllEpochGroupValidationsResponse); i {
+			switch v := v.(*QueryGetEpochGroupValidationsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87573,7 +96688,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPocBatchesForStageRequest); i {
+			switch v := v.(*QueryAllEpochGroupValidationsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87585,7 +96700,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPocBatchesForStageResponse); i {
+			switch v := v.(*QueryAllEpochGroupValidationsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87597,7 +96712,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCBatchesWithParticipants); i {
+			switch v := v.(*QueryPocBatchesForStageRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87609,7 +96724,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPocValidationsForStageRequest); i {
+			switch v := v.(*QueryPocBatchesForStageResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87621,7 +96736,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPocValidationsForStageResponse); i {
+			switch v := v.(*PoCBatchesWithParticipants); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87633,7 +96748,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCValidationsWithParticipants); i {
+			switch v := v.(*QueryPocValidationsForStageRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87645,7 +96760,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPocV2ValidationsForStageRequest); i {
+			switch v := v.(*QueryPocValidationsForStageResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87657,7 +96772,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPocV2ValidationsForStageResponse); i {
+			switch v := v.(*PoCValidationsWithParticipants); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87669,7 +96784,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCValidationsWithParticipantsV2); i {
+			switch v := v.(*QueryPocV2ValidationsForStageRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87681,7 +96796,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPoCV2StoreCommitRequest); i {
+			switch v := v.(*QueryPocV2ValidationsForStageResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87693,7 +96808,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPoCV2StoreCommitResponse); i {
+			switch v := v.(*PoCValidationsWithParticipantsV2); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87705,7 +96820,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryMLNodeWeightDistributionRequest); i {
+			switch v := v.(*QueryPoCV2StoreCommitRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87717,7 +96832,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryMLNodeWeightDistributionResponse); i {
+			switch v := v.(*QueryPoCV2StoreCommitResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87729,7 +96844,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllPoCV2StoreCommitsForStageRequest); i {
+			switch v := v.(*QueryMLNodeWeightDistributionRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87741,7 +96856,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllPoCV2StoreCommitsForStageResponse); i {
+			switch v := v.(*QueryMLNodeWeightDistributionResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87753,7 +96868,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PoCV2StoreCommitWithAddress); i {
+			switch v := v.(*QueryAllPoCV2StoreCommitsForStageRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87765,7 +96880,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllMLNodeWeightDistributionsForStageRequest); i {
+			switch v := v.(*QueryAllPoCV2StoreCommitsForStageResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87777,7 +96892,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllMLNodeWeightDistributionsForStageResponse); i {
+			switch v := v.(*PoCV2StoreCommitWithAddress); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87789,7 +96904,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MLNodeWeightDistributionWithAddress); i {
+			switch v := v.(*QueryAllMLNodeWeightDistributionsForStageRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87801,7 +96916,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetCurrentEpochRequest); i {
+			switch v := v.(*QueryAllMLNodeWeightDistributionsForStageResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87813,7 +96928,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetCurrentEpochResponse); i {
+			switch v := v.(*MLNodeWeightDistributionWithAddress); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87825,7 +96940,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetTokenomicsDataRequest); i {
+			switch v := v.(*QueryGetCurrentEpochRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87837,7 +96952,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetTokenomicsDataResponse); i {
+			switch v := v.(*QueryGetCurrentEpochResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87849,7 +96964,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetUnitOfComputePriceProposalRequest); i {
+			switch v := v.(*QueryGetTokenomicsDataRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87861,7 +96976,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetUnitOfComputePriceProposalResponse); i {
+			switch v := v.(*QueryGetTokenomicsDataResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87873,7 +96988,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCurrentEpochGroupDataRequest); i {
+			switch v := v.(*QueryGetUnitOfComputePriceProposalRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87885,7 +97000,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCurrentEpochGroupDataResponse); i {
+			switch v := v.(*QueryGetUnitOfComputePriceProposalResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87897,7 +97012,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPreviousEpochGroupDataRequest); i {
+			switch v := v.(*QueryCurrentEpochGroupDataRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87909,7 +97024,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPreviousEpochGroupDataResponse); i {
+			switch v := v.(*QueryCurrentEpochGroupDataResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87921,7 +97036,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryModelsAllRequest); i {
+			switch v := v.(*QueryPreviousEpochGroupDataRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87933,7 +97048,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryModelsAllResponse); i {
+			switch v := v.(*QueryPreviousEpochGroupDataResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87945,7 +97060,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetInferenceTimeoutRequest); i {
+			switch v := v.(*QueryModelsAllRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87957,7 +97072,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetInferenceTimeoutResponse); i {
+			switch v := v.(*QueryModelsAllResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87969,7 +97084,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllInferenceTimeoutRequest); i {
+			switch v := v.(*QueryGetInferenceTimeoutRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87981,7 +97096,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllInferenceTimeoutResponse); i {
+			switch v := v.(*QueryGetInferenceTimeoutResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -87993,7 +97108,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetInferenceValidationDetailsRequest); i {
+			switch v := v.(*QueryAllInferenceTimeoutRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88005,7 +97120,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetInferenceValidationDetailsResponse); i {
+			switch v := v.(*QueryAllInferenceTimeoutResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88017,7 +97132,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllInferenceValidationDetailsRequest); i {
+			switch v := v.(*QueryGetInferenceValidationDetailsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88029,7 +97144,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllInferenceValidationDetailsResponse); i {
+			switch v := v.(*QueryGetInferenceValidationDetailsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88041,7 +97156,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetInferenceValidationParametersRequest); i {
+			switch v := v.(*QueryAllInferenceValidationDetailsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88053,7 +97168,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetInferenceValidationParametersResponse); i {
+			switch v := v.(*QueryAllInferenceValidationDetailsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88065,7 +97180,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ValidatorPower); i {
+			switch v := v.(*QueryGetInferenceValidationParametersRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88077,7 +97192,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryEpochPerformanceSummaryByEpochRequest); i {
+			switch v := v.(*QueryGetInferenceValidationParametersResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88089,7 +97204,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryEpochPerformanceSummaryByEpochResponse); i {
+			switch v := v.(*ValidatorPower); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88101,7 +97216,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryEpochPerformanceSummaryByParticipantRequest); i {
+			switch v := v.(*QueryEpochPerformanceSummaryByEpochRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88113,7 +97228,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryEpochPerformanceSummaryByParticipantResponse); i {
+			switch v := v.(*QueryEpochPerformanceSummaryByEpochResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88125,7 +97240,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllEpochPerformanceSummaryRequest); i {
+			switch v := v.(*QueryEpochPerformanceSummaryByParticipantRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88137,7 +97252,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllEpochPerformanceSummaryResponse); i {
+			switch v := v.(*QueryEpochPerformanceSummaryByParticipantResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88149,7 +97264,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryHardwareNodesRequest); i {
+			switch v := v.(*QueryAllEpochPerformanceSummaryRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88161,7 +97276,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryHardwareNodesResponse); i {
+			switch v := v.(*QueryAllEpochPerformanceSummaryResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88173,7 +97288,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryHardwareNodesAllRequest); i {
+			switch v := v.(*QueryHardwareNodesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88185,7 +97300,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryHardwareNodesAllResponse); i {
+			switch v := v.(*QueryHardwareNodesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88197,7 +97312,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetParticipantCurrentStatsRequest); i {
+			switch v := v.(*QueryHardwareNodesAllRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88209,7 +97324,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetParticipantCurrentStatsResponse); i {
+			switch v := v.(*QueryHardwareNodesAllResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88221,7 +97336,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetAllParticipantCurrentStatsRequest); i {
+			switch v := v.(*QueryGetParticipantCurrentStatsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88233,7 +97348,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetAllParticipantCurrentStatsResponse); i {
+			switch v := v.(*QueryGetParticipantCurrentStatsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88245,7 +97360,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ParticipantCurrentStats); i {
+			switch v := v.(*QueryGetAllParticipantCurrentStatsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88257,7 +97372,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ParticipantFullStats); i {
+			switch v := v.(*QueryGetAllParticipantCurrentStatsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88269,7 +97384,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryParticipantsFullStatsRequest); i {
+			switch v := v.(*ParticipantCurrentStats); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88281,7 +97396,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryParticipantsFullStatsResponse); i {
+			switch v := v.(*ParticipantFullStats); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88293,7 +97408,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryStatsByTimePeriodByDeveloperRequest); i {
+			switch v := v.(*QueryParticipantsFullStatsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88305,7 +97420,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryStatsByTimePeriodByDeveloperResponse); i {
+			switch v := v.(*QueryParticipantsFullStatsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88317,7 +97432,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryStatsByDeveloperAndEpochBackwardsRequest); i {
+			switch v := v.(*QueryStatsByTimePeriodByDeveloperRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88329,7 +97444,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest); i {
+			switch v := v.(*QueryStatsByTimePeriodByDeveloperResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88341,7 +97456,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryInferencesAndTokensStatsByTimePeriodRequest); i {
+			switch v := v.(*QueryStatsByDeveloperAndEpochBackwardsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88353,7 +97468,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryInferencesAndTokensStatsByModelsRequest); i {
+			switch v := v.(*QueryInferencesAndTokensStatsByEpochsBackwardsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88365,7 +97480,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ModelStats); i {
+			switch v := v.(*QueryInferencesAndTokensStatsByTimePeriodRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88377,7 +97492,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryInferencesAndTokensStatsByModelsResponse); i {
+			switch v := v.(*QueryInferencesAndTokensStatsByModelsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88389,7 +97504,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryInferencesAndTokensStatsResponse); i {
+			switch v := v.(*ModelStats); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88401,7 +97516,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCountAllParticipantsRequest); i {
+			switch v := v.(*QueryInferencesAndTokensStatsByModelsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88413,7 +97528,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCountAllParticipantsResponse); i {
+			switch v := v.(*QueryInferencesAndTokensStatsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88425,7 +97540,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryDebugStatsRequest); i {
+			switch v := v.(*QueryCountAllParticipantsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88437,7 +97552,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryDebugStatsResponse); i {
+			switch v := v.(*QueryCountAllParticipantsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88449,7 +97564,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetMinimumValidationAverageRequest); i {
+			switch v := v.(*QueryDebugStatsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88461,7 +97576,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetMinimumValidationAverageResponse); i {
+			switch v := v.(*QueryDebugStatsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88473,7 +97588,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetPartialUpgradeRequest); i {
+			switch v := v.(*QueryGetMinimumValidationAverageRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88485,7 +97600,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetPartialUpgradeResponse); i {
+			switch v := v.(*QueryGetMinimumValidationAverageResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88497,7 +97612,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllPartialUpgradeRequest); i {
+			switch v := v.(*QueryGetPartialUpgradeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88509,7 +97624,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllPartialUpgradeResponse); i {
+			switch v := v.(*QueryGetPartialUpgradeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88521,7 +97636,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetBridgeTransactionRequest); i {
+			switch v := v.(*QueryAllPartialUpgradeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88533,7 +97648,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetBridgeTransactionResponse); i {
+			switch v := v.(*QueryAllPartialUpgradeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88545,7 +97660,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllBridgeTransactionsRequest); i {
+			switch v := v.(*QueryGetBridgeTransactionRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88557,7 +97672,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryAllBridgeTransactionsResponse); i {
+			switch v := v.(*QueryGetBridgeTransactionResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88569,7 +97684,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*WrappedTokenBalance); i {
+			switch v := v.(*QueryAllBridgeTransactionsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88581,7 +97696,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryWrappedTokenBalancesRequest); i {
+			switch v := v.(*QueryAllBridgeTransactionsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88593,7 +97708,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryWrappedTokenBalancesResponse); i {
+			switch v := v.(*WrappedTokenBalance); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88605,7 +97720,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryBridgeAddressesByChainRequest); i {
+			switch v := v.(*QueryWrappedTokenBalancesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88617,7 +97732,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryBridgeAddressesByChainResponse); i {
+			switch v := v.(*QueryWrappedTokenBalancesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88629,7 +97744,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryValidateWrappedTokenForTradeRequest); i {
+			switch v := v.(*QueryBridgeAddressesByChainRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88641,7 +97756,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryValidateWrappedTokenForTradeResponse); i {
+			switch v := v.(*QueryBridgeAddressesByChainResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88653,7 +97768,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryValidateIbcTokenForTradeRequest); i {
+			switch v := v.(*QueryValidateWrappedTokenForTradeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88665,7 +97780,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryValidateIbcTokenForTradeResponse); i {
+			switch v := v.(*QueryValidateWrappedTokenForTradeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88677,7 +97792,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryLiquidityPoolRequest); i {
+			switch v := v.(*QueryValidateIbcTokenForTradeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88689,7 +97804,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryLiquidityPoolResponse); i {
+			switch v := v.(*QueryValidateIbcTokenForTradeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88701,7 +97816,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryEpochInfoRequest); i {
+			switch v := v.(*QueryLiquidityPoolRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88713,7 +97828,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryEpochInfoResponse); i {
+			switch v := v.(*QueryLiquidityPoolResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88725,7 +97840,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCountPoCbatchesAtHeightRequest); i {
+			switch v := v.(*QueryEpochInfoRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88737,7 +97852,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCountPoCbatchesAtHeightResponse); i {
+			switch v := v.(*QueryEpochInfoResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88749,7 +97864,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCountPoCvalidationsAtHeightRequest); i {
+			switch v := v.(*QueryCountPoCbatchesAtHeightRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88761,7 +97876,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryCountPoCvalidationsAtHeightResponse); i {
+			switch v := v.(*QueryCountPoCbatchesAtHeightResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88773,7 +97888,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryApprovedTokensForTradeRequest); i {
+			switch v := v.(*QueryCountPoCvalidationsAtHeightRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88785,7 +97900,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryApprovedTokensForTradeResponse); i {
+			switch v := v.(*QueryCountPoCvalidationsAtHeightResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88797,7 +97912,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetModelPerTokenPriceRequest); i {
+			switch v := v.(*QueryApprovedTokensForTradeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88809,7 +97924,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetModelPerTokenPriceResponse); i {
+			switch v := v.(*QueryApprovedTokensForTradeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88821,7 +97936,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetAllModelPerTokenPricesRequest); i {
+			switch v := v.(*QueryGetModelPerTokenPriceRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88833,7 +97948,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ModelPrice); i {
+			switch v := v.(*QueryGetModelPerTokenPriceResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88845,7 +97960,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetAllModelPerTokenPricesResponse); i {
+			switch v := v.(*QueryGetAllModelPerTokenPricesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88857,7 +97972,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[133].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetModelCapacityRequest); i {
+			switch v := v.(*ModelPrice); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88869,7 +97984,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[134].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetModelCapacityResponse); i {
+			switch v := v.(*QueryGetAllModelPerTokenPricesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88881,7 +97996,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[135].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetAllModelCapacitiesRequest); i {
+			switch v := v.(*QueryGetModelCapacityRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88893,7 +98008,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[136].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetAllModelCapacitiesResponse); i {
+			switch v := v.(*QueryGetModelCapacityResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88905,7 +98020,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[137].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ModelCapacity); i {
+			switch v := v.(*QueryGetAllModelCapacitiesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88917,7 +98032,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[138].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGranteesByMessageTypeRequest); i {
+			switch v := v.(*QueryGetAllModelCapacitiesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88929,7 +98044,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Grantee); i {
+			switch v := v.(*ModelCapacity); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88941,7 +98056,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGranteesByMessageTypeResponse); i {
+			switch v := v.(*QueryGranteesByMessageTypeRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88953,7 +98068,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[141].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryParticipantAllowListRequest); i {
+			switch v := v.(*Grantee); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88965,7 +98080,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[142].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryParticipantAllowListResponse); i {
+			switch v := v.(*QueryGranteesByMessageTypeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88977,7 +98092,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[143].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetMLNodeVersionRequest); i {
+			switch v := v.(*QueryParticipantAllowListRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -88989,7 +98104,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetMLNodeVersionResponse); i {
+			switch v := v.(*QueryParticipantAllowListResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89001,7 +98116,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[145].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryExcludedParticipantsRequest); i {
+			switch v := v.(*QueryGetMLNodeVersionRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89013,7 +98128,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[146].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryExcludedParticipantsResponse); i {
+			switch v := v.(*QueryGetMLNodeVersionResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89025,7 +98140,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[147].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryActiveConfirmationPoCEventRequest); i {
+			switch v := v.(*QueryGetLastUpgradeHeightRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89037,7 +98152,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[148].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryActiveConfirmationPoCEventResponse); i {
+			switch v := v.(*QueryGetLastUpgradeHeightResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89049,7 +98164,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[149].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryConfirmationPoCEventsRequest); i {
+			switch v := v.(*QueryExcludedParticipantsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89061,7 +98176,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[150].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryConfirmationPoCEventsResponse); i {
+			switch v := v.(*QueryExcludedParticipantsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89073,7 +98188,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[151].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ParticipantWithBalance); i {
+			switch v := v.(*QueryActiveConfirmationPoCEventRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89085,7 +98200,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[152].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryParticipantsWithBalancesRequest); i {
+			switch v := v.(*QueryActiveConfirmationPoCEventResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89097,7 +98212,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[153].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryParticipantsWithBalancesResponse); i {
+			switch v := v.(*QueryConfirmationPoCEventsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89109,7 +98224,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[154].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryRandomSeedsRequest); i {
+			switch v := v.(*QueryConfirmationPoCEventsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89121,7 +98236,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[155].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryRandomSeedsResponse); i {
+			switch v := v.(*ParticipantWithBalance); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89133,7 +98248,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[156].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPoCValidationSnapshotRequest); i {
+			switch v := v.(*QueryParticipantsWithBalancesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89145,7 +98260,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[157].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPoCValidationSnapshotResponse); i {
+			switch v := v.(*QueryParticipantsWithBalancesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89157,7 +98272,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[158].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPreservedNodesSnapshotRequest); i {
+			switch v := v.(*QueryRandomSeedsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89169,7 +98284,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[159].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryPreservedNodesSnapshotResponse); i {
+			switch v := v.(*QueryRandomSeedsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89181,7 +98296,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[160].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetDevshardEscrowRequest); i {
+			switch v := v.(*QueryPoCValidationSnapshotRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89193,7 +98308,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[161].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetDevshardEscrowResponse); i {
+			switch v := v.(*QueryPoCValidationSnapshotResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89205,7 +98320,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[162].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetDevshardHostEpochStatsRequest); i {
+			switch v := v.(*QueryPreservedNodesSnapshotRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89217,7 +98332,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[163].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryGetDevshardHostEpochStatsResponse); i {
+			switch v := v.(*QueryPreservedNodesSnapshotResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89229,7 +98344,7 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[164].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*QueryDebugStatsResponse_TemporaryTimeStat); i {
+			switch v := v.(*QueryGetDevshardEscrowRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -89241,6 +98356,222 @@ func file_inference_inference_query_proto_init() {
 			}
 		}
 		file_inference_inference_query_proto_msgTypes[165].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryGetDevshardEscrowResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[166].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryGetDevshardHostEpochStatsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[167].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryGetDevshardHostEpochStatsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[168].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceCreditRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[169].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceCreditResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[170].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceScheduledRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[171].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceScheduledResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[172].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceActiveRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[173].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceActiveResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[174].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceStatusRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[175].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceStatusResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[176].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceConcurrencyRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[177].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceConcurrencyResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[178].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceSchedulabilityRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[179].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryMaintenanceSchedulabilityResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[180].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryListClaimRecipientsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[181].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryListClaimRecipientsResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[182].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*QueryDebugStatsResponse_TemporaryTimeStat); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_query_proto_msgTypes[183].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*QueryDebugStatsResponse_TemporaryEpochStat); i {
 			case 0:
 				return &v.state
@@ -89259,7 +98590,7 @@ func file_inference_inference_query_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_inference_inference_query_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   166,
+			NumMessages:   184,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/inference-chain/api/inference/inference/query_grpc.pb.go b/inference-chain/api/inference/inference/query_grpc.pb.go
index aab38f2fa2..e48b1a749b 100644
--- a/inference-chain/api/inference/inference/query_grpc.pb.go
+++ b/inference-chain/api/inference/inference/query_grpc.pb.go
@@ -30,6 +30,7 @@ const (
 	Query_EpochGroupDataAll_FullMethodName                         = "/inference.inference.Query/EpochGroupDataAll"
 	Query_SettleAmount_FullMethodName                              = "/inference.inference.Query/SettleAmount"
 	Query_SettleAmountAll_FullMethodName                           = "/inference.inference.Query/SettleAmountAll"
+	Query_EstimateBitcoinReward_FullMethodName                     = "/inference.inference.Query/EstimateBitcoinReward"
 	Query_EpochGroupValidations_FullMethodName                     = "/inference.inference.Query/EpochGroupValidations"
 	Query_EpochGroupValidationsAll_FullMethodName                  = "/inference.inference.Query/EpochGroupValidationsAll"
 	Query_PocBatchesForStage_FullMethodName                        = "/inference.inference.Query/PocBatchesForStage"
@@ -84,6 +85,7 @@ const (
 	Query_GetAllModelCapacities_FullMethodName                     = "/inference.inference.Query/GetAllModelCapacities"
 	Query_GranteesByMessageType_FullMethodName                     = "/inference.inference.Query/GranteesByMessageType"
 	Query_MLNodeVersion_FullMethodName                             = "/inference.inference.Query/MLNodeVersion"
+	Query_LastUpgradeHeight_FullMethodName                         = "/inference.inference.Query/LastUpgradeHeight"
 	Query_ParticipantAllowList_FullMethodName                      = "/inference.inference.Query/ParticipantAllowList"
 	Query_ExcludedParticipants_FullMethodName                      = "/inference.inference.Query/ExcludedParticipants"
 	Query_ActiveConfirmationPoCEvent_FullMethodName                = "/inference.inference.Query/ActiveConfirmationPoCEvent"
@@ -95,6 +97,13 @@ const (
 	Query_PreservedNodesSnapshot_FullMethodName                    = "/inference.inference.Query/PreservedNodesSnapshot"
 	Query_DevshardHostEpochStats_FullMethodName                    = "/inference.inference.Query/DevshardHostEpochStats"
 	Query_PoCDelegation_FullMethodName                             = "/inference.inference.Query/PoCDelegation"
+	Query_MaintenanceCredit_FullMethodName                         = "/inference.inference.Query/MaintenanceCredit"
+	Query_MaintenanceScheduled_FullMethodName                      = "/inference.inference.Query/MaintenanceScheduled"
+	Query_MaintenanceActive_FullMethodName                         = "/inference.inference.Query/MaintenanceActive"
+	Query_MaintenanceStatus_FullMethodName                         = "/inference.inference.Query/MaintenanceStatus"
+	Query_MaintenanceConcurrency_FullMethodName                    = "/inference.inference.Query/MaintenanceConcurrency"
+	Query_MaintenanceSchedulability_FullMethodName                 = "/inference.inference.Query/MaintenanceSchedulability"
+	Query_ListClaimRecipients_FullMethodName                       = "/inference.inference.Query/ListClaimRecipients"
 )
 
 // QueryClient is the client API for Query service.
@@ -119,6 +128,7 @@ type QueryClient interface {
 	// Queries a list of SettleAmount items.
 	SettleAmount(ctx context.Context, in *QueryGetSettleAmountRequest, opts ...grpc.CallOption) (*QueryGetSettleAmountResponse, error)
 	SettleAmountAll(ctx context.Context, in *QueryAllSettleAmountRequest, opts ...grpc.CallOption) (*QueryAllSettleAmountResponse, error)
+	EstimateBitcoinReward(ctx context.Context, in *QueryEstimateBitcoinRewardRequest, opts ...grpc.CallOption) (*QueryEstimateBitcoinRewardResponse, error)
 	// Queries a list of EpochGroupValidations items.
 	EpochGroupValidations(ctx context.Context, in *QueryGetEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupValidationsResponse, error)
 	EpochGroupValidationsAll(ctx context.Context, in *QueryAllEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupValidationsResponse, error)
@@ -210,6 +220,8 @@ type QueryClient interface {
 	GranteesByMessageType(ctx context.Context, in *QueryGranteesByMessageTypeRequest, opts ...grpc.CallOption) (*QueryGranteesByMessageTypeResponse, error)
 	// Queries the current MLNode version.
 	MLNodeVersion(ctx context.Context, in *QueryGetMLNodeVersionRequest, opts ...grpc.CallOption) (*QueryGetMLNodeVersionResponse, error)
+	// Queries the most recent applied upgrade height.
+	LastUpgradeHeight(ctx context.Context, in *QueryGetLastUpgradeHeightRequest, opts ...grpc.CallOption) (*QueryGetLastUpgradeHeightResponse, error)
 	// Queries the participant allowlist.
 	ParticipantAllowList(ctx context.Context, in *QueryParticipantAllowListRequest, opts ...grpc.CallOption) (*QueryParticipantAllowListResponse, error)
 	// Queries the list of excluded participants for an epoch (0 = current epoch).
@@ -228,6 +240,20 @@ type QueryClient interface {
 	PreservedNodesSnapshot(ctx context.Context, in *QueryPreservedNodesSnapshotRequest, opts ...grpc.CallOption) (*QueryPreservedNodesSnapshotResponse, error)
 	DevshardHostEpochStats(ctx context.Context, in *QueryGetDevshardHostEpochStatsRequest, opts ...grpc.CallOption) (*QueryGetDevshardHostEpochStatsResponse, error)
 	PoCDelegation(ctx context.Context, in *QueryPoCDelegationRequest, opts ...grpc.CallOption) (*QueryPoCDelegationResponse, error)
+	// Queries the maintenance credit balance for a participant.
+	MaintenanceCredit(ctx context.Context, in *QueryMaintenanceCreditRequest, opts ...grpc.CallOption) (*QueryMaintenanceCreditResponse, error)
+	// Queries scheduled maintenance windows for a participant.
+	MaintenanceScheduled(ctx context.Context, in *QueryMaintenanceScheduledRequest, opts ...grpc.CallOption) (*QueryMaintenanceScheduledResponse, error)
+	// Queries all currently active maintenance windows.
+	MaintenanceActive(ctx context.Context, in *QueryMaintenanceActiveRequest, opts ...grpc.CallOption) (*QueryMaintenanceActiveResponse, error)
+	// Queries the full maintenance status for a participant at the current height.
+	MaintenanceStatus(ctx context.Context, in *QueryMaintenanceStatusRequest, opts ...grpc.CallOption) (*QueryMaintenanceStatusResponse, error)
+	// Queries the concurrent reserved participant count and power at a given height.
+	MaintenanceConcurrency(ctx context.Context, in *QueryMaintenanceConcurrencyRequest, opts ...grpc.CallOption) (*QueryMaintenanceConcurrencyResponse, error)
+	// Queries whether a proposed maintenance window is schedulable.
+	MaintenanceSchedulability(ctx context.Context, in *QueryMaintenanceSchedulabilityRequest, opts ...grpc.CallOption) (*QueryMaintenanceSchedulabilityResponse, error)
+	// Lists the scheduled per-epoch claim recipient overrides for a participant.
+	ListClaimRecipients(ctx context.Context, in *QueryListClaimRecipientsRequest, opts ...grpc.CallOption) (*QueryListClaimRecipientsResponse, error)
 }
 
 type queryClient struct {
@@ -337,6 +363,15 @@ func (c *queryClient) SettleAmountAll(ctx context.Context, in *QueryAllSettleAmo
 	return out, nil
 }
 
+func (c *queryClient) EstimateBitcoinReward(ctx context.Context, in *QueryEstimateBitcoinRewardRequest, opts ...grpc.CallOption) (*QueryEstimateBitcoinRewardResponse, error) {
+	out := new(QueryEstimateBitcoinRewardResponse)
+	err := c.cc.Invoke(ctx, Query_EstimateBitcoinReward_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) EpochGroupValidations(ctx context.Context, in *QueryGetEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupValidationsResponse, error) {
 	out := new(QueryGetEpochGroupValidationsResponse)
 	err := c.cc.Invoke(ctx, Query_EpochGroupValidations_FullMethodName, in, out, opts...)
@@ -823,6 +858,15 @@ func (c *queryClient) MLNodeVersion(ctx context.Context, in *QueryGetMLNodeVersi
 	return out, nil
 }
 
+func (c *queryClient) LastUpgradeHeight(ctx context.Context, in *QueryGetLastUpgradeHeightRequest, opts ...grpc.CallOption) (*QueryGetLastUpgradeHeightResponse, error) {
+	out := new(QueryGetLastUpgradeHeightResponse)
+	err := c.cc.Invoke(ctx, Query_LastUpgradeHeight_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) ParticipantAllowList(ctx context.Context, in *QueryParticipantAllowListRequest, opts ...grpc.CallOption) (*QueryParticipantAllowListResponse, error) {
 	out := new(QueryParticipantAllowListResponse)
 	err := c.cc.Invoke(ctx, Query_ParticipantAllowList_FullMethodName, in, out, opts...)
@@ -922,6 +966,69 @@ func (c *queryClient) PoCDelegation(ctx context.Context, in *QueryPoCDelegationR
 	return out, nil
 }
 
+func (c *queryClient) MaintenanceCredit(ctx context.Context, in *QueryMaintenanceCreditRequest, opts ...grpc.CallOption) (*QueryMaintenanceCreditResponse, error) {
+	out := new(QueryMaintenanceCreditResponse)
+	err := c.cc.Invoke(ctx, Query_MaintenanceCredit_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceScheduled(ctx context.Context, in *QueryMaintenanceScheduledRequest, opts ...grpc.CallOption) (*QueryMaintenanceScheduledResponse, error) {
+	out := new(QueryMaintenanceScheduledResponse)
+	err := c.cc.Invoke(ctx, Query_MaintenanceScheduled_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceActive(ctx context.Context, in *QueryMaintenanceActiveRequest, opts ...grpc.CallOption) (*QueryMaintenanceActiveResponse, error) {
+	out := new(QueryMaintenanceActiveResponse)
+	err := c.cc.Invoke(ctx, Query_MaintenanceActive_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceStatus(ctx context.Context, in *QueryMaintenanceStatusRequest, opts ...grpc.CallOption) (*QueryMaintenanceStatusResponse, error) {
+	out := new(QueryMaintenanceStatusResponse)
+	err := c.cc.Invoke(ctx, Query_MaintenanceStatus_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceConcurrency(ctx context.Context, in *QueryMaintenanceConcurrencyRequest, opts ...grpc.CallOption) (*QueryMaintenanceConcurrencyResponse, error) {
+	out := new(QueryMaintenanceConcurrencyResponse)
+	err := c.cc.Invoke(ctx, Query_MaintenanceConcurrency_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceSchedulability(ctx context.Context, in *QueryMaintenanceSchedulabilityRequest, opts ...grpc.CallOption) (*QueryMaintenanceSchedulabilityResponse, error) {
+	out := new(QueryMaintenanceSchedulabilityResponse)
+	err := c.cc.Invoke(ctx, Query_MaintenanceSchedulability_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ListClaimRecipients(ctx context.Context, in *QueryListClaimRecipientsRequest, opts ...grpc.CallOption) (*QueryListClaimRecipientsResponse, error) {
+	out := new(QueryListClaimRecipientsResponse)
+	err := c.cc.Invoke(ctx, Query_ListClaimRecipients_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 // All implementations must embed UnimplementedQueryServer
 // for forward compatibility
@@ -944,6 +1051,7 @@ type QueryServer interface {
 	// Queries a list of SettleAmount items.
 	SettleAmount(context.Context, *QueryGetSettleAmountRequest) (*QueryGetSettleAmountResponse, error)
 	SettleAmountAll(context.Context, *QueryAllSettleAmountRequest) (*QueryAllSettleAmountResponse, error)
+	EstimateBitcoinReward(context.Context, *QueryEstimateBitcoinRewardRequest) (*QueryEstimateBitcoinRewardResponse, error)
 	// Queries a list of EpochGroupValidations items.
 	EpochGroupValidations(context.Context, *QueryGetEpochGroupValidationsRequest) (*QueryGetEpochGroupValidationsResponse, error)
 	EpochGroupValidationsAll(context.Context, *QueryAllEpochGroupValidationsRequest) (*QueryAllEpochGroupValidationsResponse, error)
@@ -1035,6 +1143,8 @@ type QueryServer interface {
 	GranteesByMessageType(context.Context, *QueryGranteesByMessageTypeRequest) (*QueryGranteesByMessageTypeResponse, error)
 	// Queries the current MLNode version.
 	MLNodeVersion(context.Context, *QueryGetMLNodeVersionRequest) (*QueryGetMLNodeVersionResponse, error)
+	// Queries the most recent applied upgrade height.
+	LastUpgradeHeight(context.Context, *QueryGetLastUpgradeHeightRequest) (*QueryGetLastUpgradeHeightResponse, error)
 	// Queries the participant allowlist.
 	ParticipantAllowList(context.Context, *QueryParticipantAllowListRequest) (*QueryParticipantAllowListResponse, error)
 	// Queries the list of excluded participants for an epoch (0 = current epoch).
@@ -1053,6 +1163,20 @@ type QueryServer interface {
 	PreservedNodesSnapshot(context.Context, *QueryPreservedNodesSnapshotRequest) (*QueryPreservedNodesSnapshotResponse, error)
 	DevshardHostEpochStats(context.Context, *QueryGetDevshardHostEpochStatsRequest) (*QueryGetDevshardHostEpochStatsResponse, error)
 	PoCDelegation(context.Context, *QueryPoCDelegationRequest) (*QueryPoCDelegationResponse, error)
+	// Queries the maintenance credit balance for a participant.
+	MaintenanceCredit(context.Context, *QueryMaintenanceCreditRequest) (*QueryMaintenanceCreditResponse, error)
+	// Queries scheduled maintenance windows for a participant.
+	MaintenanceScheduled(context.Context, *QueryMaintenanceScheduledRequest) (*QueryMaintenanceScheduledResponse, error)
+	// Queries all currently active maintenance windows.
+	MaintenanceActive(context.Context, *QueryMaintenanceActiveRequest) (*QueryMaintenanceActiveResponse, error)
+	// Queries the full maintenance status for a participant at the current height.
+	MaintenanceStatus(context.Context, *QueryMaintenanceStatusRequest) (*QueryMaintenanceStatusResponse, error)
+	// Queries the concurrent reserved participant count and power at a given height.
+	MaintenanceConcurrency(context.Context, *QueryMaintenanceConcurrencyRequest) (*QueryMaintenanceConcurrencyResponse, error)
+	// Queries whether a proposed maintenance window is schedulable.
+	MaintenanceSchedulability(context.Context, *QueryMaintenanceSchedulabilityRequest) (*QueryMaintenanceSchedulabilityResponse, error)
+	// Lists the scheduled per-epoch claim recipient overrides for a participant.
+	ListClaimRecipients(context.Context, *QueryListClaimRecipientsRequest) (*QueryListClaimRecipientsResponse, error)
 	mustEmbedUnimplementedQueryServer()
 }
 
@@ -1093,6 +1217,9 @@ func (UnimplementedQueryServer) SettleAmount(context.Context, *QueryGetSettleAmo
 func (UnimplementedQueryServer) SettleAmountAll(context.Context, *QueryAllSettleAmountRequest) (*QueryAllSettleAmountResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SettleAmountAll not implemented")
 }
+func (UnimplementedQueryServer) EstimateBitcoinReward(context.Context, *QueryEstimateBitcoinRewardRequest) (*QueryEstimateBitcoinRewardResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method EstimateBitcoinReward not implemented")
+}
 func (UnimplementedQueryServer) EpochGroupValidations(context.Context, *QueryGetEpochGroupValidationsRequest) (*QueryGetEpochGroupValidationsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method EpochGroupValidations not implemented")
 }
@@ -1255,6 +1382,9 @@ func (UnimplementedQueryServer) GranteesByMessageType(context.Context, *QueryGra
 func (UnimplementedQueryServer) MLNodeVersion(context.Context, *QueryGetMLNodeVersionRequest) (*QueryGetMLNodeVersionResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MLNodeVersion not implemented")
 }
+func (UnimplementedQueryServer) LastUpgradeHeight(context.Context, *QueryGetLastUpgradeHeightRequest) (*QueryGetLastUpgradeHeightResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method LastUpgradeHeight not implemented")
+}
 func (UnimplementedQueryServer) ParticipantAllowList(context.Context, *QueryParticipantAllowListRequest) (*QueryParticipantAllowListResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ParticipantAllowList not implemented")
 }
@@ -1288,6 +1418,27 @@ func (UnimplementedQueryServer) DevshardHostEpochStats(context.Context, *QueryGe
 func (UnimplementedQueryServer) PoCDelegation(context.Context, *QueryPoCDelegationRequest) (*QueryPoCDelegationResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method PoCDelegation not implemented")
 }
+func (UnimplementedQueryServer) MaintenanceCredit(context.Context, *QueryMaintenanceCreditRequest) (*QueryMaintenanceCreditResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceCredit not implemented")
+}
+func (UnimplementedQueryServer) MaintenanceScheduled(context.Context, *QueryMaintenanceScheduledRequest) (*QueryMaintenanceScheduledResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceScheduled not implemented")
+}
+func (UnimplementedQueryServer) MaintenanceActive(context.Context, *QueryMaintenanceActiveRequest) (*QueryMaintenanceActiveResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceActive not implemented")
+}
+func (UnimplementedQueryServer) MaintenanceStatus(context.Context, *QueryMaintenanceStatusRequest) (*QueryMaintenanceStatusResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceStatus not implemented")
+}
+func (UnimplementedQueryServer) MaintenanceConcurrency(context.Context, *QueryMaintenanceConcurrencyRequest) (*QueryMaintenanceConcurrencyResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceConcurrency not implemented")
+}
+func (UnimplementedQueryServer) MaintenanceSchedulability(context.Context, *QueryMaintenanceSchedulabilityRequest) (*QueryMaintenanceSchedulabilityResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceSchedulability not implemented")
+}
+func (UnimplementedQueryServer) ListClaimRecipients(context.Context, *QueryListClaimRecipientsRequest) (*QueryListClaimRecipientsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListClaimRecipients not implemented")
+}
 func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}
 
 // UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
@@ -1499,6 +1650,24 @@ func _Query_SettleAmountAll_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_EstimateBitcoinReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryEstimateBitcoinRewardRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).EstimateBitcoinReward(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_EstimateBitcoinReward_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).EstimateBitcoinReward(ctx, req.(*QueryEstimateBitcoinRewardRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_EpochGroupValidations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryGetEpochGroupValidationsRequest)
 	if err := dec(in); err != nil {
@@ -2471,6 +2640,24 @@ func _Query_MLNodeVersion_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_LastUpgradeHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryGetLastUpgradeHeightRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).LastUpgradeHeight(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_LastUpgradeHeight_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).LastUpgradeHeight(ctx, req.(*QueryGetLastUpgradeHeightRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_ParticipantAllowList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryParticipantAllowListRequest)
 	if err := dec(in); err != nil {
@@ -2669,6 +2856,132 @@ func _Query_PoCDelegation_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_MaintenanceCredit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceCreditRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceCredit(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_MaintenanceCredit_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceCredit(ctx, req.(*QueryMaintenanceCreditRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceScheduled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceScheduledRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceScheduled(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_MaintenanceScheduled_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceScheduled(ctx, req.(*QueryMaintenanceScheduledRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceActive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceActiveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceActive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_MaintenanceActive_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceActive(ctx, req.(*QueryMaintenanceActiveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceStatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceStatus(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_MaintenanceStatus_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceStatus(ctx, req.(*QueryMaintenanceStatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceConcurrency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceConcurrencyRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceConcurrency(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_MaintenanceConcurrency_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceConcurrency(ctx, req.(*QueryMaintenanceConcurrencyRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceSchedulability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceSchedulabilityRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceSchedulability(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_MaintenanceSchedulability_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceSchedulability(ctx, req.(*QueryMaintenanceSchedulabilityRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_ListClaimRecipients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryListClaimRecipientsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).ListClaimRecipients(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Query_ListClaimRecipients_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).ListClaimRecipients(ctx, req.(*QueryListClaimRecipientsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Query_ServiceDesc is the grpc.ServiceDesc for Query service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -2720,6 +3033,10 @@ var Query_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "SettleAmountAll",
 			Handler:    _Query_SettleAmountAll_Handler,
 		},
+		{
+			MethodName: "EstimateBitcoinReward",
+			Handler:    _Query_EstimateBitcoinReward_Handler,
+		},
 		{
 			MethodName: "EpochGroupValidations",
 			Handler:    _Query_EpochGroupValidations_Handler,
@@ -2936,6 +3253,10 @@ var Query_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "MLNodeVersion",
 			Handler:    _Query_MLNodeVersion_Handler,
 		},
+		{
+			MethodName: "LastUpgradeHeight",
+			Handler:    _Query_LastUpgradeHeight_Handler,
+		},
 		{
 			MethodName: "ParticipantAllowList",
 			Handler:    _Query_ParticipantAllowList_Handler,
@@ -2980,6 +3301,34 @@ var Query_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "PoCDelegation",
 			Handler:    _Query_PoCDelegation_Handler,
 		},
+		{
+			MethodName: "MaintenanceCredit",
+			Handler:    _Query_MaintenanceCredit_Handler,
+		},
+		{
+			MethodName: "MaintenanceScheduled",
+			Handler:    _Query_MaintenanceScheduled_Handler,
+		},
+		{
+			MethodName: "MaintenanceActive",
+			Handler:    _Query_MaintenanceActive_Handler,
+		},
+		{
+			MethodName: "MaintenanceStatus",
+			Handler:    _Query_MaintenanceStatus_Handler,
+		},
+		{
+			MethodName: "MaintenanceConcurrency",
+			Handler:    _Query_MaintenanceConcurrency_Handler,
+		},
+		{
+			MethodName: "MaintenanceSchedulability",
+			Handler:    _Query_MaintenanceSchedulability_Handler,
+		},
+		{
+			MethodName: "ListClaimRecipients",
+			Handler:    _Query_ListClaimRecipients_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "inference/inference/query.proto",
diff --git a/inference-chain/api/inference/inference/tx.pulsar.go b/inference-chain/api/inference/inference/tx.pulsar.go
index ab064e135d..b0eec5a932 100644
--- a/inference-chain/api/inference/inference/tx.pulsar.go
+++ b/inference-chain/api/inference/inference/tx.pulsar.go
@@ -10572,128 +10572,79 @@ func (x *fastReflection_MsgClaimRewardsResponse) ProtoMethods() *protoiface.Meth
 	}
 }
 
-var _ protoreflect.List = (*_MsgSubmitPocBatch_4_list)(nil)
+var _ protoreflect.List = (*_MsgSetClaimRecipients_2_list)(nil)
 
-type _MsgSubmitPocBatch_4_list struct {
-	list *[]int64
+type _MsgSetClaimRecipients_2_list struct {
+	list *[]*ClaimRecipientEntry
 }
 
-func (x *_MsgSubmitPocBatch_4_list) Len() int {
+func (x *_MsgSetClaimRecipients_2_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_MsgSubmitPocBatch_4_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfInt64((*x.list)[i])
+func (x *_MsgSetClaimRecipients_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_MsgSubmitPocBatch_4_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Int()
-	concreteValue := valueUnwrapped
+func (x *_MsgSetClaimRecipients_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ClaimRecipientEntry)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_MsgSubmitPocBatch_4_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Int()
-	concreteValue := valueUnwrapped
+func (x *_MsgSetClaimRecipients_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*ClaimRecipientEntry)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_MsgSubmitPocBatch_4_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitPocBatch at list field Nonces as it is not of Message kind"))
-}
-
-func (x *_MsgSubmitPocBatch_4_list) Truncate(n int) {
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgSubmitPocBatch_4_list) NewElement() protoreflect.Value {
-	v := int64(0)
-	return protoreflect.ValueOfInt64(v)
-}
-
-func (x *_MsgSubmitPocBatch_4_list) IsValid() bool {
-	return x.list != nil
-}
-
-var _ protoreflect.List = (*_MsgSubmitPocBatch_5_list)(nil)
-
-type _MsgSubmitPocBatch_5_list struct {
-	list *[]float64
+func (x *_MsgSetClaimRecipients_2_list) AppendMutable() protoreflect.Value {
+	v := new(ClaimRecipientEntry)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_MsgSubmitPocBatch_5_list) Len() int {
-	if x.list == nil {
-		return 0
+func (x *_MsgSetClaimRecipients_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
 	}
-	return len(*x.list)
-}
-
-func (x *_MsgSubmitPocBatch_5_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfFloat64((*x.list)[i])
-}
-
-func (x *_MsgSubmitPocBatch_5_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Float()
-	concreteValue := valueUnwrapped
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgSubmitPocBatch_5_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Float()
-	concreteValue := valueUnwrapped
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgSubmitPocBatch_5_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitPocBatch at list field Dist as it is not of Message kind"))
-}
-
-func (x *_MsgSubmitPocBatch_5_list) Truncate(n int) {
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_MsgSubmitPocBatch_5_list) NewElement() protoreflect.Value {
-	v := float64(0)
-	return protoreflect.ValueOfFloat64(v)
+func (x *_MsgSetClaimRecipients_2_list) NewElement() protoreflect.Value {
+	v := new(ClaimRecipientEntry)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_MsgSubmitPocBatch_5_list) IsValid() bool {
+func (x *_MsgSetClaimRecipients_2_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_MsgSubmitPocBatch                              protoreflect.MessageDescriptor
-	fd_MsgSubmitPocBatch_creator                      protoreflect.FieldDescriptor
-	fd_MsgSubmitPocBatch_poc_stage_start_block_height protoreflect.FieldDescriptor
-	fd_MsgSubmitPocBatch_batch_id                     protoreflect.FieldDescriptor
-	fd_MsgSubmitPocBatch_nonces                       protoreflect.FieldDescriptor
-	fd_MsgSubmitPocBatch_dist                         protoreflect.FieldDescriptor
-	fd_MsgSubmitPocBatch_node_id                      protoreflect.FieldDescriptor
+	md_MsgSetClaimRecipients         protoreflect.MessageDescriptor
+	fd_MsgSetClaimRecipients_creator protoreflect.FieldDescriptor
+	fd_MsgSetClaimRecipients_entries protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitPocBatch = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocBatch")
-	fd_MsgSubmitPocBatch_creator = md_MsgSubmitPocBatch.Fields().ByName("creator")
-	fd_MsgSubmitPocBatch_poc_stage_start_block_height = md_MsgSubmitPocBatch.Fields().ByName("poc_stage_start_block_height")
-	fd_MsgSubmitPocBatch_batch_id = md_MsgSubmitPocBatch.Fields().ByName("batch_id")
-	fd_MsgSubmitPocBatch_nonces = md_MsgSubmitPocBatch.Fields().ByName("nonces")
-	fd_MsgSubmitPocBatch_dist = md_MsgSubmitPocBatch.Fields().ByName("dist")
-	fd_MsgSubmitPocBatch_node_id = md_MsgSubmitPocBatch.Fields().ByName("node_id")
+	md_MsgSetClaimRecipients = File_inference_inference_tx_proto.Messages().ByName("MsgSetClaimRecipients")
+	fd_MsgSetClaimRecipients_creator = md_MsgSetClaimRecipients.Fields().ByName("creator")
+	fd_MsgSetClaimRecipients_entries = md_MsgSetClaimRecipients.Fields().ByName("entries")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitPocBatch)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSetClaimRecipients)(nil)
 
-type fastReflection_MsgSubmitPocBatch MsgSubmitPocBatch
+type fastReflection_MsgSetClaimRecipients MsgSetClaimRecipients
 
-func (x *MsgSubmitPocBatch) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocBatch)(x)
+func (x *MsgSetClaimRecipients) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSetClaimRecipients)(x)
 }
 
-func (x *MsgSubmitPocBatch) slowProtoReflect() protoreflect.Message {
+func (x *MsgSetClaimRecipients) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -10705,43 +10656,43 @@ func (x *MsgSubmitPocBatch) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitPocBatch_messageType fastReflection_MsgSubmitPocBatch_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitPocBatch_messageType{}
+var _fastReflection_MsgSetClaimRecipients_messageType fastReflection_MsgSetClaimRecipients_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSetClaimRecipients_messageType{}
 
-type fastReflection_MsgSubmitPocBatch_messageType struct{}
+type fastReflection_MsgSetClaimRecipients_messageType struct{}
 
-func (x fastReflection_MsgSubmitPocBatch_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocBatch)(nil)
+func (x fastReflection_MsgSetClaimRecipients_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSetClaimRecipients)(nil)
 }
-func (x fastReflection_MsgSubmitPocBatch_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocBatch)
+func (x fastReflection_MsgSetClaimRecipients_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSetClaimRecipients)
 }
-func (x fastReflection_MsgSubmitPocBatch_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocBatch
+func (x fastReflection_MsgSetClaimRecipients_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetClaimRecipients
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitPocBatch) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocBatch
+func (x *fastReflection_MsgSetClaimRecipients) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetClaimRecipients
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitPocBatch) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitPocBatch_messageType
+func (x *fastReflection_MsgSetClaimRecipients) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSetClaimRecipients_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitPocBatch) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocBatch)
+func (x *fastReflection_MsgSetClaimRecipients) New() protoreflect.Message {
+	return new(fastReflection_MsgSetClaimRecipients)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitPocBatch) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitPocBatch)(x)
+func (x *fastReflection_MsgSetClaimRecipients) Interface() protoreflect.ProtoMessage {
+	return (*MsgSetClaimRecipients)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -10749,40 +10700,16 @@ func (x *fastReflection_MsgSubmitPocBatch) Interface() protoreflect.ProtoMessage
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitPocBatch) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSetClaimRecipients) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgSubmitPocBatch_creator, value) {
-			return
-		}
-	}
-	if x.PocStageStartBlockHeight != int64(0) {
-		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_MsgSubmitPocBatch_poc_stage_start_block_height, value) {
-			return
-		}
-	}
-	if x.BatchId != "" {
-		value := protoreflect.ValueOfString(x.BatchId)
-		if !f(fd_MsgSubmitPocBatch_batch_id, value) {
-			return
-		}
-	}
-	if len(x.Nonces) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSubmitPocBatch_4_list{list: &x.Nonces})
-		if !f(fd_MsgSubmitPocBatch_nonces, value) {
+		if !f(fd_MsgSetClaimRecipients_creator, value) {
 			return
 		}
 	}
-	if len(x.Dist) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSubmitPocBatch_5_list{list: &x.Dist})
-		if !f(fd_MsgSubmitPocBatch_dist, value) {
-			return
-		}
-	}
-	if x.NodeId != "" {
-		value := protoreflect.ValueOfString(x.NodeId)
-		if !f(fd_MsgSubmitPocBatch_node_id, value) {
+	if len(x.Entries) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSetClaimRecipients_2_list{list: &x.Entries})
+		if !f(fd_MsgSetClaimRecipients_entries, value) {
 			return
 		}
 	}
@@ -10799,25 +10726,17 @@ func (x *fastReflection_MsgSubmitPocBatch) Range(f func(protoreflect.FieldDescri
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitPocBatch) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSetClaimRecipients) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocBatch.creator":
+	case "inference.inference.MsgSetClaimRecipients.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
-		return x.PocStageStartBlockHeight != int64(0)
-	case "inference.inference.MsgSubmitPocBatch.batch_id":
-		return x.BatchId != ""
-	case "inference.inference.MsgSubmitPocBatch.nonces":
-		return len(x.Nonces) != 0
-	case "inference.inference.MsgSubmitPocBatch.dist":
-		return len(x.Dist) != 0
-	case "inference.inference.MsgSubmitPocBatch.node_id":
-		return x.NodeId != ""
+	case "inference.inference.MsgSetClaimRecipients.entries":
+		return len(x.Entries) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipients"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipients does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10827,25 +10746,17 @@ func (x *fastReflection_MsgSubmitPocBatch) Has(fd protoreflect.FieldDescriptor)
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatch) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSetClaimRecipients) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocBatch.creator":
+	case "inference.inference.MsgSetClaimRecipients.creator":
 		x.Creator = ""
-	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
-		x.PocStageStartBlockHeight = int64(0)
-	case "inference.inference.MsgSubmitPocBatch.batch_id":
-		x.BatchId = ""
-	case "inference.inference.MsgSubmitPocBatch.nonces":
-		x.Nonces = nil
-	case "inference.inference.MsgSubmitPocBatch.dist":
-		x.Dist = nil
-	case "inference.inference.MsgSubmitPocBatch.node_id":
-		x.NodeId = ""
+	case "inference.inference.MsgSetClaimRecipients.entries":
+		x.Entries = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipients"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipients does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10855,37 +10766,22 @@ func (x *fastReflection_MsgSubmitPocBatch) Clear(fd protoreflect.FieldDescriptor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitPocBatch) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetClaimRecipients) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSubmitPocBatch.creator":
+	case "inference.inference.MsgSetClaimRecipients.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
-		value := x.PocStageStartBlockHeight
-		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.MsgSubmitPocBatch.batch_id":
-		value := x.BatchId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSubmitPocBatch.nonces":
-		if len(x.Nonces) == 0 {
-			return protoreflect.ValueOfList(&_MsgSubmitPocBatch_4_list{})
-		}
-		listValue := &_MsgSubmitPocBatch_4_list{list: &x.Nonces}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgSubmitPocBatch.dist":
-		if len(x.Dist) == 0 {
-			return protoreflect.ValueOfList(&_MsgSubmitPocBatch_5_list{})
+	case "inference.inference.MsgSetClaimRecipients.entries":
+		if len(x.Entries) == 0 {
+			return protoreflect.ValueOfList(&_MsgSetClaimRecipients_2_list{})
 		}
-		listValue := &_MsgSubmitPocBatch_5_list{list: &x.Dist}
+		listValue := &_MsgSetClaimRecipients_2_list{list: &x.Entries}
 		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgSubmitPocBatch.node_id":
-		value := x.NodeId
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipients"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipients does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -10899,29 +10795,19 @@ func (x *fastReflection_MsgSubmitPocBatch) Get(descriptor protoreflect.FieldDesc
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatch) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSetClaimRecipients) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocBatch.creator":
+	case "inference.inference.MsgSetClaimRecipients.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
-		x.PocStageStartBlockHeight = value.Int()
-	case "inference.inference.MsgSubmitPocBatch.batch_id":
-		x.BatchId = value.Interface().(string)
-	case "inference.inference.MsgSubmitPocBatch.nonces":
-		lv := value.List()
-		clv := lv.(*_MsgSubmitPocBatch_4_list)
-		x.Nonces = *clv.list
-	case "inference.inference.MsgSubmitPocBatch.dist":
+	case "inference.inference.MsgSetClaimRecipients.entries":
 		lv := value.List()
-		clv := lv.(*_MsgSubmitPocBatch_5_list)
-		x.Dist = *clv.list
-	case "inference.inference.MsgSubmitPocBatch.node_id":
-		x.NodeId = value.Interface().(string)
+		clv := lv.(*_MsgSetClaimRecipients_2_list)
+		x.Entries = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipients"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipients does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -10935,70 +10821,49 @@ func (x *fastReflection_MsgSubmitPocBatch) Set(fd protoreflect.FieldDescriptor,
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatch) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetClaimRecipients) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocBatch.nonces":
-		if x.Nonces == nil {
-			x.Nonces = []int64{}
-		}
-		value := &_MsgSubmitPocBatch_4_list{list: &x.Nonces}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSubmitPocBatch.dist":
-		if x.Dist == nil {
-			x.Dist = []float64{}
+	case "inference.inference.MsgSetClaimRecipients.entries":
+		if x.Entries == nil {
+			x.Entries = []*ClaimRecipientEntry{}
 		}
-		value := &_MsgSubmitPocBatch_5_list{list: &x.Dist}
+		value := &_MsgSetClaimRecipients_2_list{list: &x.Entries}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSubmitPocBatch.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitPocBatch is not mutable"))
-	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgSubmitPocBatch is not mutable"))
-	case "inference.inference.MsgSubmitPocBatch.batch_id":
-		panic(fmt.Errorf("field batch_id of message inference.inference.MsgSubmitPocBatch is not mutable"))
-	case "inference.inference.MsgSubmitPocBatch.node_id":
-		panic(fmt.Errorf("field node_id of message inference.inference.MsgSubmitPocBatch is not mutable"))
+	case "inference.inference.MsgSetClaimRecipients.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgSetClaimRecipients is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipients"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipients does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitPocBatch) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetClaimRecipients) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocBatch.creator":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
-		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.MsgSubmitPocBatch.batch_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSubmitPocBatch.nonces":
-		list := []int64{}
-		return protoreflect.ValueOfList(&_MsgSubmitPocBatch_4_list{list: &list})
-	case "inference.inference.MsgSubmitPocBatch.dist":
-		list := []float64{}
-		return protoreflect.ValueOfList(&_MsgSubmitPocBatch_5_list{list: &list})
-	case "inference.inference.MsgSubmitPocBatch.node_id":
+	case "inference.inference.MsgSetClaimRecipients.creator":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgSetClaimRecipients.entries":
+		list := []*ClaimRecipientEntry{}
+		return protoreflect.ValueOfList(&_MsgSetClaimRecipients_2_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipients"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipients does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitPocBatch) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSetClaimRecipients) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocBatch", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSetClaimRecipients", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -11006,7 +10871,7 @@ func (x *fastReflection_MsgSubmitPocBatch) WhichOneof(d protoreflect.OneofDescri
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitPocBatch) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSetClaimRecipients) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -11017,7 +10882,7 @@ func (x *fastReflection_MsgSubmitPocBatch) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatch) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSetClaimRecipients) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -11029,7 +10894,7 @@ func (x *fastReflection_MsgSubmitPocBatch) SetUnknown(fields protoreflect.RawFie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitPocBatch) IsValid() bool {
+func (x *fastReflection_MsgSetClaimRecipients) IsValid() bool {
 	return x != nil
 }
 
@@ -11039,9 +10904,9 @@ func (x *fastReflection_MsgSubmitPocBatch) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSetClaimRecipients) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitPocBatch)
+		x := input.Message.Interface().(*MsgSetClaimRecipients)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11057,26 +10922,11 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.PocStageStartBlockHeight != 0 {
-			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
-		}
-		l = len(x.BatchId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.Nonces) > 0 {
-			l = 0
-			for _, e := range x.Nonces {
-				l += runtime.Sov(uint64(e))
+		if len(x.Entries) > 0 {
+			for _, e := range x.Entries {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
 			}
-			n += 1 + runtime.Sov(uint64(l)) + l
-		}
-		if len(x.Dist) > 0 {
-			n += 1 + runtime.Sov(uint64(len(x.Dist)*8)) + len(x.Dist)*8
-		}
-		l = len(x.NodeId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -11088,7 +10938,7 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocBatch)
+		x := input.Message.Interface().(*MsgSetClaimRecipients)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11107,55 +10957,21 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.NodeId) > 0 {
-			i -= len(x.NodeId)
-			copy(dAtA[i:], x.NodeId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NodeId)))
-			i--
-			dAtA[i] = 0x32
-		}
-		if len(x.Dist) > 0 {
-			for iNdEx := len(x.Dist) - 1; iNdEx >= 0; iNdEx-- {
-				f1 := math.Float64bits(float64(x.Dist[iNdEx]))
-				i -= 8
-				binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
-			}
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Dist)*8))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.Nonces) > 0 {
-			var pksize3 int
-			for _, num := range x.Nonces {
-				pksize3 += runtime.Sov(uint64(num))
-			}
-			i -= pksize3
-			j2 := i
-			for _, num1 := range x.Nonces {
-				num := uint64(num1)
-				for num >= 1<<7 {
-					dAtA[j2] = uint8(uint64(num)&0x7f | 0x80)
-					num >>= 7
-					j2++
+		if len(x.Entries) > 0 {
+			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Entries[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
 				}
-				dAtA[j2] = uint8(num)
-				j2++
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
 			}
-			i = runtime.EncodeVarint(dAtA, i, uint64(pksize3))
-			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.BatchId) > 0 {
-			i -= len(x.BatchId)
-			copy(dAtA[i:], x.BatchId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BatchId)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if x.PocStageStartBlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
-			i--
-			dAtA[i] = 0x10
 		}
 		if len(x.Creator) > 0 {
 			i -= len(x.Creator)
@@ -11175,7 +10991,7 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocBatch)
+		x := input.Message.Interface().(*MsgSetClaimRecipients)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11207,10 +11023,10 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatch: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetClaimRecipients: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatch: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetClaimRecipients: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -11246,29 +11062,10 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
-				}
-				x.PocStageStartBlockHeight = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.PocStageStartBlockHeight |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BatchId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -11278,194 +11075,34 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.BatchId = string(dAtA[iNdEx:postIndex])
+				x.Entries = append(x.Entries, &ClaimRecipientEntry{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
-			case 4:
-				if wireType == 0 {
-					var v int64
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-						}
-						if iNdEx >= l {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						v |= int64(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					x.Nonces = append(x.Nonces, v)
-				} else if wireType == 2 {
-					var packedLen int
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-						}
-						if iNdEx >= l {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						packedLen |= int(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					if packedLen < 0 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-					}
-					postIndex := iNdEx + packedLen
-					if postIndex < 0 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-					}
-					if postIndex > l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					var elementCount int
-					var count int
-					for _, integer := range dAtA[iNdEx:postIndex] {
-						if integer < 128 {
-							count++
-						}
-					}
-					elementCount = count
-					if elementCount != 0 && len(x.Nonces) == 0 {
-						x.Nonces = make([]int64, 0, elementCount)
-					}
-					for iNdEx < postIndex {
-						var v int64
-						for shift := uint(0); ; shift += 7 {
-							if shift >= 64 {
-								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-							}
-							if iNdEx >= l {
-								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-							}
-							b := dAtA[iNdEx]
-							iNdEx++
-							v |= int64(b&0x7F) << shift
-							if b < 0x80 {
-								break
-							}
-						}
-						x.Nonces = append(x.Nonces, v)
-					}
-				} else {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonces", wireType)
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
-			case 5:
-				if wireType == 1 {
-					var v uint64
-					if (iNdEx + 8) > l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-					iNdEx += 8
-					v2 := float64(math.Float64frombits(v))
-					x.Dist = append(x.Dist, v2)
-				} else if wireType == 2 {
-					var packedLen int
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-						}
-						if iNdEx >= l {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						packedLen |= int(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					if packedLen < 0 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-					}
-					postIndex := iNdEx + packedLen
-					if postIndex < 0 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-					}
-					if postIndex > l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					var elementCount int
-					elementCount = packedLen / 8
-					if elementCount != 0 && len(x.Dist) == 0 {
-						x.Dist = make([]float64, 0, elementCount)
-					}
-					for iNdEx < postIndex {
-						var v uint64
-						if (iNdEx + 8) > l {
-							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-						}
-						v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-						iNdEx += 8
-						v2 := float64(math.Float64frombits(v))
-						x.Dist = append(x.Dist, v2)
-					}
-				} else {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Dist", wireType)
-				}
-			case 6:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.NodeId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if (iNdEx + skippy) > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
@@ -11494,23 +11131,23 @@ func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 }
 
 var (
-	md_MsgSubmitPocBatchResponse protoreflect.MessageDescriptor
+	md_MsgSetClaimRecipientsResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitPocBatchResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocBatchResponse")
+	md_MsgSetClaimRecipientsResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSetClaimRecipientsResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitPocBatchResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSetClaimRecipientsResponse)(nil)
 
-type fastReflection_MsgSubmitPocBatchResponse MsgSubmitPocBatchResponse
+type fastReflection_MsgSetClaimRecipientsResponse MsgSetClaimRecipientsResponse
 
-func (x *MsgSubmitPocBatchResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocBatchResponse)(x)
+func (x *MsgSetClaimRecipientsResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSetClaimRecipientsResponse)(x)
 }
 
-func (x *MsgSubmitPocBatchResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgSetClaimRecipientsResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -11522,43 +11159,43 @@ func (x *MsgSubmitPocBatchResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitPocBatchResponse_messageType fastReflection_MsgSubmitPocBatchResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitPocBatchResponse_messageType{}
+var _fastReflection_MsgSetClaimRecipientsResponse_messageType fastReflection_MsgSetClaimRecipientsResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSetClaimRecipientsResponse_messageType{}
 
-type fastReflection_MsgSubmitPocBatchResponse_messageType struct{}
+type fastReflection_MsgSetClaimRecipientsResponse_messageType struct{}
 
-func (x fastReflection_MsgSubmitPocBatchResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocBatchResponse)(nil)
+func (x fastReflection_MsgSetClaimRecipientsResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSetClaimRecipientsResponse)(nil)
 }
-func (x fastReflection_MsgSubmitPocBatchResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocBatchResponse)
+func (x fastReflection_MsgSetClaimRecipientsResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSetClaimRecipientsResponse)
 }
-func (x fastReflection_MsgSubmitPocBatchResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocBatchResponse
+func (x fastReflection_MsgSetClaimRecipientsResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetClaimRecipientsResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocBatchResponse
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetClaimRecipientsResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitPocBatchResponse_messageType
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSetClaimRecipientsResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitPocBatchResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocBatchResponse)
+func (x *fastReflection_MsgSetClaimRecipientsResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSetClaimRecipientsResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitPocBatchResponse)(x)
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSetClaimRecipientsResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -11566,7 +11203,7 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) Interface() protoreflect.Prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -11580,13 +11217,13 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) Range(f func(protoreflect.Fie
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipientsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipientsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11596,13 +11233,13 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) Has(fd protoreflect.FieldDesc
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipientsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipientsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11612,13 +11249,13 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) Clear(fd protoreflect.FieldDe
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipientsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipientsResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -11632,13 +11269,13 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) Get(descriptor protoreflect.F
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipientsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipientsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -11652,36 +11289,36 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) Set(fd protoreflect.FieldDesc
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatchResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipientsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipientsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitPocBatchResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetClaimRecipientsResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetClaimRecipientsResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitPocBatchResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocBatchResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSetClaimRecipientsResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -11689,7 +11326,7 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) WhichOneof(d protoreflect.One
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitPocBatchResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -11700,7 +11337,7 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) GetUnknown() protoreflect.Raw
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocBatchResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -11712,7 +11349,7 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) SetUnknown(fields protoreflec
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitPocBatchResponse) IsValid() bool {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -11722,9 +11359,9 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitPocBatchResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSetClaimRecipientsResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitPocBatchResponse)
+		x := input.Message.Interface().(*MsgSetClaimRecipientsResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11746,7 +11383,7 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) ProtoMethods() *protoiface.Me
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocBatchResponse)
+		x := input.Message.Interface().(*MsgSetClaimRecipientsResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11776,7 +11413,7 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) ProtoMethods() *protoiface.Me
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocBatchResponse)
+		x := input.Message.Interface().(*MsgSetClaimRecipientsResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -11808,10 +11445,10 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) ProtoMethods() *protoiface.Me
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatchResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetClaimRecipientsResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetClaimRecipientsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -11849,81 +11486,128 @@ func (x *fastReflection_MsgSubmitPocBatchResponse) ProtoMethods() *protoiface.Me
 	}
 }
 
-var _ protoreflect.List = (*_MsgSubmitPocValidationsV2_3_list)(nil)
+var _ protoreflect.List = (*_MsgSubmitPocBatch_4_list)(nil)
 
-type _MsgSubmitPocValidationsV2_3_list struct {
-	list *[]*PoCValidationEntryV2
+type _MsgSubmitPocBatch_4_list struct {
+	list *[]int64
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) Len() int {
+func (x *_MsgSubmitPocBatch_4_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+func (x *_MsgSubmitPocBatch_4_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfInt64((*x.list)[i])
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationEntryV2)
+func (x *_MsgSubmitPocBatch_4_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Int()
+	concreteValue := valueUnwrapped
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCValidationEntryV2)
+func (x *_MsgSubmitPocBatch_4_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Int()
+	concreteValue := valueUnwrapped
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) AppendMutable() protoreflect.Value {
-	v := new(PoCValidationEntryV2)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
+func (x *_MsgSubmitPocBatch_4_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitPocBatch at list field Nonces as it is not of Message kind"))
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
+func (x *_MsgSubmitPocBatch_4_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitPocBatch_4_list) NewElement() protoreflect.Value {
+	v := int64(0)
+	return protoreflect.ValueOfInt64(v)
+}
+
+func (x *_MsgSubmitPocBatch_4_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_MsgSubmitPocBatch_5_list)(nil)
+
+type _MsgSubmitPocBatch_5_list struct {
+	list *[]float64
+}
+
+func (x *_MsgSubmitPocBatch_5_list) Len() int {
+	if x.list == nil {
+		return 0
 	}
+	return len(*x.list)
+}
+
+func (x *_MsgSubmitPocBatch_5_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfFloat64((*x.list)[i])
+}
+
+func (x *_MsgSubmitPocBatch_5_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Float()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitPocBatch_5_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Float()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitPocBatch_5_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message MsgSubmitPocBatch at list field Dist as it is not of Message kind"))
+}
+
+func (x *_MsgSubmitPocBatch_5_list) Truncate(n int) {
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) NewElement() protoreflect.Value {
-	v := new(PoCValidationEntryV2)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
+func (x *_MsgSubmitPocBatch_5_list) NewElement() protoreflect.Value {
+	v := float64(0)
+	return protoreflect.ValueOfFloat64(v)
 }
 
-func (x *_MsgSubmitPocValidationsV2_3_list) IsValid() bool {
+func (x *_MsgSubmitPocBatch_5_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_MsgSubmitPocValidationsV2                              protoreflect.MessageDescriptor
-	fd_MsgSubmitPocValidationsV2_creator                      protoreflect.FieldDescriptor
-	fd_MsgSubmitPocValidationsV2_poc_stage_start_block_height protoreflect.FieldDescriptor
-	fd_MsgSubmitPocValidationsV2_validations                  protoreflect.FieldDescriptor
+	md_MsgSubmitPocBatch                              protoreflect.MessageDescriptor
+	fd_MsgSubmitPocBatch_creator                      protoreflect.FieldDescriptor
+	fd_MsgSubmitPocBatch_poc_stage_start_block_height protoreflect.FieldDescriptor
+	fd_MsgSubmitPocBatch_batch_id                     protoreflect.FieldDescriptor
+	fd_MsgSubmitPocBatch_nonces                       protoreflect.FieldDescriptor
+	fd_MsgSubmitPocBatch_dist                         protoreflect.FieldDescriptor
+	fd_MsgSubmitPocBatch_node_id                      protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitPocValidationsV2 = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocValidationsV2")
-	fd_MsgSubmitPocValidationsV2_creator = md_MsgSubmitPocValidationsV2.Fields().ByName("creator")
-	fd_MsgSubmitPocValidationsV2_poc_stage_start_block_height = md_MsgSubmitPocValidationsV2.Fields().ByName("poc_stage_start_block_height")
-	fd_MsgSubmitPocValidationsV2_validations = md_MsgSubmitPocValidationsV2.Fields().ByName("validations")
+	md_MsgSubmitPocBatch = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocBatch")
+	fd_MsgSubmitPocBatch_creator = md_MsgSubmitPocBatch.Fields().ByName("creator")
+	fd_MsgSubmitPocBatch_poc_stage_start_block_height = md_MsgSubmitPocBatch.Fields().ByName("poc_stage_start_block_height")
+	fd_MsgSubmitPocBatch_batch_id = md_MsgSubmitPocBatch.Fields().ByName("batch_id")
+	fd_MsgSubmitPocBatch_nonces = md_MsgSubmitPocBatch.Fields().ByName("nonces")
+	fd_MsgSubmitPocBatch_dist = md_MsgSubmitPocBatch.Fields().ByName("dist")
+	fd_MsgSubmitPocBatch_node_id = md_MsgSubmitPocBatch.Fields().ByName("node_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitPocValidationsV2)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitPocBatch)(nil)
 
-type fastReflection_MsgSubmitPocValidationsV2 MsgSubmitPocValidationsV2
+type fastReflection_MsgSubmitPocBatch MsgSubmitPocBatch
 
-func (x *MsgSubmitPocValidationsV2) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocValidationsV2)(x)
+func (x *MsgSubmitPocBatch) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocBatch)(x)
 }
 
-func (x *MsgSubmitPocValidationsV2) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitPocBatch) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -11935,43 +11619,43 @@ func (x *MsgSubmitPocValidationsV2) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitPocValidationsV2_messageType fastReflection_MsgSubmitPocValidationsV2_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitPocValidationsV2_messageType{}
+var _fastReflection_MsgSubmitPocBatch_messageType fastReflection_MsgSubmitPocBatch_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitPocBatch_messageType{}
 
-type fastReflection_MsgSubmitPocValidationsV2_messageType struct{}
+type fastReflection_MsgSubmitPocBatch_messageType struct{}
 
-func (x fastReflection_MsgSubmitPocValidationsV2_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocValidationsV2)(nil)
+func (x fastReflection_MsgSubmitPocBatch_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocBatch)(nil)
 }
-func (x fastReflection_MsgSubmitPocValidationsV2_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocValidationsV2)
+func (x fastReflection_MsgSubmitPocBatch_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocBatch)
 }
-func (x fastReflection_MsgSubmitPocValidationsV2_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocValidationsV2
+func (x fastReflection_MsgSubmitPocBatch_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocBatch
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocValidationsV2
+func (x *fastReflection_MsgSubmitPocBatch) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocBatch
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitPocValidationsV2_messageType
+func (x *fastReflection_MsgSubmitPocBatch) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitPocBatch_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitPocValidationsV2) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocValidationsV2)
+func (x *fastReflection_MsgSubmitPocBatch) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocBatch)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitPocValidationsV2)(x)
+func (x *fastReflection_MsgSubmitPocBatch) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitPocBatch)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -11979,22 +11663,40 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) Interface() protoreflect.Prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitPocBatch) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgSubmitPocValidationsV2_creator, value) {
+		if !f(fd_MsgSubmitPocBatch_creator, value) {
 			return
 		}
 	}
 	if x.PocStageStartBlockHeight != int64(0) {
 		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_MsgSubmitPocValidationsV2_poc_stage_start_block_height, value) {
+		if !f(fd_MsgSubmitPocBatch_poc_stage_start_block_height, value) {
 			return
 		}
 	}
-	if len(x.Validations) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSubmitPocValidationsV2_3_list{list: &x.Validations})
-		if !f(fd_MsgSubmitPocValidationsV2_validations, value) {
+	if x.BatchId != "" {
+		value := protoreflect.ValueOfString(x.BatchId)
+		if !f(fd_MsgSubmitPocBatch_batch_id, value) {
+			return
+		}
+	}
+	if len(x.Nonces) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSubmitPocBatch_4_list{list: &x.Nonces})
+		if !f(fd_MsgSubmitPocBatch_nonces, value) {
+			return
+		}
+	}
+	if len(x.Dist) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSubmitPocBatch_5_list{list: &x.Dist})
+		if !f(fd_MsgSubmitPocBatch_dist, value) {
+			return
+		}
+	}
+	if x.NodeId != "" {
+		value := protoreflect.ValueOfString(x.NodeId)
+		if !f(fd_MsgSubmitPocBatch_node_id, value) {
 			return
 		}
 	}
@@ -12011,19 +11713,25 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) Range(f func(protoreflect.Fie
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitPocBatch) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocValidationsV2.creator":
+	case "inference.inference.MsgSubmitPocBatch.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
 		return x.PocStageStartBlockHeight != int64(0)
-	case "inference.inference.MsgSubmitPocValidationsV2.validations":
-		return len(x.Validations) != 0
+	case "inference.inference.MsgSubmitPocBatch.batch_id":
+		return x.BatchId != ""
+	case "inference.inference.MsgSubmitPocBatch.nonces":
+		return len(x.Nonces) != 0
+	case "inference.inference.MsgSubmitPocBatch.dist":
+		return len(x.Dist) != 0
+	case "inference.inference.MsgSubmitPocBatch.node_id":
+		return x.NodeId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12033,19 +11741,25 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) Has(fd protoreflect.FieldDesc
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitPocBatch) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocValidationsV2.creator":
+	case "inference.inference.MsgSubmitPocBatch.creator":
 		x.Creator = ""
-	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = int64(0)
-	case "inference.inference.MsgSubmitPocValidationsV2.validations":
-		x.Validations = nil
+	case "inference.inference.MsgSubmitPocBatch.batch_id":
+		x.BatchId = ""
+	case "inference.inference.MsgSubmitPocBatch.nonces":
+		x.Nonces = nil
+	case "inference.inference.MsgSubmitPocBatch.dist":
+		x.Dist = nil
+	case "inference.inference.MsgSubmitPocBatch.node_id":
+		x.NodeId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12055,25 +11769,37 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) Clear(fd protoreflect.FieldDe
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocBatch) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSubmitPocValidationsV2.creator":
+	case "inference.inference.MsgSubmitPocBatch.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
 		value := x.PocStageStartBlockHeight
 		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.MsgSubmitPocValidationsV2.validations":
-		if len(x.Validations) == 0 {
-			return protoreflect.ValueOfList(&_MsgSubmitPocValidationsV2_3_list{})
+	case "inference.inference.MsgSubmitPocBatch.batch_id":
+		value := x.BatchId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgSubmitPocBatch.nonces":
+		if len(x.Nonces) == 0 {
+			return protoreflect.ValueOfList(&_MsgSubmitPocBatch_4_list{})
 		}
-		listValue := &_MsgSubmitPocValidationsV2_3_list{list: &x.Validations}
+		listValue := &_MsgSubmitPocBatch_4_list{list: &x.Nonces}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgSubmitPocBatch.dist":
+		if len(x.Dist) == 0 {
+			return protoreflect.ValueOfList(&_MsgSubmitPocBatch_5_list{})
+		}
+		listValue := &_MsgSubmitPocBatch_5_list{list: &x.Dist}
 		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgSubmitPocBatch.node_id":
+		value := x.NodeId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -12087,21 +11813,29 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) Get(descriptor protoreflect.F
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitPocBatch) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocValidationsV2.creator":
+	case "inference.inference.MsgSubmitPocBatch.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = value.Int()
-	case "inference.inference.MsgSubmitPocValidationsV2.validations":
+	case "inference.inference.MsgSubmitPocBatch.batch_id":
+		x.BatchId = value.Interface().(string)
+	case "inference.inference.MsgSubmitPocBatch.nonces":
 		lv := value.List()
-		clv := lv.(*_MsgSubmitPocValidationsV2_3_list)
-		x.Validations = *clv.list
+		clv := lv.(*_MsgSubmitPocBatch_4_list)
+		x.Nonces = *clv.list
+	case "inference.inference.MsgSubmitPocBatch.dist":
+		lv := value.List()
+		clv := lv.(*_MsgSubmitPocBatch_5_list)
+		x.Dist = *clv.list
+	case "inference.inference.MsgSubmitPocBatch.node_id":
+		x.NodeId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12115,53 +11849,70 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) Set(fd protoreflect.FieldDesc
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocBatch) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocValidationsV2.validations":
-		if x.Validations == nil {
-			x.Validations = []*PoCValidationEntryV2{}
+	case "inference.inference.MsgSubmitPocBatch.nonces":
+		if x.Nonces == nil {
+			x.Nonces = []int64{}
 		}
-		value := &_MsgSubmitPocValidationsV2_3_list{list: &x.Validations}
+		value := &_MsgSubmitPocBatch_4_list{list: &x.Nonces}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSubmitPocValidationsV2.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitPocValidationsV2 is not mutable"))
-	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgSubmitPocValidationsV2 is not mutable"))
+	case "inference.inference.MsgSubmitPocBatch.dist":
+		if x.Dist == nil {
+			x.Dist = []float64{}
+		}
+		value := &_MsgSubmitPocBatch_5_list{list: &x.Dist}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgSubmitPocBatch.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitPocBatch is not mutable"))
+	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgSubmitPocBatch is not mutable"))
+	case "inference.inference.MsgSubmitPocBatch.batch_id":
+		panic(fmt.Errorf("field batch_id of message inference.inference.MsgSubmitPocBatch is not mutable"))
+	case "inference.inference.MsgSubmitPocBatch.node_id":
+		panic(fmt.Errorf("field node_id of message inference.inference.MsgSubmitPocBatch is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitPocValidationsV2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocBatch) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitPocValidationsV2.creator":
+	case "inference.inference.MsgSubmitPocBatch.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocBatch.poc_stage_start_block_height":
 		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.MsgSubmitPocValidationsV2.validations":
-		list := []*PoCValidationEntryV2{}
-		return protoreflect.ValueOfList(&_MsgSubmitPocValidationsV2_3_list{list: &list})
+	case "inference.inference.MsgSubmitPocBatch.batch_id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgSubmitPocBatch.nonces":
+		list := []int64{}
+		return protoreflect.ValueOfList(&_MsgSubmitPocBatch_4_list{list: &list})
+	case "inference.inference.MsgSubmitPocBatch.dist":
+		list := []float64{}
+		return protoreflect.ValueOfList(&_MsgSubmitPocBatch_5_list{list: &list})
+	case "inference.inference.MsgSubmitPocBatch.node_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatch"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatch does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitPocValidationsV2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitPocBatch) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocValidationsV2", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocBatch", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -12169,7 +11920,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) WhichOneof(d protoreflect.One
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitPocValidationsV2) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitPocBatch) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -12180,7 +11931,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) GetUnknown() protoreflect.Raw
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitPocBatch) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -12192,7 +11943,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) SetUnknown(fields protoreflec
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitPocValidationsV2) IsValid() bool {
+func (x *fastReflection_MsgSubmitPocBatch) IsValid() bool {
 	return x != nil
 }
 
@@ -12202,9 +11953,9 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitPocBatch) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitPocValidationsV2)
+		x := input.Message.Interface().(*MsgSubmitPocBatch)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12223,11 +11974,23 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 		if x.PocStageStartBlockHeight != 0 {
 			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
-		if len(x.Validations) > 0 {
-			for _, e := range x.Validations {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
+		l = len(x.BatchId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Nonces) > 0 {
+			l = 0
+			for _, e := range x.Nonces {
+				l += runtime.Sov(uint64(e))
 			}
+			n += 1 + runtime.Sov(uint64(l)) + l
+		}
+		if len(x.Dist) > 0 {
+			n += 1 + runtime.Sov(uint64(len(x.Dist)*8)) + len(x.Dist)*8
+		}
+		l = len(x.NodeId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -12239,7 +12002,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocValidationsV2)
+		x := input.Message.Interface().(*MsgSubmitPocBatch)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12258,47 +12021,76 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Validations) > 0 {
-			for iNdEx := len(x.Validations) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Validations[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x1a
-			}
-		}
-		if x.PocStageStartBlockHeight != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
+		if len(x.NodeId) > 0 {
+			i -= len(x.NodeId)
+			copy(dAtA[i:], x.NodeId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NodeId)))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x32
 		}
-		if len(x.Creator) > 0 {
-			i -= len(x.Creator)
-			copy(dAtA[i:], x.Creator)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+		if len(x.Dist) > 0 {
+			for iNdEx := len(x.Dist) - 1; iNdEx >= 0; iNdEx-- {
+				f1 := math.Float64bits(float64(x.Dist[iNdEx]))
+				i -= 8
+				binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
+			}
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Dist)*8))
 			i--
-			dAtA[i] = 0xa
-		}
-		if input.Buf != nil {
-			input.Buf = append(input.Buf, dAtA...)
-		} else {
-			input.Buf = dAtA
+			dAtA[i] = 0x2a
 		}
-		return protoiface.MarshalOutput{
-			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-			Buf:               input.Buf,
-		}, nil
-	}
-	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocValidationsV2)
-		if x == nil {
+		if len(x.Nonces) > 0 {
+			var pksize3 int
+			for _, num := range x.Nonces {
+				pksize3 += runtime.Sov(uint64(num))
+			}
+			i -= pksize3
+			j2 := i
+			for _, num1 := range x.Nonces {
+				num := uint64(num1)
+				for num >= 1<<7 {
+					dAtA[j2] = uint8(uint64(num)&0x7f | 0x80)
+					num >>= 7
+					j2++
+				}
+				dAtA[j2] = uint8(num)
+				j2++
+			}
+			i = runtime.EncodeVarint(dAtA, i, uint64(pksize3))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.BatchId) > 0 {
+			i -= len(x.BatchId)
+			copy(dAtA[i:], x.BatchId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BatchId)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.PocStageStartBlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgSubmitPocBatch)
+		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
 				Flags:             input.Flags,
@@ -12329,10 +12121,10 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatch: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatch: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -12388,9 +12180,9 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 				}
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validations", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BatchId", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -12400,25 +12192,185 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Validations = append(x.Validations, &PoCValidationEntryV2{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validations[len(x.Validations)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.BatchId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType == 0 {
+					var v int64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= int64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					x.Nonces = append(x.Nonces, v)
+				} else if wireType == 2 {
+					var packedLen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						packedLen |= int(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					if packedLen < 0 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+					}
+					postIndex := iNdEx + packedLen
+					if postIndex < 0 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+					}
+					if postIndex > l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					var elementCount int
+					var count int
+					for _, integer := range dAtA[iNdEx:postIndex] {
+						if integer < 128 {
+							count++
+						}
+					}
+					elementCount = count
+					if elementCount != 0 && len(x.Nonces) == 0 {
+						x.Nonces = make([]int64, 0, elementCount)
+					}
+					for iNdEx < postIndex {
+						var v int64
+						for shift := uint(0); ; shift += 7 {
+							if shift >= 64 {
+								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+							}
+							if iNdEx >= l {
+								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+							}
+							b := dAtA[iNdEx]
+							iNdEx++
+							v |= int64(b&0x7F) << shift
+							if b < 0x80 {
+								break
+							}
+						}
+						x.Nonces = append(x.Nonces, v)
+					}
+				} else {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonces", wireType)
+				}
+			case 5:
+				if wireType == 1 {
+					var v uint64
+					if (iNdEx + 8) > l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+					iNdEx += 8
+					v2 := float64(math.Float64frombits(v))
+					x.Dist = append(x.Dist, v2)
+				} else if wireType == 2 {
+					var packedLen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						packedLen |= int(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					if packedLen < 0 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+					}
+					postIndex := iNdEx + packedLen
+					if postIndex < 0 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+					}
+					if postIndex > l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					var elementCount int
+					elementCount = packedLen / 8
+					if elementCount != 0 && len(x.Dist) == 0 {
+						x.Dist = make([]float64, 0, elementCount)
+					}
+					for iNdEx < postIndex {
+						var v uint64
+						if (iNdEx + 8) > l {
+							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+						}
+						v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+						iNdEx += 8
+						v2 := float64(math.Float64frombits(v))
+						x.Dist = append(x.Dist, v2)
+					}
+				} else {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Dist", wireType)
+				}
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
+				x.NodeId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -12456,23 +12408,23 @@ func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Me
 }
 
 var (
-	md_MsgSubmitPocValidationsV2Response protoreflect.MessageDescriptor
+	md_MsgSubmitPocBatchResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitPocValidationsV2Response = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocValidationsV2Response")
+	md_MsgSubmitPocBatchResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocBatchResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitPocValidationsV2Response)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitPocBatchResponse)(nil)
 
-type fastReflection_MsgSubmitPocValidationsV2Response MsgSubmitPocValidationsV2Response
+type fastReflection_MsgSubmitPocBatchResponse MsgSubmitPocBatchResponse
 
-func (x *MsgSubmitPocValidationsV2Response) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocValidationsV2Response)(x)
+func (x *MsgSubmitPocBatchResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocBatchResponse)(x)
 }
 
-func (x *MsgSubmitPocValidationsV2Response) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitPocBatchResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[21]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -12484,43 +12436,43 @@ func (x *MsgSubmitPocValidationsV2Response) slowProtoReflect() protoreflect.Mess
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitPocValidationsV2Response_messageType fastReflection_MsgSubmitPocValidationsV2Response_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitPocValidationsV2Response_messageType{}
+var _fastReflection_MsgSubmitPocBatchResponse_messageType fastReflection_MsgSubmitPocBatchResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitPocBatchResponse_messageType{}
 
-type fastReflection_MsgSubmitPocValidationsV2Response_messageType struct{}
+type fastReflection_MsgSubmitPocBatchResponse_messageType struct{}
 
-func (x fastReflection_MsgSubmitPocValidationsV2Response_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitPocValidationsV2Response)(nil)
+func (x fastReflection_MsgSubmitPocBatchResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocBatchResponse)(nil)
 }
-func (x fastReflection_MsgSubmitPocValidationsV2Response_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocValidationsV2Response)
+func (x fastReflection_MsgSubmitPocBatchResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocBatchResponse)
 }
-func (x fastReflection_MsgSubmitPocValidationsV2Response_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocValidationsV2Response
+func (x fastReflection_MsgSubmitPocBatchResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocBatchResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitPocValidationsV2Response
+func (x *fastReflection_MsgSubmitPocBatchResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocBatchResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitPocValidationsV2Response_messageType
+func (x *fastReflection_MsgSubmitPocBatchResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitPocBatchResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitPocValidationsV2Response)
+func (x *fastReflection_MsgSubmitPocBatchResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocBatchResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitPocValidationsV2Response)(x)
+func (x *fastReflection_MsgSubmitPocBatchResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitPocBatchResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -12528,7 +12480,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) Interface() protorefl
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitPocBatchResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -12542,13 +12494,13 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) Range(f func(protoref
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitPocBatchResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12558,13 +12510,13 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) Has(fd protoreflect.F
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitPocBatchResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12574,13 +12526,13 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) Clear(fd protoreflect
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocBatchResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -12594,13 +12546,13 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) Get(descriptor protor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitPocBatchResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -12614,36 +12566,36 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) Set(fd protoreflect.F
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocBatchResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocBatchResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocBatchResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocBatchResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitPocBatchResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocValidationsV2Response", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocBatchResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -12651,7 +12603,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) WhichOneof(d protoref
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitPocBatchResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -12662,7 +12614,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) GetUnknown() protoref
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitPocBatchResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -12674,7 +12626,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) SetUnknown(fields pro
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) IsValid() bool {
+func (x *fastReflection_MsgSubmitPocBatchResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -12684,9 +12636,9 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitPocValidationsV2Response) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitPocBatchResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitPocValidationsV2Response)
+		x := input.Message.Interface().(*MsgSubmitPocBatchResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12708,7 +12660,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) ProtoMethods() *proto
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocValidationsV2Response)
+		x := input.Message.Interface().(*MsgSubmitPocBatchResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12738,7 +12690,7 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) ProtoMethods() *proto
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitPocValidationsV2Response)
+		x := input.Message.Interface().(*MsgSubmitPocBatchResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -12770,10 +12722,10 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) ProtoMethods() *proto
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2Response: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatchResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2Response: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -12811,85 +12763,81 @@ func (x *fastReflection_MsgSubmitPocValidationsV2Response) ProtoMethods() *proto
 	}
 }
 
-var _ protoreflect.List = (*_MsgPoCV2StoreCommit_5_list)(nil)
+var _ protoreflect.List = (*_MsgSubmitPocValidationsV2_3_list)(nil)
 
-type _MsgPoCV2StoreCommit_5_list struct {
-	list *[]*PoCV2CommitEntry
+type _MsgSubmitPocValidationsV2_3_list struct {
+	list *[]*PoCValidationEntryV2
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) Len() int {
+func (x *_MsgSubmitPocValidationsV2_3_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) Get(i int) protoreflect.Value {
+func (x *_MsgSubmitPocValidationsV2_3_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) Set(i int, value protoreflect.Value) {
+func (x *_MsgSubmitPocValidationsV2_3_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCV2CommitEntry)
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationEntryV2)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) Append(value protoreflect.Value) {
+func (x *_MsgSubmitPocValidationsV2_3_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*PoCV2CommitEntry)
+	concreteValue := valueUnwrapped.Interface().(*PoCValidationEntryV2)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) AppendMutable() protoreflect.Value {
-	v := new(PoCV2CommitEntry)
+func (x *_MsgSubmitPocValidationsV2_3_list) AppendMutable() protoreflect.Value {
+	v := new(PoCValidationEntryV2)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) Truncate(n int) {
+func (x *_MsgSubmitPocValidationsV2_3_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) NewElement() protoreflect.Value {
-	v := new(PoCV2CommitEntry)
+func (x *_MsgSubmitPocValidationsV2_3_list) NewElement() protoreflect.Value {
+	v := new(PoCValidationEntryV2)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_MsgPoCV2StoreCommit_5_list) IsValid() bool {
+func (x *_MsgSubmitPocValidationsV2_3_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_MsgPoCV2StoreCommit                              protoreflect.MessageDescriptor
-	fd_MsgPoCV2StoreCommit_creator                      protoreflect.FieldDescriptor
-	fd_MsgPoCV2StoreCommit_poc_stage_start_block_height protoreflect.FieldDescriptor
-	fd_MsgPoCV2StoreCommit_count                        protoreflect.FieldDescriptor
-	fd_MsgPoCV2StoreCommit_root_hash                    protoreflect.FieldDescriptor
-	fd_MsgPoCV2StoreCommit_entries                      protoreflect.FieldDescriptor
+	md_MsgSubmitPocValidationsV2                              protoreflect.MessageDescriptor
+	fd_MsgSubmitPocValidationsV2_creator                      protoreflect.FieldDescriptor
+	fd_MsgSubmitPocValidationsV2_poc_stage_start_block_height protoreflect.FieldDescriptor
+	fd_MsgSubmitPocValidationsV2_validations                  protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgPoCV2StoreCommit = File_inference_inference_tx_proto.Messages().ByName("MsgPoCV2StoreCommit")
-	fd_MsgPoCV2StoreCommit_creator = md_MsgPoCV2StoreCommit.Fields().ByName("creator")
-	fd_MsgPoCV2StoreCommit_poc_stage_start_block_height = md_MsgPoCV2StoreCommit.Fields().ByName("poc_stage_start_block_height")
-	fd_MsgPoCV2StoreCommit_count = md_MsgPoCV2StoreCommit.Fields().ByName("count")
-	fd_MsgPoCV2StoreCommit_root_hash = md_MsgPoCV2StoreCommit.Fields().ByName("root_hash")
-	fd_MsgPoCV2StoreCommit_entries = md_MsgPoCV2StoreCommit.Fields().ByName("entries")
+	md_MsgSubmitPocValidationsV2 = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocValidationsV2")
+	fd_MsgSubmitPocValidationsV2_creator = md_MsgSubmitPocValidationsV2.Fields().ByName("creator")
+	fd_MsgSubmitPocValidationsV2_poc_stage_start_block_height = md_MsgSubmitPocValidationsV2.Fields().ByName("poc_stage_start_block_height")
+	fd_MsgSubmitPocValidationsV2_validations = md_MsgSubmitPocValidationsV2.Fields().ByName("validations")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgPoCV2StoreCommit)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitPocValidationsV2)(nil)
 
-type fastReflection_MsgPoCV2StoreCommit MsgPoCV2StoreCommit
+type fastReflection_MsgSubmitPocValidationsV2 MsgSubmitPocValidationsV2
 
-func (x *MsgPoCV2StoreCommit) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgPoCV2StoreCommit)(x)
+func (x *MsgSubmitPocValidationsV2) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocValidationsV2)(x)
 }
 
-func (x *MsgPoCV2StoreCommit) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitPocValidationsV2) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[22]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -12901,43 +12849,43 @@ func (x *MsgPoCV2StoreCommit) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgPoCV2StoreCommit_messageType fastReflection_MsgPoCV2StoreCommit_messageType
-var _ protoreflect.MessageType = fastReflection_MsgPoCV2StoreCommit_messageType{}
+var _fastReflection_MsgSubmitPocValidationsV2_messageType fastReflection_MsgSubmitPocValidationsV2_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitPocValidationsV2_messageType{}
 
-type fastReflection_MsgPoCV2StoreCommit_messageType struct{}
+type fastReflection_MsgSubmitPocValidationsV2_messageType struct{}
 
-func (x fastReflection_MsgPoCV2StoreCommit_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgPoCV2StoreCommit)(nil)
+func (x fastReflection_MsgSubmitPocValidationsV2_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocValidationsV2)(nil)
 }
-func (x fastReflection_MsgPoCV2StoreCommit_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgPoCV2StoreCommit)
+func (x fastReflection_MsgSubmitPocValidationsV2_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocValidationsV2)
 }
-func (x fastReflection_MsgPoCV2StoreCommit_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgPoCV2StoreCommit
+func (x fastReflection_MsgSubmitPocValidationsV2_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocValidationsV2
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgPoCV2StoreCommit) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgPoCV2StoreCommit
+func (x *fastReflection_MsgSubmitPocValidationsV2) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocValidationsV2
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgPoCV2StoreCommit) Type() protoreflect.MessageType {
-	return _fastReflection_MsgPoCV2StoreCommit_messageType
+func (x *fastReflection_MsgSubmitPocValidationsV2) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitPocValidationsV2_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgPoCV2StoreCommit) New() protoreflect.Message {
-	return new(fastReflection_MsgPoCV2StoreCommit)
+func (x *fastReflection_MsgSubmitPocValidationsV2) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocValidationsV2)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgPoCV2StoreCommit) Interface() protoreflect.ProtoMessage {
-	return (*MsgPoCV2StoreCommit)(x)
+func (x *fastReflection_MsgSubmitPocValidationsV2) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitPocValidationsV2)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -12945,34 +12893,22 @@ func (x *fastReflection_MsgPoCV2StoreCommit) Interface() protoreflect.ProtoMessa
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgPoCV2StoreCommit) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitPocValidationsV2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgPoCV2StoreCommit_creator, value) {
+		if !f(fd_MsgSubmitPocValidationsV2_creator, value) {
 			return
 		}
 	}
 	if x.PocStageStartBlockHeight != int64(0) {
 		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_MsgPoCV2StoreCommit_poc_stage_start_block_height, value) {
-			return
-		}
-	}
-	if x.Count != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Count)
-		if !f(fd_MsgPoCV2StoreCommit_count, value) {
-			return
-		}
-	}
-	if len(x.RootHash) != 0 {
-		value := protoreflect.ValueOfBytes(x.RootHash)
-		if !f(fd_MsgPoCV2StoreCommit_root_hash, value) {
+		if !f(fd_MsgSubmitPocValidationsV2_poc_stage_start_block_height, value) {
 			return
 		}
 	}
-	if len(x.Entries) != 0 {
-		value := protoreflect.ValueOfList(&_MsgPoCV2StoreCommit_5_list{list: &x.Entries})
-		if !f(fd_MsgPoCV2StoreCommit_entries, value) {
+	if len(x.Validations) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSubmitPocValidationsV2_3_list{list: &x.Validations})
+		if !f(fd_MsgSubmitPocValidationsV2_validations, value) {
 			return
 		}
 	}
@@ -12989,23 +12925,19 @@ func (x *fastReflection_MsgPoCV2StoreCommit) Range(f func(protoreflect.FieldDesc
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgPoCV2StoreCommit) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitPocValidationsV2) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgPoCV2StoreCommit.creator":
+	case "inference.inference.MsgSubmitPocValidationsV2.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
 		return x.PocStageStartBlockHeight != int64(0)
-	case "inference.inference.MsgPoCV2StoreCommit.count":
-		return x.Count != uint32(0)
-	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
-		return len(x.RootHash) != 0
-	case "inference.inference.MsgPoCV2StoreCommit.entries":
-		return len(x.Entries) != 0
+	case "inference.inference.MsgSubmitPocValidationsV2.validations":
+		return len(x.Validations) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13015,23 +12947,19 @@ func (x *fastReflection_MsgPoCV2StoreCommit) Has(fd protoreflect.FieldDescriptor
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommit) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitPocValidationsV2) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgPoCV2StoreCommit.creator":
+	case "inference.inference.MsgSubmitPocValidationsV2.creator":
 		x.Creator = ""
-	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = int64(0)
-	case "inference.inference.MsgPoCV2StoreCommit.count":
-		x.Count = uint32(0)
-	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
-		x.RootHash = nil
-	case "inference.inference.MsgPoCV2StoreCommit.entries":
-		x.Entries = nil
+	case "inference.inference.MsgSubmitPocValidationsV2.validations":
+		x.Validations = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13041,31 +12969,25 @@ func (x *fastReflection_MsgPoCV2StoreCommit) Clear(fd protoreflect.FieldDescript
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgPoCV2StoreCommit) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocValidationsV2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgPoCV2StoreCommit.creator":
+	case "inference.inference.MsgSubmitPocValidationsV2.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
 		value := x.PocStageStartBlockHeight
 		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.MsgPoCV2StoreCommit.count":
-		value := x.Count
-		return protoreflect.ValueOfUint32(value)
-	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
-		value := x.RootHash
-		return protoreflect.ValueOfBytes(value)
-	case "inference.inference.MsgPoCV2StoreCommit.entries":
-		if len(x.Entries) == 0 {
-			return protoreflect.ValueOfList(&_MsgPoCV2StoreCommit_5_list{})
-		}
-		listValue := &_MsgPoCV2StoreCommit_5_list{list: &x.Entries}
+	case "inference.inference.MsgSubmitPocValidationsV2.validations":
+		if len(x.Validations) == 0 {
+			return protoreflect.ValueOfList(&_MsgSubmitPocValidationsV2_3_list{})
+		}
+		listValue := &_MsgSubmitPocValidationsV2_3_list{list: &x.Validations}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -13079,25 +13001,21 @@ func (x *fastReflection_MsgPoCV2StoreCommit) Get(descriptor protoreflect.FieldDe
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommit) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitPocValidationsV2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgPoCV2StoreCommit.creator":
+	case "inference.inference.MsgSubmitPocValidationsV2.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = value.Int()
-	case "inference.inference.MsgPoCV2StoreCommit.count":
-		x.Count = uint32(value.Uint())
-	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
-		x.RootHash = value.Bytes()
-	case "inference.inference.MsgPoCV2StoreCommit.entries":
+	case "inference.inference.MsgSubmitPocValidationsV2.validations":
 		lv := value.List()
-		clv := lv.(*_MsgPoCV2StoreCommit_5_list)
-		x.Entries = *clv.list
+		clv := lv.(*_MsgSubmitPocValidationsV2_3_list)
+		x.Validations = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13111,61 +13029,53 @@ func (x *fastReflection_MsgPoCV2StoreCommit) Set(fd protoreflect.FieldDescriptor
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommit) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocValidationsV2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgPoCV2StoreCommit.entries":
-		if x.Entries == nil {
-			x.Entries = []*PoCV2CommitEntry{}
+	case "inference.inference.MsgSubmitPocValidationsV2.validations":
+		if x.Validations == nil {
+			x.Validations = []*PoCValidationEntryV2{}
 		}
-		value := &_MsgPoCV2StoreCommit_5_list{list: &x.Entries}
+		value := &_MsgSubmitPocValidationsV2_3_list{list: &x.Validations}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgPoCV2StoreCommit.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
-	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
-	case "inference.inference.MsgPoCV2StoreCommit.count":
-		panic(fmt.Errorf("field count of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
-	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
-		panic(fmt.Errorf("field root_hash of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
+	case "inference.inference.MsgSubmitPocValidationsV2.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitPocValidationsV2 is not mutable"))
+	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgSubmitPocValidationsV2 is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgPoCV2StoreCommit) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocValidationsV2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgPoCV2StoreCommit.creator":
+	case "inference.inference.MsgSubmitPocValidationsV2.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
+	case "inference.inference.MsgSubmitPocValidationsV2.poc_stage_start_block_height":
 		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.MsgPoCV2StoreCommit.count":
-		return protoreflect.ValueOfUint32(uint32(0))
-	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
-		return protoreflect.ValueOfBytes(nil)
-	case "inference.inference.MsgPoCV2StoreCommit.entries":
-		list := []*PoCV2CommitEntry{}
-		return protoreflect.ValueOfList(&_MsgPoCV2StoreCommit_5_list{list: &list})
+	case "inference.inference.MsgSubmitPocValidationsV2.validations":
+		list := []*PoCValidationEntryV2{}
+		return protoreflect.ValueOfList(&_MsgSubmitPocValidationsV2_3_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2 does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgPoCV2StoreCommit) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitPocValidationsV2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgPoCV2StoreCommit", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocValidationsV2", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -13173,7 +13083,7 @@ func (x *fastReflection_MsgPoCV2StoreCommit) WhichOneof(d protoreflect.OneofDesc
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgPoCV2StoreCommit) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitPocValidationsV2) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -13184,7 +13094,7 @@ func (x *fastReflection_MsgPoCV2StoreCommit) GetUnknown() protoreflect.RawFields
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommit) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitPocValidationsV2) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -13196,7 +13106,7 @@ func (x *fastReflection_MsgPoCV2StoreCommit) SetUnknown(fields protoreflect.RawF
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgPoCV2StoreCommit) IsValid() bool {
+func (x *fastReflection_MsgSubmitPocValidationsV2) IsValid() bool {
 	return x != nil
 }
 
@@ -13206,9 +13116,9 @@ func (x *fastReflection_MsgPoCV2StoreCommit) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitPocValidationsV2) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgPoCV2StoreCommit)
+		x := input.Message.Interface().(*MsgSubmitPocValidationsV2)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13227,15 +13137,8 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 		if x.PocStageStartBlockHeight != 0 {
 			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
-		if x.Count != 0 {
-			n += 1 + runtime.Sov(uint64(x.Count))
-		}
-		l = len(x.RootHash)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if len(x.Entries) > 0 {
-			for _, e := range x.Entries {
+		if len(x.Validations) > 0 {
+			for _, e := range x.Validations {
 				l = options.Size(e)
 				n += 1 + l + runtime.Sov(uint64(l))
 			}
@@ -13250,7 +13153,7 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgPoCV2StoreCommit)
+		x := input.Message.Interface().(*MsgSubmitPocValidationsV2)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13269,9 +13172,9 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Entries) > 0 {
-			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Entries[iNdEx])
+		if len(x.Validations) > 0 {
+			for iNdEx := len(x.Validations) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Validations[iNdEx])
 				if err != nil {
 					return protoiface.MarshalOutput{
 						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13282,21 +13185,9 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 				copy(dAtA[i:], encoded)
 				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 				i--
-				dAtA[i] = 0x2a
+				dAtA[i] = 0x1a
 			}
 		}
-		if len(x.RootHash) > 0 {
-			i -= len(x.RootHash)
-			copy(dAtA[i:], x.RootHash)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RootHash)))
-			i--
-			dAtA[i] = 0x22
-		}
-		if x.Count != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
-			i--
-			dAtA[i] = 0x18
-		}
 		if x.PocStageStartBlockHeight != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
 			i--
@@ -13320,7 +13211,7 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgPoCV2StoreCommit)
+		x := input.Message.Interface().(*MsgSubmitPocValidationsV2)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13352,10 +13243,10 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommit: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommit: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -13410,61 +13301,8 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 					}
 				}
 			case 3:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
-				}
-				x.Count = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Count |= uint32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
-				}
-				var byteLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					byteLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if byteLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + byteLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RootHash = append(x.RootHash[:0], dAtA[iNdEx:postIndex]...)
-				if x.RootHash == nil {
-					x.RootHash = []byte{}
-				}
-				iNdEx = postIndex
-			case 5:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validations", wireType)
 				}
 				var msglen int
 				for shift := uint(0); ; shift += 7 {
@@ -13491,8 +13329,8 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Entries = append(x.Entries, &PoCV2CommitEntry{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+				x.Validations = append(x.Validations, &PoCValidationEntryV2{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Validations[len(x.Validations)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
 				iNdEx = postIndex
@@ -13532,23 +13370,23 @@ func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods
 }
 
 var (
-	md_MsgPoCV2StoreCommitResponse protoreflect.MessageDescriptor
+	md_MsgSubmitPocValidationsV2Response protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgPoCV2StoreCommitResponse = File_inference_inference_tx_proto.Messages().ByName("MsgPoCV2StoreCommitResponse")
+	md_MsgSubmitPocValidationsV2Response = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitPocValidationsV2Response")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgPoCV2StoreCommitResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitPocValidationsV2Response)(nil)
 
-type fastReflection_MsgPoCV2StoreCommitResponse MsgPoCV2StoreCommitResponse
+type fastReflection_MsgSubmitPocValidationsV2Response MsgSubmitPocValidationsV2Response
 
-func (x *MsgPoCV2StoreCommitResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgPoCV2StoreCommitResponse)(x)
+func (x *MsgSubmitPocValidationsV2Response) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocValidationsV2Response)(x)
 }
 
-func (x *MsgPoCV2StoreCommitResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitPocValidationsV2Response) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[23]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -13560,43 +13398,43 @@ func (x *MsgPoCV2StoreCommitResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgPoCV2StoreCommitResponse_messageType fastReflection_MsgPoCV2StoreCommitResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgPoCV2StoreCommitResponse_messageType{}
+var _fastReflection_MsgSubmitPocValidationsV2Response_messageType fastReflection_MsgSubmitPocValidationsV2Response_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitPocValidationsV2Response_messageType{}
 
-type fastReflection_MsgPoCV2StoreCommitResponse_messageType struct{}
+type fastReflection_MsgSubmitPocValidationsV2Response_messageType struct{}
 
-func (x fastReflection_MsgPoCV2StoreCommitResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgPoCV2StoreCommitResponse)(nil)
+func (x fastReflection_MsgSubmitPocValidationsV2Response_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitPocValidationsV2Response)(nil)
 }
-func (x fastReflection_MsgPoCV2StoreCommitResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgPoCV2StoreCommitResponse)
+func (x fastReflection_MsgSubmitPocValidationsV2Response_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocValidationsV2Response)
 }
-func (x fastReflection_MsgPoCV2StoreCommitResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgPoCV2StoreCommitResponse
+func (x fastReflection_MsgSubmitPocValidationsV2Response_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocValidationsV2Response
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgPoCV2StoreCommitResponse
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitPocValidationsV2Response
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgPoCV2StoreCommitResponse_messageType
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitPocValidationsV2Response_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgPoCV2StoreCommitResponse)
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitPocValidationsV2Response)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgPoCV2StoreCommitResponse)(x)
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitPocValidationsV2Response)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -13604,7 +13442,7 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) Interface() protoreflect.Pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -13618,13 +13456,13 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) Range(f func(protoreflect.F
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13634,13 +13472,13 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) Has(fd protoreflect.FieldDe
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13650,13 +13488,13 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) Clear(fd protoreflect.Field
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -13670,13 +13508,13 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) Get(descriptor protoreflect
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -13690,36 +13528,36 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) Set(fd protoreflect.FieldDe
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitPocValidationsV2Response"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitPocValidationsV2Response does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgPoCV2StoreCommitResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitPocValidationsV2Response", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -13727,7 +13565,7 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) WhichOneof(d protoreflect.O
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -13738,7 +13576,7 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) GetUnknown() protoreflect.R
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -13750,7 +13588,7 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) SetUnknown(fields protorefl
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) IsValid() bool {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) IsValid() bool {
 	return x != nil
 }
 
@@ -13760,9 +13598,9 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgPoCV2StoreCommitResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitPocValidationsV2Response) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgPoCV2StoreCommitResponse)
+		x := input.Message.Interface().(*MsgSubmitPocValidationsV2Response)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13784,7 +13622,7 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) ProtoMethods() *protoiface.
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgPoCV2StoreCommitResponse)
+		x := input.Message.Interface().(*MsgSubmitPocValidationsV2Response)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13814,7 +13652,7 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) ProtoMethods() *protoiface.
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgPoCV2StoreCommitResponse)
+		x := input.Message.Interface().(*MsgSubmitPocValidationsV2Response)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -13846,10 +13684,10 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) ProtoMethods() *protoiface.
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommitResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2Response: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitPocValidationsV2Response: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -13887,134 +13725,85 @@ func (x *fastReflection_MsgPoCV2StoreCommitResponse) ProtoMethods() *protoiface.
 	}
 }
 
-var _ protoreflect.List = (*_MsgMLNodeWeightDistribution_3_list)(nil)
-
-type _MsgMLNodeWeightDistribution_3_list struct {
-	list *[]*MLNodeWeight
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) AppendMutable() protoreflect.Value {
-	v := new(MLNodeWeight)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) NewElement() protoreflect.Value {
-	v := new(MLNodeWeight)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgMLNodeWeightDistribution_3_list) IsValid() bool {
-	return x.list != nil
-}
-
-var _ protoreflect.List = (*_MsgMLNodeWeightDistribution_4_list)(nil)
+var _ protoreflect.List = (*_MsgPoCV2StoreCommit_5_list)(nil)
 
-type _MsgMLNodeWeightDistribution_4_list struct {
-	list *[]*MLNodeDistributionEntry
+type _MsgPoCV2StoreCommit_5_list struct {
+	list *[]*PoCV2CommitEntry
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) Len() int {
+func (x *_MsgPoCV2StoreCommit_5_list) Len() int {
 	if x.list == nil {
 		return 0
 	}
 	return len(*x.list)
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) Get(i int) protoreflect.Value {
+func (x *_MsgPoCV2StoreCommit_5_list) Get(i int) protoreflect.Value {
 	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) Set(i int, value protoreflect.Value) {
+func (x *_MsgPoCV2StoreCommit_5_list) Set(i int, value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeDistributionEntry)
+	concreteValue := valueUnwrapped.Interface().(*PoCV2CommitEntry)
 	(*x.list)[i] = concreteValue
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) Append(value protoreflect.Value) {
+func (x *_MsgPoCV2StoreCommit_5_list) Append(value protoreflect.Value) {
 	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*MLNodeDistributionEntry)
+	concreteValue := valueUnwrapped.Interface().(*PoCV2CommitEntry)
 	*x.list = append(*x.list, concreteValue)
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) AppendMutable() protoreflect.Value {
-	v := new(MLNodeDistributionEntry)
+func (x *_MsgPoCV2StoreCommit_5_list) AppendMutable() protoreflect.Value {
+	v := new(PoCV2CommitEntry)
 	*x.list = append(*x.list, v)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) Truncate(n int) {
+func (x *_MsgPoCV2StoreCommit_5_list) Truncate(n int) {
 	for i := n; i < len(*x.list); i++ {
 		(*x.list)[i] = nil
 	}
 	*x.list = (*x.list)[:n]
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) NewElement() protoreflect.Value {
-	v := new(MLNodeDistributionEntry)
+func (x *_MsgPoCV2StoreCommit_5_list) NewElement() protoreflect.Value {
+	v := new(PoCV2CommitEntry)
 	return protoreflect.ValueOfMessage(v.ProtoReflect())
 }
 
-func (x *_MsgMLNodeWeightDistribution_4_list) IsValid() bool {
+func (x *_MsgPoCV2StoreCommit_5_list) IsValid() bool {
 	return x.list != nil
 }
 
 var (
-	md_MsgMLNodeWeightDistribution                              protoreflect.MessageDescriptor
-	fd_MsgMLNodeWeightDistribution_creator                      protoreflect.FieldDescriptor
-	fd_MsgMLNodeWeightDistribution_poc_stage_start_block_height protoreflect.FieldDescriptor
-	fd_MsgMLNodeWeightDistribution_weights                      protoreflect.FieldDescriptor
-	fd_MsgMLNodeWeightDistribution_entries                      protoreflect.FieldDescriptor
+	md_MsgPoCV2StoreCommit                              protoreflect.MessageDescriptor
+	fd_MsgPoCV2StoreCommit_creator                      protoreflect.FieldDescriptor
+	fd_MsgPoCV2StoreCommit_poc_stage_start_block_height protoreflect.FieldDescriptor
+	fd_MsgPoCV2StoreCommit_count                        protoreflect.FieldDescriptor
+	fd_MsgPoCV2StoreCommit_root_hash                    protoreflect.FieldDescriptor
+	fd_MsgPoCV2StoreCommit_entries                      protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgMLNodeWeightDistribution = File_inference_inference_tx_proto.Messages().ByName("MsgMLNodeWeightDistribution")
-	fd_MsgMLNodeWeightDistribution_creator = md_MsgMLNodeWeightDistribution.Fields().ByName("creator")
-	fd_MsgMLNodeWeightDistribution_poc_stage_start_block_height = md_MsgMLNodeWeightDistribution.Fields().ByName("poc_stage_start_block_height")
-	fd_MsgMLNodeWeightDistribution_weights = md_MsgMLNodeWeightDistribution.Fields().ByName("weights")
-	fd_MsgMLNodeWeightDistribution_entries = md_MsgMLNodeWeightDistribution.Fields().ByName("entries")
+	md_MsgPoCV2StoreCommit = File_inference_inference_tx_proto.Messages().ByName("MsgPoCV2StoreCommit")
+	fd_MsgPoCV2StoreCommit_creator = md_MsgPoCV2StoreCommit.Fields().ByName("creator")
+	fd_MsgPoCV2StoreCommit_poc_stage_start_block_height = md_MsgPoCV2StoreCommit.Fields().ByName("poc_stage_start_block_height")
+	fd_MsgPoCV2StoreCommit_count = md_MsgPoCV2StoreCommit.Fields().ByName("count")
+	fd_MsgPoCV2StoreCommit_root_hash = md_MsgPoCV2StoreCommit.Fields().ByName("root_hash")
+	fd_MsgPoCV2StoreCommit_entries = md_MsgPoCV2StoreCommit.Fields().ByName("entries")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgMLNodeWeightDistribution)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgPoCV2StoreCommit)(nil)
 
-type fastReflection_MsgMLNodeWeightDistribution MsgMLNodeWeightDistribution
+type fastReflection_MsgPoCV2StoreCommit MsgPoCV2StoreCommit
 
-func (x *MsgMLNodeWeightDistribution) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgMLNodeWeightDistribution)(x)
+func (x *MsgPoCV2StoreCommit) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgPoCV2StoreCommit)(x)
 }
 
-func (x *MsgMLNodeWeightDistribution) slowProtoReflect() protoreflect.Message {
+func (x *MsgPoCV2StoreCommit) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[24]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -14026,43 +13815,43 @@ func (x *MsgMLNodeWeightDistribution) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgMLNodeWeightDistribution_messageType fastReflection_MsgMLNodeWeightDistribution_messageType
-var _ protoreflect.MessageType = fastReflection_MsgMLNodeWeightDistribution_messageType{}
+var _fastReflection_MsgPoCV2StoreCommit_messageType fastReflection_MsgPoCV2StoreCommit_messageType
+var _ protoreflect.MessageType = fastReflection_MsgPoCV2StoreCommit_messageType{}
 
-type fastReflection_MsgMLNodeWeightDistribution_messageType struct{}
+type fastReflection_MsgPoCV2StoreCommit_messageType struct{}
 
-func (x fastReflection_MsgMLNodeWeightDistribution_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgMLNodeWeightDistribution)(nil)
+func (x fastReflection_MsgPoCV2StoreCommit_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgPoCV2StoreCommit)(nil)
 }
-func (x fastReflection_MsgMLNodeWeightDistribution_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgMLNodeWeightDistribution)
+func (x fastReflection_MsgPoCV2StoreCommit_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgPoCV2StoreCommit)
 }
-func (x fastReflection_MsgMLNodeWeightDistribution_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMLNodeWeightDistribution
+func (x fastReflection_MsgPoCV2StoreCommit_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgPoCV2StoreCommit
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMLNodeWeightDistribution
+func (x *fastReflection_MsgPoCV2StoreCommit) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgPoCV2StoreCommit
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Type() protoreflect.MessageType {
-	return _fastReflection_MsgMLNodeWeightDistribution_messageType
+func (x *fastReflection_MsgPoCV2StoreCommit) Type() protoreflect.MessageType {
+	return _fastReflection_MsgPoCV2StoreCommit_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgMLNodeWeightDistribution) New() protoreflect.Message {
-	return new(fastReflection_MsgMLNodeWeightDistribution)
+func (x *fastReflection_MsgPoCV2StoreCommit) New() protoreflect.Message {
+	return new(fastReflection_MsgPoCV2StoreCommit)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Interface() protoreflect.ProtoMessage {
-	return (*MsgMLNodeWeightDistribution)(x)
+func (x *fastReflection_MsgPoCV2StoreCommit) Interface() protoreflect.ProtoMessage {
+	return (*MsgPoCV2StoreCommit)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -14070,28 +13859,34 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) Interface() protoreflect.Pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgPoCV2StoreCommit) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgMLNodeWeightDistribution_creator, value) {
+		if !f(fd_MsgPoCV2StoreCommit_creator, value) {
 			return
 		}
 	}
 	if x.PocStageStartBlockHeight != int64(0) {
 		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
-		if !f(fd_MsgMLNodeWeightDistribution_poc_stage_start_block_height, value) {
+		if !f(fd_MsgPoCV2StoreCommit_poc_stage_start_block_height, value) {
 			return
 		}
 	}
-	if len(x.Weights) != 0 {
-		value := protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_3_list{list: &x.Weights})
-		if !f(fd_MsgMLNodeWeightDistribution_weights, value) {
+	if x.Count != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Count)
+		if !f(fd_MsgPoCV2StoreCommit_count, value) {
+			return
+		}
+	}
+	if len(x.RootHash) != 0 {
+		value := protoreflect.ValueOfBytes(x.RootHash)
+		if !f(fd_MsgPoCV2StoreCommit_root_hash, value) {
 			return
 		}
 	}
 	if len(x.Entries) != 0 {
-		value := protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_4_list{list: &x.Entries})
-		if !f(fd_MsgMLNodeWeightDistribution_entries, value) {
+		value := protoreflect.ValueOfList(&_MsgPoCV2StoreCommit_5_list{list: &x.Entries})
+		if !f(fd_MsgPoCV2StoreCommit_entries, value) {
 			return
 		}
 	}
@@ -14108,21 +13903,23 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) Range(f func(protoreflect.F
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgPoCV2StoreCommit) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgMLNodeWeightDistribution.creator":
+	case "inference.inference.MsgPoCV2StoreCommit.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
 		return x.PocStageStartBlockHeight != int64(0)
-	case "inference.inference.MsgMLNodeWeightDistribution.weights":
-		return len(x.Weights) != 0
-	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+	case "inference.inference.MsgPoCV2StoreCommit.count":
+		return x.Count != uint32(0)
+	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
+		return len(x.RootHash) != 0
+	case "inference.inference.MsgPoCV2StoreCommit.entries":
 		return len(x.Entries) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14132,21 +13929,23 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) Has(fd protoreflect.FieldDe
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgPoCV2StoreCommit) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgMLNodeWeightDistribution.creator":
+	case "inference.inference.MsgPoCV2StoreCommit.creator":
 		x.Creator = ""
-	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = int64(0)
-	case "inference.inference.MsgMLNodeWeightDistribution.weights":
-		x.Weights = nil
-	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+	case "inference.inference.MsgPoCV2StoreCommit.count":
+		x.Count = uint32(0)
+	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
+		x.RootHash = nil
+	case "inference.inference.MsgPoCV2StoreCommit.entries":
 		x.Entries = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14156,31 +13955,31 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) Clear(fd protoreflect.Field
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgPoCV2StoreCommit) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgMLNodeWeightDistribution.creator":
+	case "inference.inference.MsgPoCV2StoreCommit.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
 		value := x.PocStageStartBlockHeight
 		return protoreflect.ValueOfInt64(value)
-	case "inference.inference.MsgMLNodeWeightDistribution.weights":
-		if len(x.Weights) == 0 {
-			return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_3_list{})
-		}
-		listValue := &_MsgMLNodeWeightDistribution_3_list{list: &x.Weights}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+	case "inference.inference.MsgPoCV2StoreCommit.count":
+		value := x.Count
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
+		value := x.RootHash
+		return protoreflect.ValueOfBytes(value)
+	case "inference.inference.MsgPoCV2StoreCommit.entries":
 		if len(x.Entries) == 0 {
-			return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_4_list{})
+			return protoreflect.ValueOfList(&_MsgPoCV2StoreCommit_5_list{})
 		}
-		listValue := &_MsgMLNodeWeightDistribution_4_list{list: &x.Entries}
+		listValue := &_MsgPoCV2StoreCommit_5_list{list: &x.Entries}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -14194,25 +13993,25 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) Get(descriptor protoreflect
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgPoCV2StoreCommit) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgMLNodeWeightDistribution.creator":
+	case "inference.inference.MsgPoCV2StoreCommit.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
 		x.PocStageStartBlockHeight = value.Int()
-	case "inference.inference.MsgMLNodeWeightDistribution.weights":
-		lv := value.List()
-		clv := lv.(*_MsgMLNodeWeightDistribution_3_list)
-		x.Weights = *clv.list
-	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+	case "inference.inference.MsgPoCV2StoreCommit.count":
+		x.Count = uint32(value.Uint())
+	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
+		x.RootHash = value.Bytes()
+	case "inference.inference.MsgPoCV2StoreCommit.entries":
 		lv := value.List()
-		clv := lv.(*_MsgMLNodeWeightDistribution_4_list)
+		clv := lv.(*_MsgPoCV2StoreCommit_5_list)
 		x.Entries = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14226,62 +14025,61 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) Set(fd protoreflect.FieldDe
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistribution) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgPoCV2StoreCommit) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgMLNodeWeightDistribution.weights":
-		if x.Weights == nil {
-			x.Weights = []*MLNodeWeight{}
-		}
-		value := &_MsgMLNodeWeightDistribution_3_list{list: &x.Weights}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+	case "inference.inference.MsgPoCV2StoreCommit.entries":
 		if x.Entries == nil {
-			x.Entries = []*MLNodeDistributionEntry{}
+			x.Entries = []*PoCV2CommitEntry{}
 		}
-		value := &_MsgMLNodeWeightDistribution_4_list{list: &x.Entries}
+		value := &_MsgPoCV2StoreCommit_5_list{list: &x.Entries}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgMLNodeWeightDistribution.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgMLNodeWeightDistribution is not mutable"))
-	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
-		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgMLNodeWeightDistribution is not mutable"))
+	case "inference.inference.MsgPoCV2StoreCommit.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
+	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
+	case "inference.inference.MsgPoCV2StoreCommit.count":
+		panic(fmt.Errorf("field count of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
+	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
+		panic(fmt.Errorf("field root_hash of message inference.inference.MsgPoCV2StoreCommit is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgMLNodeWeightDistribution) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgPoCV2StoreCommit) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgMLNodeWeightDistribution.creator":
+	case "inference.inference.MsgPoCV2StoreCommit.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+	case "inference.inference.MsgPoCV2StoreCommit.poc_stage_start_block_height":
 		return protoreflect.ValueOfInt64(int64(0))
-	case "inference.inference.MsgMLNodeWeightDistribution.weights":
-		list := []*MLNodeWeight{}
-		return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_3_list{list: &list})
-	case "inference.inference.MsgMLNodeWeightDistribution.entries":
-		list := []*MLNodeDistributionEntry{}
-		return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_4_list{list: &list})
+	case "inference.inference.MsgPoCV2StoreCommit.count":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.MsgPoCV2StoreCommit.root_hash":
+		return protoreflect.ValueOfBytes(nil)
+	case "inference.inference.MsgPoCV2StoreCommit.entries":
+		list := []*PoCV2CommitEntry{}
+		return protoreflect.ValueOfList(&_MsgPoCV2StoreCommit_5_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommit"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommit does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgMLNodeWeightDistribution) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgPoCV2StoreCommit) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMLNodeWeightDistribution", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgPoCV2StoreCommit", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -14289,7 +14087,7 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) WhichOneof(d protoreflect.O
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgMLNodeWeightDistribution) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgPoCV2StoreCommit) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -14300,7 +14098,7 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) GetUnknown() protoreflect.R
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistribution) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgPoCV2StoreCommit) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -14312,7 +14110,7 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) SetUnknown(fields protorefl
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgMLNodeWeightDistribution) IsValid() bool {
+func (x *fastReflection_MsgPoCV2StoreCommit) IsValid() bool {
 	return x != nil
 }
 
@@ -14322,9 +14120,9 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgPoCV2StoreCommit) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgMLNodeWeightDistribution)
+		x := input.Message.Interface().(*MsgPoCV2StoreCommit)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14343,11 +14141,12 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 		if x.PocStageStartBlockHeight != 0 {
 			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
-		if len(x.Weights) > 0 {
-			for _, e := range x.Weights {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.Count != 0 {
+			n += 1 + runtime.Sov(uint64(x.Count))
+		}
+		l = len(x.RootHash)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if len(x.Entries) > 0 {
 			for _, e := range x.Entries {
@@ -14365,7 +14164,7 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMLNodeWeightDistribution)
+		x := input.Message.Interface().(*MsgPoCV2StoreCommit)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14397,24 +14196,20 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 				copy(dAtA[i:], encoded)
 				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
 				i--
-				dAtA[i] = 0x22
+				dAtA[i] = 0x2a
 			}
 		}
-		if len(x.Weights) > 0 {
-			for iNdEx := len(x.Weights) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Weights[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x1a
-			}
+		if len(x.RootHash) > 0 {
+			i -= len(x.RootHash)
+			copy(dAtA[i:], x.RootHash)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RootHash)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if x.Count != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Count))
+			i--
+			dAtA[i] = 0x18
 		}
 		if x.PocStageStartBlockHeight != 0 {
 			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
@@ -14439,7 +14234,7 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMLNodeWeightDistribution)
+		x := input.Message.Interface().(*MsgPoCV2StoreCommit)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14471,10 +14266,10 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistribution: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommit: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistribution: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommit: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -14529,10 +14324,29 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 					}
 				}
 			case 3:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+				}
+				x.Count = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Count |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 4:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
 				}
-				var msglen int
+				var byteLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -14542,27 +14356,27 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					byteLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				if byteLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + byteLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Weights = append(x.Weights, &MLNodeWeight{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Weights[len(x.Weights)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				x.RootHash = append(x.RootHash[:0], dAtA[iNdEx:postIndex]...)
+				if x.RootHash == nil {
+					x.RootHash = []byte{}
 				}
 				iNdEx = postIndex
-			case 4:
+			case 5:
 				if wireType != 2 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
 				}
@@ -14591,7 +14405,7 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Entries = append(x.Entries, &MLNodeDistributionEntry{})
+				x.Entries = append(x.Entries, &PoCV2CommitEntry{})
 				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
 				}
@@ -14632,23 +14446,23 @@ func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.
 }
 
 var (
-	md_MsgMLNodeWeightDistributionResponse protoreflect.MessageDescriptor
+	md_MsgPoCV2StoreCommitResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgMLNodeWeightDistributionResponse = File_inference_inference_tx_proto.Messages().ByName("MsgMLNodeWeightDistributionResponse")
+	md_MsgPoCV2StoreCommitResponse = File_inference_inference_tx_proto.Messages().ByName("MsgPoCV2StoreCommitResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgMLNodeWeightDistributionResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgPoCV2StoreCommitResponse)(nil)
 
-type fastReflection_MsgMLNodeWeightDistributionResponse MsgMLNodeWeightDistributionResponse
+type fastReflection_MsgPoCV2StoreCommitResponse MsgPoCV2StoreCommitResponse
 
-func (x *MsgMLNodeWeightDistributionResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgMLNodeWeightDistributionResponse)(x)
+func (x *MsgPoCV2StoreCommitResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgPoCV2StoreCommitResponse)(x)
 }
 
-func (x *MsgMLNodeWeightDistributionResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgPoCV2StoreCommitResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[25]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -14660,43 +14474,43 @@ func (x *MsgMLNodeWeightDistributionResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgMLNodeWeightDistributionResponse_messageType fastReflection_MsgMLNodeWeightDistributionResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgMLNodeWeightDistributionResponse_messageType{}
+var _fastReflection_MsgPoCV2StoreCommitResponse_messageType fastReflection_MsgPoCV2StoreCommitResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgPoCV2StoreCommitResponse_messageType{}
 
-type fastReflection_MsgMLNodeWeightDistributionResponse_messageType struct{}
+type fastReflection_MsgPoCV2StoreCommitResponse_messageType struct{}
 
-func (x fastReflection_MsgMLNodeWeightDistributionResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgMLNodeWeightDistributionResponse)(nil)
+func (x fastReflection_MsgPoCV2StoreCommitResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgPoCV2StoreCommitResponse)(nil)
 }
-func (x fastReflection_MsgMLNodeWeightDistributionResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgMLNodeWeightDistributionResponse)
+func (x fastReflection_MsgPoCV2StoreCommitResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgPoCV2StoreCommitResponse)
 }
-func (x fastReflection_MsgMLNodeWeightDistributionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMLNodeWeightDistributionResponse
+func (x fastReflection_MsgPoCV2StoreCommitResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgPoCV2StoreCommitResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMLNodeWeightDistributionResponse
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgPoCV2StoreCommitResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgMLNodeWeightDistributionResponse_messageType
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgPoCV2StoreCommitResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgMLNodeWeightDistributionResponse)
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgPoCV2StoreCommitResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgMLNodeWeightDistributionResponse)(x)
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgPoCV2StoreCommitResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -14704,7 +14518,7 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -14718,13 +14532,13 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14734,13 +14548,13 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14750,13 +14564,13 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -14770,13 +14584,13 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -14790,36 +14604,36 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgPoCV2StoreCommitResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgPoCV2StoreCommitResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMLNodeWeightDistributionResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgPoCV2StoreCommitResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -14827,7 +14641,7 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -14838,7 +14652,7 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -14850,7 +14664,7 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) IsValid() bool {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -14860,9 +14674,9 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgMLNodeWeightDistributionResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgPoCV2StoreCommitResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgMLNodeWeightDistributionResponse)
+		x := input.Message.Interface().(*MsgPoCV2StoreCommitResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14884,7 +14698,7 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMLNodeWeightDistributionResponse)
+		x := input.Message.Interface().(*MsgPoCV2StoreCommitResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14914,7 +14728,7 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMLNodeWeightDistributionResponse)
+		x := input.Message.Interface().(*MsgPoCV2StoreCommitResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -14946,10 +14760,10 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistributionResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommitResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistributionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgPoCV2StoreCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -14987,30 +14801,134 @@ func (x *fastReflection_MsgMLNodeWeightDistributionResponse) ProtoMethods() *pro
 	}
 }
 
+var _ protoreflect.List = (*_MsgMLNodeWeightDistribution_3_list)(nil)
+
+type _MsgMLNodeWeightDistribution_3_list struct {
+	list *[]*MLNodeWeight
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeWeight)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) AppendMutable() protoreflect.Value {
+	v := new(MLNodeWeight)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) NewElement() protoreflect.Value {
+	v := new(MLNodeWeight)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgMLNodeWeightDistribution_3_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_MsgMLNodeWeightDistribution_4_list)(nil)
+
+type _MsgMLNodeWeightDistribution_4_list struct {
+	list *[]*MLNodeDistributionEntry
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeDistributionEntry)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*MLNodeDistributionEntry)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) AppendMutable() protoreflect.Value {
+	v := new(MLNodeDistributionEntry)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) NewElement() protoreflect.Value {
+	v := new(MLNodeDistributionEntry)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgMLNodeWeightDistribution_4_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_MsgSubmitSeed             protoreflect.MessageDescriptor
-	fd_MsgSubmitSeed_creator     protoreflect.FieldDescriptor
-	fd_MsgSubmitSeed_epoch_index protoreflect.FieldDescriptor
-	fd_MsgSubmitSeed_signature   protoreflect.FieldDescriptor
+	md_MsgMLNodeWeightDistribution                              protoreflect.MessageDescriptor
+	fd_MsgMLNodeWeightDistribution_creator                      protoreflect.FieldDescriptor
+	fd_MsgMLNodeWeightDistribution_poc_stage_start_block_height protoreflect.FieldDescriptor
+	fd_MsgMLNodeWeightDistribution_weights                      protoreflect.FieldDescriptor
+	fd_MsgMLNodeWeightDistribution_entries                      protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitSeed = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitSeed")
-	fd_MsgSubmitSeed_creator = md_MsgSubmitSeed.Fields().ByName("creator")
-	fd_MsgSubmitSeed_epoch_index = md_MsgSubmitSeed.Fields().ByName("epoch_index")
-	fd_MsgSubmitSeed_signature = md_MsgSubmitSeed.Fields().ByName("signature")
+	md_MsgMLNodeWeightDistribution = File_inference_inference_tx_proto.Messages().ByName("MsgMLNodeWeightDistribution")
+	fd_MsgMLNodeWeightDistribution_creator = md_MsgMLNodeWeightDistribution.Fields().ByName("creator")
+	fd_MsgMLNodeWeightDistribution_poc_stage_start_block_height = md_MsgMLNodeWeightDistribution.Fields().ByName("poc_stage_start_block_height")
+	fd_MsgMLNodeWeightDistribution_weights = md_MsgMLNodeWeightDistribution.Fields().ByName("weights")
+	fd_MsgMLNodeWeightDistribution_entries = md_MsgMLNodeWeightDistribution.Fields().ByName("entries")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitSeed)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgMLNodeWeightDistribution)(nil)
 
-type fastReflection_MsgSubmitSeed MsgSubmitSeed
+type fastReflection_MsgMLNodeWeightDistribution MsgMLNodeWeightDistribution
 
-func (x *MsgSubmitSeed) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitSeed)(x)
+func (x *MsgMLNodeWeightDistribution) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgMLNodeWeightDistribution)(x)
 }
 
-func (x *MsgSubmitSeed) slowProtoReflect() protoreflect.Message {
+func (x *MsgMLNodeWeightDistribution) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[26]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -15022,43 +14940,43 @@ func (x *MsgSubmitSeed) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitSeed_messageType fastReflection_MsgSubmitSeed_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitSeed_messageType{}
+var _fastReflection_MsgMLNodeWeightDistribution_messageType fastReflection_MsgMLNodeWeightDistribution_messageType
+var _ protoreflect.MessageType = fastReflection_MsgMLNodeWeightDistribution_messageType{}
 
-type fastReflection_MsgSubmitSeed_messageType struct{}
+type fastReflection_MsgMLNodeWeightDistribution_messageType struct{}
 
-func (x fastReflection_MsgSubmitSeed_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitSeed)(nil)
+func (x fastReflection_MsgMLNodeWeightDistribution_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgMLNodeWeightDistribution)(nil)
 }
-func (x fastReflection_MsgSubmitSeed_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitSeed)
+func (x fastReflection_MsgMLNodeWeightDistribution_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgMLNodeWeightDistribution)
 }
-func (x fastReflection_MsgSubmitSeed_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitSeed
+func (x fastReflection_MsgMLNodeWeightDistribution_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMLNodeWeightDistribution
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitSeed) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitSeed
+func (x *fastReflection_MsgMLNodeWeightDistribution) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMLNodeWeightDistribution
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitSeed) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitSeed_messageType
+func (x *fastReflection_MsgMLNodeWeightDistribution) Type() protoreflect.MessageType {
+	return _fastReflection_MsgMLNodeWeightDistribution_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitSeed) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitSeed)
+func (x *fastReflection_MsgMLNodeWeightDistribution) New() protoreflect.Message {
+	return new(fastReflection_MsgMLNodeWeightDistribution)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitSeed) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitSeed)(x)
+func (x *fastReflection_MsgMLNodeWeightDistribution) Interface() protoreflect.ProtoMessage {
+	return (*MsgMLNodeWeightDistribution)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -15066,22 +14984,28 @@ func (x *fastReflection_MsgSubmitSeed) Interface() protoreflect.ProtoMessage {
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitSeed) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgMLNodeWeightDistribution) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgSubmitSeed_creator, value) {
+		if !f(fd_MsgMLNodeWeightDistribution_creator, value) {
 			return
 		}
 	}
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_MsgSubmitSeed_epoch_index, value) {
+	if x.PocStageStartBlockHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.PocStageStartBlockHeight)
+		if !f(fd_MsgMLNodeWeightDistribution_poc_stage_start_block_height, value) {
 			return
 		}
 	}
-	if x.Signature != "" {
-		value := protoreflect.ValueOfString(x.Signature)
-		if !f(fd_MsgSubmitSeed_signature, value) {
+	if len(x.Weights) != 0 {
+		value := protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_3_list{list: &x.Weights})
+		if !f(fd_MsgMLNodeWeightDistribution_weights, value) {
+			return
+		}
+	}
+	if len(x.Entries) != 0 {
+		value := protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_4_list{list: &x.Entries})
+		if !f(fd_MsgMLNodeWeightDistribution_entries, value) {
 			return
 		}
 	}
@@ -15098,19 +15022,21 @@ func (x *fastReflection_MsgSubmitSeed) Range(f func(protoreflect.FieldDescriptor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitSeed) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgMLNodeWeightDistribution) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitSeed.creator":
+	case "inference.inference.MsgMLNodeWeightDistribution.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgSubmitSeed.epoch_index":
-		return x.EpochIndex != uint64(0)
-	case "inference.inference.MsgSubmitSeed.signature":
-		return x.Signature != ""
+	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+		return x.PocStageStartBlockHeight != int64(0)
+	case "inference.inference.MsgMLNodeWeightDistribution.weights":
+		return len(x.Weights) != 0
+	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+		return len(x.Entries) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15120,19 +15046,21 @@ func (x *fastReflection_MsgSubmitSeed) Has(fd protoreflect.FieldDescriptor) bool
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeed) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgMLNodeWeightDistribution) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitSeed.creator":
+	case "inference.inference.MsgMLNodeWeightDistribution.creator":
 		x.Creator = ""
-	case "inference.inference.MsgSubmitSeed.epoch_index":
-		x.EpochIndex = uint64(0)
-	case "inference.inference.MsgSubmitSeed.signature":
-		x.Signature = ""
+	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+		x.PocStageStartBlockHeight = int64(0)
+	case "inference.inference.MsgMLNodeWeightDistribution.weights":
+		x.Weights = nil
+	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+		x.Entries = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15142,22 +15070,31 @@ func (x *fastReflection_MsgSubmitSeed) Clear(fd protoreflect.FieldDescriptor) {
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitSeed) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMLNodeWeightDistribution) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSubmitSeed.creator":
+	case "inference.inference.MsgMLNodeWeightDistribution.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSubmitSeed.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgSubmitSeed.signature":
-		value := x.Signature
-		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+		value := x.PocStageStartBlockHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.MsgMLNodeWeightDistribution.weights":
+		if len(x.Weights) == 0 {
+			return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_3_list{})
+		}
+		listValue := &_MsgMLNodeWeightDistribution_3_list{list: &x.Weights}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+		if len(x.Entries) == 0 {
+			return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_4_list{})
+		}
+		listValue := &_MsgMLNodeWeightDistribution_4_list{list: &x.Entries}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -15171,19 +15108,25 @@ func (x *fastReflection_MsgSubmitSeed) Get(descriptor protoreflect.FieldDescript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeed) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgMLNodeWeightDistribution) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitSeed.creator":
+	case "inference.inference.MsgMLNodeWeightDistribution.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgSubmitSeed.epoch_index":
-		x.EpochIndex = value.Uint()
-	case "inference.inference.MsgSubmitSeed.signature":
-		x.Signature = value.Interface().(string)
+	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+		x.PocStageStartBlockHeight = value.Int()
+	case "inference.inference.MsgMLNodeWeightDistribution.weights":
+		lv := value.List()
+		clv := lv.(*_MsgMLNodeWeightDistribution_3_list)
+		x.Weights = *clv.list
+	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+		lv := value.List()
+		clv := lv.(*_MsgMLNodeWeightDistribution_4_list)
+		x.Entries = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15197,48 +15140,62 @@ func (x *fastReflection_MsgSubmitSeed) Set(fd protoreflect.FieldDescriptor, valu
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeed) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMLNodeWeightDistribution) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitSeed.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitSeed is not mutable"))
-	case "inference.inference.MsgSubmitSeed.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.MsgSubmitSeed is not mutable"))
-	case "inference.inference.MsgSubmitSeed.signature":
-		panic(fmt.Errorf("field signature of message inference.inference.MsgSubmitSeed is not mutable"))
+	case "inference.inference.MsgMLNodeWeightDistribution.weights":
+		if x.Weights == nil {
+			x.Weights = []*MLNodeWeight{}
+		}
+		value := &_MsgMLNodeWeightDistribution_3_list{list: &x.Weights}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+		if x.Entries == nil {
+			x.Entries = []*MLNodeDistributionEntry{}
+		}
+		value := &_MsgMLNodeWeightDistribution_4_list{list: &x.Entries}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgMLNodeWeightDistribution.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgMLNodeWeightDistribution is not mutable"))
+	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+		panic(fmt.Errorf("field poc_stage_start_block_height of message inference.inference.MsgMLNodeWeightDistribution is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitSeed) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMLNodeWeightDistribution) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitSeed.creator":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSubmitSeed.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgSubmitSeed.signature":
+	case "inference.inference.MsgMLNodeWeightDistribution.creator":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgMLNodeWeightDistribution.poc_stage_start_block_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.MsgMLNodeWeightDistribution.weights":
+		list := []*MLNodeWeight{}
+		return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_3_list{list: &list})
+	case "inference.inference.MsgMLNodeWeightDistribution.entries":
+		list := []*MLNodeDistributionEntry{}
+		return protoreflect.ValueOfList(&_MsgMLNodeWeightDistribution_4_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistribution"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistribution does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitSeed) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgMLNodeWeightDistribution) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitSeed", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMLNodeWeightDistribution", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -15246,7 +15203,7 @@ func (x *fastReflection_MsgSubmitSeed) WhichOneof(d protoreflect.OneofDescriptor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitSeed) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgMLNodeWeightDistribution) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -15257,7 +15214,7 @@ func (x *fastReflection_MsgSubmitSeed) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeed) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgMLNodeWeightDistribution) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -15269,7 +15226,7 @@ func (x *fastReflection_MsgSubmitSeed) SetUnknown(fields protoreflect.RawFields)
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitSeed) IsValid() bool {
+func (x *fastReflection_MsgMLNodeWeightDistribution) IsValid() bool {
 	return x != nil
 }
 
@@ -15279,9 +15236,9 @@ func (x *fastReflection_MsgSubmitSeed) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgMLNodeWeightDistribution) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitSeed)
+		x := input.Message.Interface().(*MsgMLNodeWeightDistribution)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15297,12 +15254,20 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		if x.PocStageStartBlockHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.PocStageStartBlockHeight))
 		}
-		l = len(x.Signature)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.Weights) > 0 {
+			for _, e := range x.Weights {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if len(x.Entries) > 0 {
+			for _, e := range x.Entries {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -15314,7 +15279,7 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitSeed)
+		x := input.Message.Interface().(*MsgMLNodeWeightDistribution)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15333,15 +15298,40 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Signature) > 0 {
-			i -= len(x.Signature)
-			copy(dAtA[i:], x.Signature)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signature)))
-			i--
-			dAtA[i] = 0x1a
+		if len(x.Entries) > 0 {
+			for iNdEx := len(x.Entries) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Entries[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x22
+			}
 		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+		if len(x.Weights) > 0 {
+			for iNdEx := len(x.Weights) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Weights[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x1a
+			}
+		}
+		if x.PocStageStartBlockHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.PocStageStartBlockHeight))
 			i--
 			dAtA[i] = 0x10
 		}
@@ -15363,7 +15353,7 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitSeed)
+		x := input.Message.Interface().(*MsgMLNodeWeightDistribution)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15395,10 +15385,10 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeed: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistribution: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeed: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistribution: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -15435,9 +15425,9 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 				}
-				x.EpochIndex = 0
+				x.PocStageStartBlockHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -15447,16 +15437,16 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
+					x.PocStageStartBlockHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -15466,23 +15456,59 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Signature = string(dAtA[iNdEx:postIndex])
+				x.Weights = append(x.Weights, &MLNodeWeight{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Weights[len(x.Weights)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Entries = append(x.Entries, &MLNodeDistributionEntry{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Entries[len(x.Entries)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -15520,23 +15546,23 @@ func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 }
 
 var (
-	md_MsgSubmitSeedResponse protoreflect.MessageDescriptor
+	md_MsgMLNodeWeightDistributionResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitSeedResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitSeedResponse")
+	md_MsgMLNodeWeightDistributionResponse = File_inference_inference_tx_proto.Messages().ByName("MsgMLNodeWeightDistributionResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitSeedResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgMLNodeWeightDistributionResponse)(nil)
 
-type fastReflection_MsgSubmitSeedResponse MsgSubmitSeedResponse
+type fastReflection_MsgMLNodeWeightDistributionResponse MsgMLNodeWeightDistributionResponse
 
-func (x *MsgSubmitSeedResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitSeedResponse)(x)
+func (x *MsgMLNodeWeightDistributionResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgMLNodeWeightDistributionResponse)(x)
 }
 
-func (x *MsgSubmitSeedResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgMLNodeWeightDistributionResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[27]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -15548,43 +15574,43 @@ func (x *MsgSubmitSeedResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitSeedResponse_messageType fastReflection_MsgSubmitSeedResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitSeedResponse_messageType{}
+var _fastReflection_MsgMLNodeWeightDistributionResponse_messageType fastReflection_MsgMLNodeWeightDistributionResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgMLNodeWeightDistributionResponse_messageType{}
 
-type fastReflection_MsgSubmitSeedResponse_messageType struct{}
+type fastReflection_MsgMLNodeWeightDistributionResponse_messageType struct{}
 
-func (x fastReflection_MsgSubmitSeedResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitSeedResponse)(nil)
+func (x fastReflection_MsgMLNodeWeightDistributionResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgMLNodeWeightDistributionResponse)(nil)
 }
-func (x fastReflection_MsgSubmitSeedResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitSeedResponse)
+func (x fastReflection_MsgMLNodeWeightDistributionResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgMLNodeWeightDistributionResponse)
 }
-func (x fastReflection_MsgSubmitSeedResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitSeedResponse
+func (x fastReflection_MsgMLNodeWeightDistributionResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMLNodeWeightDistributionResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitSeedResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitSeedResponse
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMLNodeWeightDistributionResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitSeedResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitSeedResponse_messageType
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgMLNodeWeightDistributionResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitSeedResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitSeedResponse)
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgMLNodeWeightDistributionResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitSeedResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitSeedResponse)(x)
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgMLNodeWeightDistributionResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -15592,7 +15618,7 @@ func (x *fastReflection_MsgSubmitSeedResponse) Interface() protoreflect.ProtoMes
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitSeedResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -15606,13 +15632,13 @@ func (x *fastReflection_MsgSubmitSeedResponse) Range(f func(protoreflect.FieldDe
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitSeedResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15622,13 +15648,13 @@ func (x *fastReflection_MsgSubmitSeedResponse) Has(fd protoreflect.FieldDescript
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeedResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15638,13 +15664,13 @@ func (x *fastReflection_MsgSubmitSeedResponse) Clear(fd protoreflect.FieldDescri
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitSeedResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -15658,13 +15684,13 @@ func (x *fastReflection_MsgSubmitSeedResponse) Get(descriptor protoreflect.Field
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeedResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15678,36 +15704,36 @@ func (x *fastReflection_MsgSubmitSeedResponse) Set(fd protoreflect.FieldDescript
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeedResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitSeedResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMLNodeWeightDistributionResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMLNodeWeightDistributionResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitSeedResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitSeedResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMLNodeWeightDistributionResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -15715,7 +15741,7 @@ func (x *fastReflection_MsgSubmitSeedResponse) WhichOneof(d protoreflect.OneofDe
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitSeedResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -15726,7 +15752,7 @@ func (x *fastReflection_MsgSubmitSeedResponse) GetUnknown() protoreflect.RawFiel
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitSeedResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -15738,7 +15764,7 @@ func (x *fastReflection_MsgSubmitSeedResponse) SetUnknown(fields protoreflect.Ra
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitSeedResponse) IsValid() bool {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -15748,9 +15774,9 @@ func (x *fastReflection_MsgSubmitSeedResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitSeedResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgMLNodeWeightDistributionResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitSeedResponse)
+		x := input.Message.Interface().(*MsgMLNodeWeightDistributionResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15772,7 +15798,7 @@ func (x *fastReflection_MsgSubmitSeedResponse) ProtoMethods() *protoiface.Method
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitSeedResponse)
+		x := input.Message.Interface().(*MsgMLNodeWeightDistributionResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15802,7 +15828,7 @@ func (x *fastReflection_MsgSubmitSeedResponse) ProtoMethods() *protoiface.Method
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitSeedResponse)
+		x := input.Message.Interface().(*MsgMLNodeWeightDistributionResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -15834,10 +15860,10 @@ func (x *fastReflection_MsgSubmitSeedResponse) ProtoMethods() *protoiface.Method
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeedResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistributionResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMLNodeWeightDistributionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -15876,27 +15902,29 @@ func (x *fastReflection_MsgSubmitSeedResponse) ProtoMethods() *protoiface.Method
 }
 
 var (
-	md_MsgSubmitUnitOfComputePriceProposal         protoreflect.MessageDescriptor
-	fd_MsgSubmitUnitOfComputePriceProposal_creator protoreflect.FieldDescriptor
-	fd_MsgSubmitUnitOfComputePriceProposal_price   protoreflect.FieldDescriptor
+	md_MsgSubmitSeed             protoreflect.MessageDescriptor
+	fd_MsgSubmitSeed_creator     protoreflect.FieldDescriptor
+	fd_MsgSubmitSeed_epoch_index protoreflect.FieldDescriptor
+	fd_MsgSubmitSeed_signature   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitUnitOfComputePriceProposal = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitUnitOfComputePriceProposal")
-	fd_MsgSubmitUnitOfComputePriceProposal_creator = md_MsgSubmitUnitOfComputePriceProposal.Fields().ByName("creator")
-	fd_MsgSubmitUnitOfComputePriceProposal_price = md_MsgSubmitUnitOfComputePriceProposal.Fields().ByName("price")
+	md_MsgSubmitSeed = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitSeed")
+	fd_MsgSubmitSeed_creator = md_MsgSubmitSeed.Fields().ByName("creator")
+	fd_MsgSubmitSeed_epoch_index = md_MsgSubmitSeed.Fields().ByName("epoch_index")
+	fd_MsgSubmitSeed_signature = md_MsgSubmitSeed.Fields().ByName("signature")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitUnitOfComputePriceProposal)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitSeed)(nil)
 
-type fastReflection_MsgSubmitUnitOfComputePriceProposal MsgSubmitUnitOfComputePriceProposal
+type fastReflection_MsgSubmitSeed MsgSubmitSeed
 
-func (x *MsgSubmitUnitOfComputePriceProposal) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitUnitOfComputePriceProposal)(x)
+func (x *MsgSubmitSeed) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitSeed)(x)
 }
 
-func (x *MsgSubmitUnitOfComputePriceProposal) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitSeed) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[28]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -15908,43 +15936,43 @@ func (x *MsgSubmitUnitOfComputePriceProposal) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType{}
+var _fastReflection_MsgSubmitSeed_messageType fastReflection_MsgSubmitSeed_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitSeed_messageType{}
 
-type fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType struct{}
+type fastReflection_MsgSubmitSeed_messageType struct{}
 
-func (x fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitUnitOfComputePriceProposal)(nil)
+func (x fastReflection_MsgSubmitSeed_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitSeed)(nil)
 }
-func (x fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitUnitOfComputePriceProposal)
+func (x fastReflection_MsgSubmitSeed_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitSeed)
 }
-func (x fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitUnitOfComputePriceProposal
+func (x fastReflection_MsgSubmitSeed_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitSeed
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitUnitOfComputePriceProposal
+func (x *fastReflection_MsgSubmitSeed) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitSeed
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType
+func (x *fastReflection_MsgSubmitSeed) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitSeed_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitUnitOfComputePriceProposal)
+func (x *fastReflection_MsgSubmitSeed) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitSeed)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitUnitOfComputePriceProposal)(x)
+func (x *fastReflection_MsgSubmitSeed) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitSeed)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -15952,16 +15980,22 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitSeed) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgSubmitUnitOfComputePriceProposal_creator, value) {
+		if !f(fd_MsgSubmitSeed_creator, value) {
 			return
 		}
 	}
-	if x.Price != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Price)
-		if !f(fd_MsgSubmitUnitOfComputePriceProposal_price, value) {
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_MsgSubmitSeed_epoch_index, value) {
+			return
+		}
+	}
+	if x.Signature != "" {
+		value := protoreflect.ValueOfString(x.Signature)
+		if !f(fd_MsgSubmitSeed_signature, value) {
 			return
 		}
 	}
@@ -15978,17 +16012,19 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitSeed) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+	case "inference.inference.MsgSubmitSeed.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
-		return x.Price != uint64(0)
+	case "inference.inference.MsgSubmitSeed.epoch_index":
+		return x.EpochIndex != uint64(0)
+	case "inference.inference.MsgSubmitSeed.signature":
+		return x.Signature != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -15998,17 +16034,19 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitSeed) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+	case "inference.inference.MsgSubmitSeed.creator":
 		x.Creator = ""
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
-		x.Price = uint64(0)
+	case "inference.inference.MsgSubmitSeed.epoch_index":
+		x.EpochIndex = uint64(0)
+	case "inference.inference.MsgSubmitSeed.signature":
+		x.Signature = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16018,19 +16056,22 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitSeed) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+	case "inference.inference.MsgSubmitSeed.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
-		value := x.Price
+	case "inference.inference.MsgSubmitSeed.epoch_index":
+		value := x.EpochIndex
 		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgSubmitSeed.signature":
+		value := x.Signature
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -16044,17 +16085,19 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitSeed) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+	case "inference.inference.MsgSubmitSeed.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
-		x.Price = value.Uint()
+	case "inference.inference.MsgSubmitSeed.epoch_index":
+		x.EpochIndex = value.Uint()
+	case "inference.inference.MsgSubmitSeed.signature":
+		x.Signature = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16068,44 +16111,48 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitSeed) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitUnitOfComputePriceProposal is not mutable"))
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
-		panic(fmt.Errorf("field price of message inference.inference.MsgSubmitUnitOfComputePriceProposal is not mutable"))
+	case "inference.inference.MsgSubmitSeed.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitSeed is not mutable"))
+	case "inference.inference.MsgSubmitSeed.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.MsgSubmitSeed is not mutable"))
+	case "inference.inference.MsgSubmitSeed.signature":
+		panic(fmt.Errorf("field signature of message inference.inference.MsgSubmitSeed is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitSeed) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+	case "inference.inference.MsgSubmitSeed.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
+	case "inference.inference.MsgSubmitSeed.epoch_index":
 		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgSubmitSeed.signature":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeed"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeed does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitSeed) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitUnitOfComputePriceProposal", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitSeed", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -16113,7 +16160,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitSeed) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -16124,7 +16171,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitSeed) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -16136,7 +16183,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) IsValid() bool {
+func (x *fastReflection_MsgSubmitSeed) IsValid() bool {
 	return x != nil
 }
 
@@ -16146,9 +16193,9 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitSeed) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposal)
+		x := input.Message.Interface().(*MsgSubmitSeed)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16164,8 +16211,12 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Price != 0 {
-			n += 1 + runtime.Sov(uint64(x.Price))
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
+		l = len(x.Signature)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -16177,7 +16228,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposal)
+		x := input.Message.Interface().(*MsgSubmitSeed)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16196,8 +16247,15 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Price != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
+		if len(x.Signature) > 0 {
+			i -= len(x.Signature)
+			copy(dAtA[i:], x.Signature)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signature)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
 			i--
 			dAtA[i] = 0x10
 		}
@@ -16219,7 +16277,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposal)
+		x := input.Message.Interface().(*MsgSubmitSeed)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16251,10 +16309,10 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposal: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeed: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeed: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -16291,9 +16349,9 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 				}
-				x.Price = 0
+				x.EpochIndex = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -16303,11 +16361,43 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Price |= uint64(b&0x7F) << shift
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Signature = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -16344,23 +16434,23 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *pro
 }
 
 var (
-	md_MsgSubmitUnitOfComputePriceProposalResponse protoreflect.MessageDescriptor
+	md_MsgSubmitSeedResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitUnitOfComputePriceProposalResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitUnitOfComputePriceProposalResponse")
+	md_MsgSubmitSeedResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitSeedResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitSeedResponse)(nil)
 
-type fastReflection_MsgSubmitUnitOfComputePriceProposalResponse MsgSubmitUnitOfComputePriceProposalResponse
+type fastReflection_MsgSubmitSeedResponse MsgSubmitSeedResponse
 
-func (x *MsgSubmitUnitOfComputePriceProposalResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)(x)
+func (x *MsgSubmitSeedResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitSeedResponse)(x)
 }
 
-func (x *MsgSubmitUnitOfComputePriceProposalResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitSeedResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[29]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -16372,43 +16462,43 @@ func (x *MsgSubmitUnitOfComputePriceProposalResponse) slowProtoReflect() protore
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType{}
+var _fastReflection_MsgSubmitSeedResponse_messageType fastReflection_MsgSubmitSeedResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitSeedResponse_messageType{}
 
-type fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType struct{}
+type fastReflection_MsgSubmitSeedResponse_messageType struct{}
 
-func (x fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)(nil)
+func (x fastReflection_MsgSubmitSeedResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitSeedResponse)(nil)
 }
-func (x fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)
+func (x fastReflection_MsgSubmitSeedResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitSeedResponse)
 }
-func (x fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitUnitOfComputePriceProposalResponse
+func (x fastReflection_MsgSubmitSeedResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitSeedResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitUnitOfComputePriceProposalResponse
+func (x *fastReflection_MsgSubmitSeedResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitSeedResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType
+func (x *fastReflection_MsgSubmitSeedResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitSeedResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)
+func (x *fastReflection_MsgSubmitSeedResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitSeedResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitUnitOfComputePriceProposalResponse)(x)
+func (x *fastReflection_MsgSubmitSeedResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitSeedResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -16416,7 +16506,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitSeedResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -16430,13 +16520,13 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Range(f fun
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitSeedResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16446,13 +16536,13 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Has(fd prot
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitSeedResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16462,13 +16552,13 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Clear(fd pr
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitSeedResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -16482,13 +16572,13 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Get(descrip
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitSeedResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16502,36 +16592,36 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Set(fd prot
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitSeedResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitSeedResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitSeedResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitSeedResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitSeedResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitUnitOfComputePriceProposalResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitSeedResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -16539,7 +16629,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) WhichOneof(
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitSeedResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -16550,7 +16640,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) GetUnknown(
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitSeedResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -16562,7 +16652,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) SetUnknown(
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) IsValid() bool {
+func (x *fastReflection_MsgSubmitSeedResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -16572,9 +16662,9 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) IsValid() b
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitSeedResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposalResponse)
+		x := input.Message.Interface().(*MsgSubmitSeedResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16596,7 +16686,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) ProtoMethod
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposalResponse)
+		x := input.Message.Interface().(*MsgSubmitSeedResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16626,7 +16716,7 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) ProtoMethod
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposalResponse)
+		x := input.Message.Interface().(*MsgSubmitSeedResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -16658,10 +16748,10 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) ProtoMethod
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposalResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeedResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitSeedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -16699,90 +16789,28 @@ func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) ProtoMethod
 	}
 }
 
-var _ protoreflect.List = (*_MsgRegisterModel_7_list)(nil)
-
-type _MsgRegisterModel_7_list struct {
-	list *[]string
-}
-
-func (x *_MsgRegisterModel_7_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgRegisterModel_7_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfString((*x.list)[i])
-}
-
-func (x *_MsgRegisterModel_7_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgRegisterModel_7_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgRegisterModel_7_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message MsgRegisterModel at list field ModelArgs as it is not of Message kind"))
-}
-
-func (x *_MsgRegisterModel_7_list) Truncate(n int) {
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgRegisterModel_7_list) NewElement() protoreflect.Value {
-	v := ""
-	return protoreflect.ValueOfString(v)
-}
-
-func (x *_MsgRegisterModel_7_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MsgRegisterModel                            protoreflect.MessageDescriptor
-	fd_MsgRegisterModel_authority                  protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_proposed_by                protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_id                         protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_units_of_compute_per_token protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_hf_repo                    protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_hf_commit                  protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_model_args                 protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_v_ram                      protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_throughput_per_nonce       protoreflect.FieldDescriptor
-	fd_MsgRegisterModel_validation_threshold       protoreflect.FieldDescriptor
+	md_MsgSubmitUnitOfComputePriceProposal         protoreflect.MessageDescriptor
+	fd_MsgSubmitUnitOfComputePriceProposal_creator protoreflect.FieldDescriptor
+	fd_MsgSubmitUnitOfComputePriceProposal_price   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterModel = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterModel")
-	fd_MsgRegisterModel_authority = md_MsgRegisterModel.Fields().ByName("authority")
-	fd_MsgRegisterModel_proposed_by = md_MsgRegisterModel.Fields().ByName("proposed_by")
-	fd_MsgRegisterModel_id = md_MsgRegisterModel.Fields().ByName("id")
-	fd_MsgRegisterModel_units_of_compute_per_token = md_MsgRegisterModel.Fields().ByName("units_of_compute_per_token")
-	fd_MsgRegisterModel_hf_repo = md_MsgRegisterModel.Fields().ByName("hf_repo")
-	fd_MsgRegisterModel_hf_commit = md_MsgRegisterModel.Fields().ByName("hf_commit")
-	fd_MsgRegisterModel_model_args = md_MsgRegisterModel.Fields().ByName("model_args")
-	fd_MsgRegisterModel_v_ram = md_MsgRegisterModel.Fields().ByName("v_ram")
-	fd_MsgRegisterModel_throughput_per_nonce = md_MsgRegisterModel.Fields().ByName("throughput_per_nonce")
-	fd_MsgRegisterModel_validation_threshold = md_MsgRegisterModel.Fields().ByName("validation_threshold")
+	md_MsgSubmitUnitOfComputePriceProposal = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitUnitOfComputePriceProposal")
+	fd_MsgSubmitUnitOfComputePriceProposal_creator = md_MsgSubmitUnitOfComputePriceProposal.Fields().ByName("creator")
+	fd_MsgSubmitUnitOfComputePriceProposal_price = md_MsgSubmitUnitOfComputePriceProposal.Fields().ByName("price")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterModel)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitUnitOfComputePriceProposal)(nil)
 
-type fastReflection_MsgRegisterModel MsgRegisterModel
+type fastReflection_MsgSubmitUnitOfComputePriceProposal MsgSubmitUnitOfComputePriceProposal
 
-func (x *MsgRegisterModel) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterModel)(x)
+func (x *MsgSubmitUnitOfComputePriceProposal) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitUnitOfComputePriceProposal)(x)
 }
 
-func (x *MsgRegisterModel) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitUnitOfComputePriceProposal) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[30]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -16794,43 +16822,43 @@ func (x *MsgRegisterModel) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterModel_messageType fastReflection_MsgRegisterModel_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterModel_messageType{}
+var _fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType{}
 
-type fastReflection_MsgRegisterModel_messageType struct{}
+type fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType struct{}
 
-func (x fastReflection_MsgRegisterModel_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterModel)(nil)
+func (x fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitUnitOfComputePriceProposal)(nil)
 }
-func (x fastReflection_MsgRegisterModel_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterModel)
+func (x fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitUnitOfComputePriceProposal)
 }
-func (x fastReflection_MsgRegisterModel_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterModel
+func (x fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitUnitOfComputePriceProposal
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterModel) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterModel
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitUnitOfComputePriceProposal
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterModel) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterModel_messageType
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitUnitOfComputePriceProposal_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterModel) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterModel)
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitUnitOfComputePriceProposal)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterModel) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterModel)(x)
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitUnitOfComputePriceProposal)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -16838,64 +16866,16 @@ func (x *fastReflection_MsgRegisterModel) Interface() protoreflect.ProtoMessage
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterModel) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRegisterModel_authority, value) {
-			return
-		}
-	}
-	if x.ProposedBy != "" {
-		value := protoreflect.ValueOfString(x.ProposedBy)
-		if !f(fd_MsgRegisterModel_proposed_by, value) {
-			return
-		}
-	}
-	if x.Id != "" {
-		value := protoreflect.ValueOfString(x.Id)
-		if !f(fd_MsgRegisterModel_id, value) {
-			return
-		}
-	}
-	if x.UnitsOfComputePerToken != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.UnitsOfComputePerToken)
-		if !f(fd_MsgRegisterModel_units_of_compute_per_token, value) {
-			return
-		}
-	}
-	if x.HfRepo != "" {
-		value := protoreflect.ValueOfString(x.HfRepo)
-		if !f(fd_MsgRegisterModel_hf_repo, value) {
-			return
-		}
-	}
-	if x.HfCommit != "" {
-		value := protoreflect.ValueOfString(x.HfCommit)
-		if !f(fd_MsgRegisterModel_hf_commit, value) {
-			return
-		}
-	}
-	if len(x.ModelArgs) != 0 {
-		value := protoreflect.ValueOfList(&_MsgRegisterModel_7_list{list: &x.ModelArgs})
-		if !f(fd_MsgRegisterModel_model_args, value) {
-			return
-		}
-	}
-	if x.VRam != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.VRam)
-		if !f(fd_MsgRegisterModel_v_ram, value) {
-			return
-		}
-	}
-	if x.ThroughputPerNonce != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.ThroughputPerNonce)
-		if !f(fd_MsgRegisterModel_throughput_per_nonce, value) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgSubmitUnitOfComputePriceProposal_creator, value) {
 			return
 		}
 	}
-	if x.ValidationThreshold != nil {
-		value := protoreflect.ValueOfMessage(x.ValidationThreshold.ProtoReflect())
-		if !f(fd_MsgRegisterModel_validation_threshold, value) {
+	if x.Price != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Price)
+		if !f(fd_MsgSubmitUnitOfComputePriceProposal_price, value) {
 			return
 		}
 	}
@@ -16912,33 +16892,17 @@ func (x *fastReflection_MsgRegisterModel) Range(f func(protoreflect.FieldDescrip
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterModel) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterModel.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgRegisterModel.proposed_by":
-		return x.ProposedBy != ""
-	case "inference.inference.MsgRegisterModel.id":
-		return x.Id != ""
-	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
-		return x.UnitsOfComputePerToken != uint64(0)
-	case "inference.inference.MsgRegisterModel.hf_repo":
-		return x.HfRepo != ""
-	case "inference.inference.MsgRegisterModel.hf_commit":
-		return x.HfCommit != ""
-	case "inference.inference.MsgRegisterModel.model_args":
-		return len(x.ModelArgs) != 0
-	case "inference.inference.MsgRegisterModel.v_ram":
-		return x.VRam != uint64(0)
-	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
-		return x.ThroughputPerNonce != uint64(0)
-	case "inference.inference.MsgRegisterModel.validation_threshold":
-		return x.ValidationThreshold != nil
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
+		return x.Price != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16948,33 +16912,17 @@ func (x *fastReflection_MsgRegisterModel) Has(fd protoreflect.FieldDescriptor) b
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModel) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterModel.authority":
-		x.Authority = ""
-	case "inference.inference.MsgRegisterModel.proposed_by":
-		x.ProposedBy = ""
-	case "inference.inference.MsgRegisterModel.id":
-		x.Id = ""
-	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
-		x.UnitsOfComputePerToken = uint64(0)
-	case "inference.inference.MsgRegisterModel.hf_repo":
-		x.HfRepo = ""
-	case "inference.inference.MsgRegisterModel.hf_commit":
-		x.HfCommit = ""
-	case "inference.inference.MsgRegisterModel.model_args":
-		x.ModelArgs = nil
-	case "inference.inference.MsgRegisterModel.v_ram":
-		x.VRam = uint64(0)
-	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
-		x.ThroughputPerNonce = uint64(0)
-	case "inference.inference.MsgRegisterModel.validation_threshold":
-		x.ValidationThreshold = nil
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+		x.Creator = ""
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
+		x.Price = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -16984,46 +16932,19 @@ func (x *fastReflection_MsgRegisterModel) Clear(fd protoreflect.FieldDescriptor)
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterModel) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRegisterModel.authority":
-		value := x.Authority
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterModel.proposed_by":
-		value := x.ProposedBy
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterModel.id":
-		value := x.Id
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
-		value := x.UnitsOfComputePerToken
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgRegisterModel.hf_repo":
-		value := x.HfRepo
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterModel.hf_commit":
-		value := x.HfCommit
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterModel.model_args":
-		if len(x.ModelArgs) == 0 {
-			return protoreflect.ValueOfList(&_MsgRegisterModel_7_list{})
-		}
-		listValue := &_MsgRegisterModel_7_list{list: &x.ModelArgs}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgRegisterModel.v_ram":
-		value := x.VRam
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
-		value := x.ThroughputPerNonce
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
+		value := x.Price
 		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgRegisterModel.validation_threshold":
-		value := x.ValidationThreshold
-		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -17037,35 +16958,17 @@ func (x *fastReflection_MsgRegisterModel) Get(descriptor protoreflect.FieldDescr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModel) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterModel.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRegisterModel.proposed_by":
-		x.ProposedBy = value.Interface().(string)
-	case "inference.inference.MsgRegisterModel.id":
-		x.Id = value.Interface().(string)
-	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
-		x.UnitsOfComputePerToken = value.Uint()
-	case "inference.inference.MsgRegisterModel.hf_repo":
-		x.HfRepo = value.Interface().(string)
-	case "inference.inference.MsgRegisterModel.hf_commit":
-		x.HfCommit = value.Interface().(string)
-	case "inference.inference.MsgRegisterModel.model_args":
-		lv := value.List()
-		clv := lv.(*_MsgRegisterModel_7_list)
-		x.ModelArgs = *clv.list
-	case "inference.inference.MsgRegisterModel.v_ram":
-		x.VRam = value.Uint()
-	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
-		x.ThroughputPerNonce = value.Uint()
-	case "inference.inference.MsgRegisterModel.validation_threshold":
-		x.ValidationThreshold = value.Message().Interface().(*Decimal)
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
+		x.Price = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17079,85 +16982,44 @@ func (x *fastReflection_MsgRegisterModel) Set(fd protoreflect.FieldDescriptor, v
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModel) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterModel.model_args":
-		if x.ModelArgs == nil {
-			x.ModelArgs = []string{}
-		}
-		value := &_MsgRegisterModel_7_list{list: &x.ModelArgs}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgRegisterModel.validation_threshold":
-		if x.ValidationThreshold == nil {
-			x.ValidationThreshold = new(Decimal)
-		}
-		return protoreflect.ValueOfMessage(x.ValidationThreshold.ProtoReflect())
-	case "inference.inference.MsgRegisterModel.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.proposed_by":
-		panic(fmt.Errorf("field proposed_by of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.id":
-		panic(fmt.Errorf("field id of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
-		panic(fmt.Errorf("field units_of_compute_per_token of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.hf_repo":
-		panic(fmt.Errorf("field hf_repo of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.hf_commit":
-		panic(fmt.Errorf("field hf_commit of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.v_ram":
-		panic(fmt.Errorf("field v_ram of message inference.inference.MsgRegisterModel is not mutable"))
-	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
-		panic(fmt.Errorf("field throughput_per_nonce of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitUnitOfComputePriceProposal is not mutable"))
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
+		panic(fmt.Errorf("field price of message inference.inference.MsgSubmitUnitOfComputePriceProposal is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterModel) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterModel.authority":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterModel.proposed_by":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterModel.id":
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+	case "inference.inference.MsgSubmitUnitOfComputePriceProposal.price":
 		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgRegisterModel.hf_repo":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterModel.hf_commit":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterModel.model_args":
-		list := []string{}
-		return protoreflect.ValueOfList(&_MsgRegisterModel_7_list{list: &list})
-	case "inference.inference.MsgRegisterModel.v_ram":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgRegisterModel.validation_threshold":
-		m := new(Decimal)
-		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposal does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterModel) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterModel", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitUnitOfComputePriceProposal", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -17165,7 +17027,7 @@ func (x *fastReflection_MsgRegisterModel) WhichOneof(d protoreflect.OneofDescrip
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterModel) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -17176,7 +17038,7 @@ func (x *fastReflection_MsgRegisterModel) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModel) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -17188,7 +17050,7 @@ func (x *fastReflection_MsgRegisterModel) SetUnknown(fields protoreflect.RawFiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterModel) IsValid() bool {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) IsValid() bool {
 	return x != nil
 }
 
@@ -17198,9 +17060,9 @@ func (x *fastReflection_MsgRegisterModel) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposal) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterModel)
+		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposal)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17212,44 +17074,12 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.ProposedBy)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.Id)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.UnitsOfComputePerToken != 0 {
-			n += 1 + runtime.Sov(uint64(x.UnitsOfComputePerToken))
-		}
-		l = len(x.HfRepo)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.HfCommit)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if len(x.ModelArgs) > 0 {
-			for _, s := range x.ModelArgs {
-				l = len(s)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if x.VRam != 0 {
-			n += 1 + runtime.Sov(uint64(x.VRam))
-		}
-		if x.ThroughputPerNonce != 0 {
-			n += 1 + runtime.Sov(uint64(x.ThroughputPerNonce))
-		}
-		if x.ValidationThreshold != nil {
-			l = options.Size(x.ValidationThreshold)
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Price != 0 {
+			n += 1 + runtime.Sov(uint64(x.Price))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -17261,7 +17091,7 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterModel)
+		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposal)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17280,76 +17110,15 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.ValidationThreshold != nil {
-			encoded, err := options.Marshal(x.ValidationThreshold)
-			if err != nil {
-				return protoiface.MarshalOutput{
-					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-					Buf:               input.Buf,
-				}, err
-			}
-			i -= len(encoded)
-			copy(dAtA[i:], encoded)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-			i--
-			dAtA[i] = 0x52
-		}
-		if x.ThroughputPerNonce != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.ThroughputPerNonce))
-			i--
-			dAtA[i] = 0x48
-		}
-		if x.VRam != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.VRam))
-			i--
-			dAtA[i] = 0x40
-		}
-		if len(x.ModelArgs) > 0 {
-			for iNdEx := len(x.ModelArgs) - 1; iNdEx >= 0; iNdEx-- {
-				i -= len(x.ModelArgs[iNdEx])
-				copy(dAtA[i:], x.ModelArgs[iNdEx])
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelArgs[iNdEx])))
-				i--
-				dAtA[i] = 0x3a
-			}
-		}
-		if len(x.HfCommit) > 0 {
-			i -= len(x.HfCommit)
-			copy(dAtA[i:], x.HfCommit)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HfCommit)))
-			i--
-			dAtA[i] = 0x32
-		}
-		if len(x.HfRepo) > 0 {
-			i -= len(x.HfRepo)
-			copy(dAtA[i:], x.HfRepo)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HfRepo)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if x.UnitsOfComputePerToken != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnitsOfComputePerToken))
-			i--
-			dAtA[i] = 0x20
-		}
-		if len(x.Id) > 0 {
-			i -= len(x.Id)
-			copy(dAtA[i:], x.Id)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.ProposedBy) > 0 {
-			i -= len(x.ProposedBy)
-			copy(dAtA[i:], x.ProposedBy)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposedBy)))
+		if x.Price != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Price))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -17364,7 +17133,7 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterModel)
+		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposal)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17396,15 +17165,15 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModel: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposal: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModel: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposal: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -17432,230 +17201,13 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposedBy", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ProposedBy = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Id = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnitsOfComputePerToken", wireType)
-				}
-				x.UnitsOfComputePerToken = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.UnitsOfComputePerToken |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HfRepo", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HfRepo = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 6:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HfCommit", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HfCommit = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 7:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelArgs", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelArgs = append(x.ModelArgs, string(dAtA[iNdEx:postIndex]))
-				iNdEx = postIndex
-			case 8:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field VRam", wireType)
-				}
-				x.VRam = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.VRam |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 9:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ThroughputPerNonce", wireType)
-				}
-				x.ThroughputPerNonce = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.ThroughputPerNonce |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 10:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationThreshold", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
 				}
-				var msglen int
+				x.Price = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -17665,28 +17217,11 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.Price |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				if x.ValidationThreshold == nil {
-					x.ValidationThreshold = &Decimal{}
-				}
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationThreshold); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -17723,23 +17258,23 @@ func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 }
 
 var (
-	md_MsgRegisterModelResponse protoreflect.MessageDescriptor
+	md_MsgSubmitUnitOfComputePriceProposalResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterModelResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterModelResponse")
+	md_MsgSubmitUnitOfComputePriceProposalResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitUnitOfComputePriceProposalResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterModelResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)(nil)
 
-type fastReflection_MsgRegisterModelResponse MsgRegisterModelResponse
+type fastReflection_MsgSubmitUnitOfComputePriceProposalResponse MsgSubmitUnitOfComputePriceProposalResponse
 
-func (x *MsgRegisterModelResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterModelResponse)(x)
+func (x *MsgSubmitUnitOfComputePriceProposalResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)(x)
 }
 
-func (x *MsgRegisterModelResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitUnitOfComputePriceProposalResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[31]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -17751,43 +17286,43 @@ func (x *MsgRegisterModelResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterModelResponse_messageType fastReflection_MsgRegisterModelResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterModelResponse_messageType{}
+var _fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType{}
 
-type fastReflection_MsgRegisterModelResponse_messageType struct{}
+type fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType struct{}
 
-func (x fastReflection_MsgRegisterModelResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterModelResponse)(nil)
+func (x fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)(nil)
 }
-func (x fastReflection_MsgRegisterModelResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterModelResponse)
+func (x fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)
 }
-func (x fastReflection_MsgRegisterModelResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterModelResponse
+func (x fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitUnitOfComputePriceProposalResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterModelResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterModelResponse
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitUnitOfComputePriceProposalResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterModelResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterModelResponse_messageType
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitUnitOfComputePriceProposalResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterModelResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterModelResponse)
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitUnitOfComputePriceProposalResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterModelResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterModelResponse)(x)
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitUnitOfComputePriceProposalResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -17795,7 +17330,7 @@ func (x *fastReflection_MsgRegisterModelResponse) Interface() protoreflect.Proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterModelResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -17809,13 +17344,13 @@ func (x *fastReflection_MsgRegisterModelResponse) Range(f func(protoreflect.Fiel
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterModelResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17825,13 +17360,13 @@ func (x *fastReflection_MsgRegisterModelResponse) Has(fd protoreflect.FieldDescr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModelResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17841,13 +17376,13 @@ func (x *fastReflection_MsgRegisterModelResponse) Clear(fd protoreflect.FieldDes
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterModelResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -17861,13 +17396,13 @@ func (x *fastReflection_MsgRegisterModelResponse) Get(descriptor protoreflect.Fi
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModelResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -17881,36 +17416,36 @@ func (x *fastReflection_MsgRegisterModelResponse) Set(fd protoreflect.FieldDescr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModelResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterModelResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitUnitOfComputePriceProposalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterModelResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterModelResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitUnitOfComputePriceProposalResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -17918,7 +17453,7 @@ func (x *fastReflection_MsgRegisterModelResponse) WhichOneof(d protoreflect.Oneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterModelResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -17929,7 +17464,7 @@ func (x *fastReflection_MsgRegisterModelResponse) GetUnknown() protoreflect.RawF
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterModelResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -17941,7 +17476,7 @@ func (x *fastReflection_MsgRegisterModelResponse) SetUnknown(fields protoreflect
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterModelResponse) IsValid() bool {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -17951,9 +17486,9 @@ func (x *fastReflection_MsgRegisterModelResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterModelResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitUnitOfComputePriceProposalResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterModelResponse)
+		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposalResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -17975,7 +17510,7 @@ func (x *fastReflection_MsgRegisterModelResponse) ProtoMethods() *protoiface.Met
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterModelResponse)
+		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposalResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18005,7 +17540,7 @@ func (x *fastReflection_MsgRegisterModelResponse) ProtoMethods() *protoiface.Met
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterModelResponse)
+		x := input.Message.Interface().(*MsgSubmitUnitOfComputePriceProposalResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18037,10 +17572,10 @@ func (x *fastReflection_MsgRegisterModelResponse) ProtoMethods() *protoiface.Met
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModelResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposalResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitUnitOfComputePriceProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -18078,28 +17613,90 @@ func (x *fastReflection_MsgRegisterModelResponse) ProtoMethods() *protoiface.Met
 	}
 }
 
-var (
-	md_MsgDeleteGovernanceModel           protoreflect.MessageDescriptor
-	fd_MsgDeleteGovernanceModel_authority protoreflect.FieldDescriptor
-	fd_MsgDeleteGovernanceModel_id        protoreflect.FieldDescriptor
-)
+var _ protoreflect.List = (*_MsgRegisterModel_7_list)(nil)
 
-func init() {
-	file_inference_inference_tx_proto_init()
-	md_MsgDeleteGovernanceModel = File_inference_inference_tx_proto.Messages().ByName("MsgDeleteGovernanceModel")
-	fd_MsgDeleteGovernanceModel_authority = md_MsgDeleteGovernanceModel.Fields().ByName("authority")
-	fd_MsgDeleteGovernanceModel_id = md_MsgDeleteGovernanceModel.Fields().ByName("id")
+type _MsgRegisterModel_7_list struct {
+	list *[]string
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgDeleteGovernanceModel)(nil)
+func (x *_MsgRegisterModel_7_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
 
-type fastReflection_MsgDeleteGovernanceModel MsgDeleteGovernanceModel
+func (x *_MsgRegisterModel_7_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
 
-func (x *MsgDeleteGovernanceModel) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgDeleteGovernanceModel)(x)
+func (x *_MsgRegisterModel_7_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
 }
 
-func (x *MsgDeleteGovernanceModel) slowProtoReflect() protoreflect.Message {
+func (x *_MsgRegisterModel_7_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgRegisterModel_7_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message MsgRegisterModel at list field ModelArgs as it is not of Message kind"))
+}
+
+func (x *_MsgRegisterModel_7_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgRegisterModel_7_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_MsgRegisterModel_7_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_MsgRegisterModel                            protoreflect.MessageDescriptor
+	fd_MsgRegisterModel_authority                  protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_proposed_by                protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_id                         protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_units_of_compute_per_token protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_hf_repo                    protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_hf_commit                  protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_model_args                 protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_v_ram                      protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_throughput_per_nonce       protoreflect.FieldDescriptor
+	fd_MsgRegisterModel_validation_threshold       protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgRegisterModel = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterModel")
+	fd_MsgRegisterModel_authority = md_MsgRegisterModel.Fields().ByName("authority")
+	fd_MsgRegisterModel_proposed_by = md_MsgRegisterModel.Fields().ByName("proposed_by")
+	fd_MsgRegisterModel_id = md_MsgRegisterModel.Fields().ByName("id")
+	fd_MsgRegisterModel_units_of_compute_per_token = md_MsgRegisterModel.Fields().ByName("units_of_compute_per_token")
+	fd_MsgRegisterModel_hf_repo = md_MsgRegisterModel.Fields().ByName("hf_repo")
+	fd_MsgRegisterModel_hf_commit = md_MsgRegisterModel.Fields().ByName("hf_commit")
+	fd_MsgRegisterModel_model_args = md_MsgRegisterModel.Fields().ByName("model_args")
+	fd_MsgRegisterModel_v_ram = md_MsgRegisterModel.Fields().ByName("v_ram")
+	fd_MsgRegisterModel_throughput_per_nonce = md_MsgRegisterModel.Fields().ByName("throughput_per_nonce")
+	fd_MsgRegisterModel_validation_threshold = md_MsgRegisterModel.Fields().ByName("validation_threshold")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgRegisterModel)(nil)
+
+type fastReflection_MsgRegisterModel MsgRegisterModel
+
+func (x *MsgRegisterModel) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterModel)(x)
+}
+
+func (x *MsgRegisterModel) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[32]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -18111,43 +17708,43 @@ func (x *MsgDeleteGovernanceModel) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgDeleteGovernanceModel_messageType fastReflection_MsgDeleteGovernanceModel_messageType
-var _ protoreflect.MessageType = fastReflection_MsgDeleteGovernanceModel_messageType{}
+var _fastReflection_MsgRegisterModel_messageType fastReflection_MsgRegisterModel_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterModel_messageType{}
 
-type fastReflection_MsgDeleteGovernanceModel_messageType struct{}
+type fastReflection_MsgRegisterModel_messageType struct{}
 
-func (x fastReflection_MsgDeleteGovernanceModel_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgDeleteGovernanceModel)(nil)
+func (x fastReflection_MsgRegisterModel_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterModel)(nil)
 }
-func (x fastReflection_MsgDeleteGovernanceModel_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgDeleteGovernanceModel)
+func (x fastReflection_MsgRegisterModel_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterModel)
 }
-func (x fastReflection_MsgDeleteGovernanceModel_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgDeleteGovernanceModel
+func (x fastReflection_MsgRegisterModel_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterModel
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgDeleteGovernanceModel) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgDeleteGovernanceModel
+func (x *fastReflection_MsgRegisterModel) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterModel
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgDeleteGovernanceModel) Type() protoreflect.MessageType {
-	return _fastReflection_MsgDeleteGovernanceModel_messageType
+func (x *fastReflection_MsgRegisterModel) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterModel_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgDeleteGovernanceModel) New() protoreflect.Message {
-	return new(fastReflection_MsgDeleteGovernanceModel)
+func (x *fastReflection_MsgRegisterModel) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterModel)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgDeleteGovernanceModel) Interface() protoreflect.ProtoMessage {
-	return (*MsgDeleteGovernanceModel)(x)
+func (x *fastReflection_MsgRegisterModel) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterModel)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -18155,16 +17752,64 @@ func (x *fastReflection_MsgDeleteGovernanceModel) Interface() protoreflect.Proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgDeleteGovernanceModel) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterModel) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgDeleteGovernanceModel_authority, value) {
+		if !f(fd_MsgRegisterModel_authority, value) {
+			return
+		}
+	}
+	if x.ProposedBy != "" {
+		value := protoreflect.ValueOfString(x.ProposedBy)
+		if !f(fd_MsgRegisterModel_proposed_by, value) {
 			return
 		}
 	}
 	if x.Id != "" {
 		value := protoreflect.ValueOfString(x.Id)
-		if !f(fd_MsgDeleteGovernanceModel_id, value) {
+		if !f(fd_MsgRegisterModel_id, value) {
+			return
+		}
+	}
+	if x.UnitsOfComputePerToken != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.UnitsOfComputePerToken)
+		if !f(fd_MsgRegisterModel_units_of_compute_per_token, value) {
+			return
+		}
+	}
+	if x.HfRepo != "" {
+		value := protoreflect.ValueOfString(x.HfRepo)
+		if !f(fd_MsgRegisterModel_hf_repo, value) {
+			return
+		}
+	}
+	if x.HfCommit != "" {
+		value := protoreflect.ValueOfString(x.HfCommit)
+		if !f(fd_MsgRegisterModel_hf_commit, value) {
+			return
+		}
+	}
+	if len(x.ModelArgs) != 0 {
+		value := protoreflect.ValueOfList(&_MsgRegisterModel_7_list{list: &x.ModelArgs})
+		if !f(fd_MsgRegisterModel_model_args, value) {
+			return
+		}
+	}
+	if x.VRam != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.VRam)
+		if !f(fd_MsgRegisterModel_v_ram, value) {
+			return
+		}
+	}
+	if x.ThroughputPerNonce != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ThroughputPerNonce)
+		if !f(fd_MsgRegisterModel_throughput_per_nonce, value) {
+			return
+		}
+	}
+	if x.ValidationThreshold != nil {
+		value := protoreflect.ValueOfMessage(x.ValidationThreshold.ProtoReflect())
+		if !f(fd_MsgRegisterModel_validation_threshold, value) {
 			return
 		}
 	}
@@ -18181,17 +17826,33 @@ func (x *fastReflection_MsgDeleteGovernanceModel) Range(f func(protoreflect.Fiel
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgDeleteGovernanceModel) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterModel) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgDeleteGovernanceModel.authority":
+	case "inference.inference.MsgRegisterModel.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgDeleteGovernanceModel.id":
+	case "inference.inference.MsgRegisterModel.proposed_by":
+		return x.ProposedBy != ""
+	case "inference.inference.MsgRegisterModel.id":
 		return x.Id != ""
+	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+		return x.UnitsOfComputePerToken != uint64(0)
+	case "inference.inference.MsgRegisterModel.hf_repo":
+		return x.HfRepo != ""
+	case "inference.inference.MsgRegisterModel.hf_commit":
+		return x.HfCommit != ""
+	case "inference.inference.MsgRegisterModel.model_args":
+		return len(x.ModelArgs) != 0
+	case "inference.inference.MsgRegisterModel.v_ram":
+		return x.VRam != uint64(0)
+	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
+		return x.ThroughputPerNonce != uint64(0)
+	case "inference.inference.MsgRegisterModel.validation_threshold":
+		return x.ValidationThreshold != nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18201,17 +17862,33 @@ func (x *fastReflection_MsgDeleteGovernanceModel) Has(fd protoreflect.FieldDescr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModel) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterModel) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgDeleteGovernanceModel.authority":
+	case "inference.inference.MsgRegisterModel.authority":
 		x.Authority = ""
-	case "inference.inference.MsgDeleteGovernanceModel.id":
+	case "inference.inference.MsgRegisterModel.proposed_by":
+		x.ProposedBy = ""
+	case "inference.inference.MsgRegisterModel.id":
 		x.Id = ""
+	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+		x.UnitsOfComputePerToken = uint64(0)
+	case "inference.inference.MsgRegisterModel.hf_repo":
+		x.HfRepo = ""
+	case "inference.inference.MsgRegisterModel.hf_commit":
+		x.HfCommit = ""
+	case "inference.inference.MsgRegisterModel.model_args":
+		x.ModelArgs = nil
+	case "inference.inference.MsgRegisterModel.v_ram":
+		x.VRam = uint64(0)
+	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
+		x.ThroughputPerNonce = uint64(0)
+	case "inference.inference.MsgRegisterModel.validation_threshold":
+		x.ValidationThreshold = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18221,19 +17898,46 @@ func (x *fastReflection_MsgDeleteGovernanceModel) Clear(fd protoreflect.FieldDes
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgDeleteGovernanceModel) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterModel) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgDeleteGovernanceModel.authority":
+	case "inference.inference.MsgRegisterModel.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgDeleteGovernanceModel.id":
+	case "inference.inference.MsgRegisterModel.proposed_by":
+		value := x.ProposedBy
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterModel.id":
 		value := x.Id
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+		value := x.UnitsOfComputePerToken
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgRegisterModel.hf_repo":
+		value := x.HfRepo
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterModel.hf_commit":
+		value := x.HfCommit
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterModel.model_args":
+		if len(x.ModelArgs) == 0 {
+			return protoreflect.ValueOfList(&_MsgRegisterModel_7_list{})
+		}
+		listValue := &_MsgRegisterModel_7_list{list: &x.ModelArgs}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgRegisterModel.v_ram":
+		value := x.VRam
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
+		value := x.ThroughputPerNonce
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgRegisterModel.validation_threshold":
+		value := x.ValidationThreshold
+		return protoreflect.ValueOfMessage(value.ProtoReflect())
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -18247,17 +17951,35 @@ func (x *fastReflection_MsgDeleteGovernanceModel) Get(descriptor protoreflect.Fi
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModel) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterModel) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgDeleteGovernanceModel.authority":
+	case "inference.inference.MsgRegisterModel.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgDeleteGovernanceModel.id":
+	case "inference.inference.MsgRegisterModel.proposed_by":
+		x.ProposedBy = value.Interface().(string)
+	case "inference.inference.MsgRegisterModel.id":
 		x.Id = value.Interface().(string)
+	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+		x.UnitsOfComputePerToken = value.Uint()
+	case "inference.inference.MsgRegisterModel.hf_repo":
+		x.HfRepo = value.Interface().(string)
+	case "inference.inference.MsgRegisterModel.hf_commit":
+		x.HfCommit = value.Interface().(string)
+	case "inference.inference.MsgRegisterModel.model_args":
+		lv := value.List()
+		clv := lv.(*_MsgRegisterModel_7_list)
+		x.ModelArgs = *clv.list
+	case "inference.inference.MsgRegisterModel.v_ram":
+		x.VRam = value.Uint()
+	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
+		x.ThroughputPerNonce = value.Uint()
+	case "inference.inference.MsgRegisterModel.validation_threshold":
+		x.ValidationThreshold = value.Message().Interface().(*Decimal)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18271,44 +17993,85 @@ func (x *fastReflection_MsgDeleteGovernanceModel) Set(fd protoreflect.FieldDescr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModel) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterModel) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgDeleteGovernanceModel.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgDeleteGovernanceModel is not mutable"))
-	case "inference.inference.MsgDeleteGovernanceModel.id":
-		panic(fmt.Errorf("field id of message inference.inference.MsgDeleteGovernanceModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.model_args":
+		if x.ModelArgs == nil {
+			x.ModelArgs = []string{}
+		}
+		value := &_MsgRegisterModel_7_list{list: &x.ModelArgs}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgRegisterModel.validation_threshold":
+		if x.ValidationThreshold == nil {
+			x.ValidationThreshold = new(Decimal)
+		}
+		return protoreflect.ValueOfMessage(x.ValidationThreshold.ProtoReflect())
+	case "inference.inference.MsgRegisterModel.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.proposed_by":
+		panic(fmt.Errorf("field proposed_by of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.id":
+		panic(fmt.Errorf("field id of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+		panic(fmt.Errorf("field units_of_compute_per_token of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.hf_repo":
+		panic(fmt.Errorf("field hf_repo of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.hf_commit":
+		panic(fmt.Errorf("field hf_commit of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.v_ram":
+		panic(fmt.Errorf("field v_ram of message inference.inference.MsgRegisterModel is not mutable"))
+	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
+		panic(fmt.Errorf("field throughput_per_nonce of message inference.inference.MsgRegisterModel is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgDeleteGovernanceModel) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterModel) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgDeleteGovernanceModel.authority":
+	case "inference.inference.MsgRegisterModel.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgDeleteGovernanceModel.id":
+	case "inference.inference.MsgRegisterModel.proposed_by":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterModel.id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterModel.units_of_compute_per_token":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgRegisterModel.hf_repo":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterModel.hf_commit":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterModel.model_args":
+		list := []string{}
+		return protoreflect.ValueOfList(&_MsgRegisterModel_7_list{list: &list})
+	case "inference.inference.MsgRegisterModel.v_ram":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgRegisterModel.throughput_per_nonce":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgRegisterModel.validation_threshold":
+		m := new(Decimal)
+		return protoreflect.ValueOfMessage(m.ProtoReflect())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModel does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgDeleteGovernanceModel) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterModel) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgDeleteGovernanceModel", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterModel", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -18316,7 +18079,7 @@ func (x *fastReflection_MsgDeleteGovernanceModel) WhichOneof(d protoreflect.Oneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgDeleteGovernanceModel) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterModel) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -18327,7 +18090,7 @@ func (x *fastReflection_MsgDeleteGovernanceModel) GetUnknown() protoreflect.RawF
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModel) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterModel) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -18339,7 +18102,7 @@ func (x *fastReflection_MsgDeleteGovernanceModel) SetUnknown(fields protoreflect
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgDeleteGovernanceModel) IsValid() bool {
+func (x *fastReflection_MsgRegisterModel) IsValid() bool {
 	return x != nil
 }
 
@@ -18349,9 +18112,9 @@ func (x *fastReflection_MsgDeleteGovernanceModel) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterModel) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgDeleteGovernanceModel)
+		x := input.Message.Interface().(*MsgRegisterModel)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18367,10 +18130,41 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		l = len(x.ProposedBy)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		l = len(x.Id)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		if x.UnitsOfComputePerToken != 0 {
+			n += 1 + runtime.Sov(uint64(x.UnitsOfComputePerToken))
+		}
+		l = len(x.HfRepo)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.HfCommit)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.ModelArgs) > 0 {
+			for _, s := range x.ModelArgs {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.VRam != 0 {
+			n += 1 + runtime.Sov(uint64(x.VRam))
+		}
+		if x.ThroughputPerNonce != 0 {
+			n += 1 + runtime.Sov(uint64(x.ThroughputPerNonce))
+		}
+		if x.ValidationThreshold != nil {
+			l = options.Size(x.ValidationThreshold)
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -18381,7 +18175,7 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgDeleteGovernanceModel)
+		x := input.Message.Interface().(*MsgRegisterModel)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18400,11 +18194,70 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.ValidationThreshold != nil {
+			encoded, err := options.Marshal(x.ValidationThreshold)
+			if err != nil {
+				return protoiface.MarshalOutput{
+					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+					Buf:               input.Buf,
+				}, err
+			}
+			i -= len(encoded)
+			copy(dAtA[i:], encoded)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			i--
+			dAtA[i] = 0x52
+		}
+		if x.ThroughputPerNonce != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ThroughputPerNonce))
+			i--
+			dAtA[i] = 0x48
+		}
+		if x.VRam != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.VRam))
+			i--
+			dAtA[i] = 0x40
+		}
+		if len(x.ModelArgs) > 0 {
+			for iNdEx := len(x.ModelArgs) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.ModelArgs[iNdEx])
+				copy(dAtA[i:], x.ModelArgs[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelArgs[iNdEx])))
+				i--
+				dAtA[i] = 0x3a
+			}
+		}
+		if len(x.HfCommit) > 0 {
+			i -= len(x.HfCommit)
+			copy(dAtA[i:], x.HfCommit)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HfCommit)))
+			i--
+			dAtA[i] = 0x32
+		}
+		if len(x.HfRepo) > 0 {
+			i -= len(x.HfRepo)
+			copy(dAtA[i:], x.HfRepo)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.HfRepo)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if x.UnitsOfComputePerToken != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.UnitsOfComputePerToken))
+			i--
+			dAtA[i] = 0x20
+		}
 		if len(x.Id) > 0 {
 			i -= len(x.Id)
 			copy(dAtA[i:], x.Id)
 			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
 			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ProposedBy) > 0 {
+			i -= len(x.ProposedBy)
+			copy(dAtA[i:], x.ProposedBy)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposedBy)))
+			i--
 			dAtA[i] = 0x12
 		}
 		if len(x.Authority) > 0 {
@@ -18425,7 +18278,7 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgDeleteGovernanceModel)
+		x := input.Message.Interface().(*MsgRegisterModel)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18457,10 +18310,10 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModel: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModel: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModel: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModel: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -18497,7 +18350,7 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposedBy", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -18525,27 +18378,248 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Id = string(dAtA[iNdEx:postIndex])
+				x.ProposedBy = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			default:
-				iNdEx = preIndex
-				skippy, err := runtime.Skip(dAtA[iNdEx:])
-				if err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
 				}
-				if (skippy < 0) || (iNdEx+skippy) < 0 {
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				if (iNdEx + skippy) > l {
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				if !options.DiscardUnknown {
-					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				x.Id = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UnitsOfComputePerToken", wireType)
 				}
-				iNdEx += skippy
-			}
-		}
-
+				x.UnitsOfComputePerToken = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.UnitsOfComputePerToken |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HfRepo", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.HfRepo = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HfCommit", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.HfCommit = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelArgs", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ModelArgs = append(x.ModelArgs, string(dAtA[iNdEx:postIndex]))
+				iNdEx = postIndex
+			case 8:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field VRam", wireType)
+				}
+				x.VRam = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.VRam |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 9:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ThroughputPerNonce", wireType)
+				}
+				x.ThroughputPerNonce = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ThroughputPerNonce |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 10:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidationThreshold", wireType)
+				}
+				var msglen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					msglen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if x.ValidationThreshold == nil {
+					x.ValidationThreshold = &Decimal{}
+				}
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ValidationThreshold); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
 		if iNdEx > l {
 			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 		}
@@ -18563,23 +18637,23 @@ func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Met
 }
 
 var (
-	md_MsgDeleteGovernanceModelResponse protoreflect.MessageDescriptor
+	md_MsgRegisterModelResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgDeleteGovernanceModelResponse = File_inference_inference_tx_proto.Messages().ByName("MsgDeleteGovernanceModelResponse")
+	md_MsgRegisterModelResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterModelResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgDeleteGovernanceModelResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterModelResponse)(nil)
 
-type fastReflection_MsgDeleteGovernanceModelResponse MsgDeleteGovernanceModelResponse
+type fastReflection_MsgRegisterModelResponse MsgRegisterModelResponse
 
-func (x *MsgDeleteGovernanceModelResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgDeleteGovernanceModelResponse)(x)
+func (x *MsgRegisterModelResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterModelResponse)(x)
 }
 
-func (x *MsgDeleteGovernanceModelResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgRegisterModelResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[33]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -18591,43 +18665,43 @@ func (x *MsgDeleteGovernanceModelResponse) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgDeleteGovernanceModelResponse_messageType fastReflection_MsgDeleteGovernanceModelResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgDeleteGovernanceModelResponse_messageType{}
+var _fastReflection_MsgRegisterModelResponse_messageType fastReflection_MsgRegisterModelResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterModelResponse_messageType{}
 
-type fastReflection_MsgDeleteGovernanceModelResponse_messageType struct{}
+type fastReflection_MsgRegisterModelResponse_messageType struct{}
 
-func (x fastReflection_MsgDeleteGovernanceModelResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgDeleteGovernanceModelResponse)(nil)
+func (x fastReflection_MsgRegisterModelResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterModelResponse)(nil)
 }
-func (x fastReflection_MsgDeleteGovernanceModelResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgDeleteGovernanceModelResponse)
+func (x fastReflection_MsgRegisterModelResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterModelResponse)
 }
-func (x fastReflection_MsgDeleteGovernanceModelResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgDeleteGovernanceModelResponse
+func (x fastReflection_MsgRegisterModelResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterModelResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgDeleteGovernanceModelResponse
+func (x *fastReflection_MsgRegisterModelResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterModelResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgDeleteGovernanceModelResponse_messageType
+func (x *fastReflection_MsgRegisterModelResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterModelResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgDeleteGovernanceModelResponse)
+func (x *fastReflection_MsgRegisterModelResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterModelResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgDeleteGovernanceModelResponse)(x)
+func (x *fastReflection_MsgRegisterModelResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterModelResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -18635,7 +18709,7 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterModelResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -18649,13 +18723,13 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterModelResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18665,13 +18739,13 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterModelResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18681,13 +18755,13 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterModelResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -18701,13 +18775,13 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterModelResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -18721,36 +18795,36 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterModelResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterModelResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterModelResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgDeleteGovernanceModelResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterModelResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -18758,7 +18832,7 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterModelResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -18769,7 +18843,7 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterModelResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -18781,7 +18855,7 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) IsValid() bool {
+func (x *fastReflection_MsgRegisterModelResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -18791,9 +18865,9 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgDeleteGovernanceModelResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterModelResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgDeleteGovernanceModelResponse)
+		x := input.Message.Interface().(*MsgRegisterModelResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18815,7 +18889,7 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgDeleteGovernanceModelResponse)
+		x := input.Message.Interface().(*MsgRegisterModelResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18845,7 +18919,7 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgDeleteGovernanceModelResponse)
+		x := input.Message.Interface().(*MsgRegisterModelResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -18877,10 +18951,10 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModelResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModelResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterModelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -18918,132 +18992,28 @@ func (x *fastReflection_MsgDeleteGovernanceModelResponse) ProtoMethods() *protoi
 	}
 }
 
-var _ protoreflect.List = (*_MsgSubmitHardwareDiff_2_list)(nil)
-
-type _MsgSubmitHardwareDiff_2_list struct {
-	list *[]*HardwareNode
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) AppendMutable() protoreflect.Value {
-	v := new(HardwareNode)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) NewElement() protoreflect.Value {
-	v := new(HardwareNode)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSubmitHardwareDiff_2_list) IsValid() bool {
-	return x.list != nil
-}
-
-var _ protoreflect.List = (*_MsgSubmitHardwareDiff_3_list)(nil)
-
-type _MsgSubmitHardwareDiff_3_list struct {
-	list *[]*HardwareNode
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) AppendMutable() protoreflect.Value {
-	v := new(HardwareNode)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) NewElement() protoreflect.Value {
-	v := new(HardwareNode)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSubmitHardwareDiff_3_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MsgSubmitHardwareDiff               protoreflect.MessageDescriptor
-	fd_MsgSubmitHardwareDiff_creator       protoreflect.FieldDescriptor
-	fd_MsgSubmitHardwareDiff_newOrModified protoreflect.FieldDescriptor
-	fd_MsgSubmitHardwareDiff_removed       protoreflect.FieldDescriptor
+	md_MsgDeleteGovernanceModel           protoreflect.MessageDescriptor
+	fd_MsgDeleteGovernanceModel_authority protoreflect.FieldDescriptor
+	fd_MsgDeleteGovernanceModel_id        protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitHardwareDiff = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitHardwareDiff")
-	fd_MsgSubmitHardwareDiff_creator = md_MsgSubmitHardwareDiff.Fields().ByName("creator")
-	fd_MsgSubmitHardwareDiff_newOrModified = md_MsgSubmitHardwareDiff.Fields().ByName("newOrModified")
-	fd_MsgSubmitHardwareDiff_removed = md_MsgSubmitHardwareDiff.Fields().ByName("removed")
+	md_MsgDeleteGovernanceModel = File_inference_inference_tx_proto.Messages().ByName("MsgDeleteGovernanceModel")
+	fd_MsgDeleteGovernanceModel_authority = md_MsgDeleteGovernanceModel.Fields().ByName("authority")
+	fd_MsgDeleteGovernanceModel_id = md_MsgDeleteGovernanceModel.Fields().ByName("id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitHardwareDiff)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgDeleteGovernanceModel)(nil)
 
-type fastReflection_MsgSubmitHardwareDiff MsgSubmitHardwareDiff
+type fastReflection_MsgDeleteGovernanceModel MsgDeleteGovernanceModel
 
-func (x *MsgSubmitHardwareDiff) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitHardwareDiff)(x)
+func (x *MsgDeleteGovernanceModel) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgDeleteGovernanceModel)(x)
 }
 
-func (x *MsgSubmitHardwareDiff) slowProtoReflect() protoreflect.Message {
+func (x *MsgDeleteGovernanceModel) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[34]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -19055,43 +19025,43 @@ func (x *MsgSubmitHardwareDiff) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitHardwareDiff_messageType fastReflection_MsgSubmitHardwareDiff_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitHardwareDiff_messageType{}
+var _fastReflection_MsgDeleteGovernanceModel_messageType fastReflection_MsgDeleteGovernanceModel_messageType
+var _ protoreflect.MessageType = fastReflection_MsgDeleteGovernanceModel_messageType{}
 
-type fastReflection_MsgSubmitHardwareDiff_messageType struct{}
+type fastReflection_MsgDeleteGovernanceModel_messageType struct{}
 
-func (x fastReflection_MsgSubmitHardwareDiff_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitHardwareDiff)(nil)
+func (x fastReflection_MsgDeleteGovernanceModel_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgDeleteGovernanceModel)(nil)
 }
-func (x fastReflection_MsgSubmitHardwareDiff_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitHardwareDiff)
+func (x fastReflection_MsgDeleteGovernanceModel_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgDeleteGovernanceModel)
 }
-func (x fastReflection_MsgSubmitHardwareDiff_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitHardwareDiff
+func (x fastReflection_MsgDeleteGovernanceModel_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDeleteGovernanceModel
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitHardwareDiff) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitHardwareDiff
+func (x *fastReflection_MsgDeleteGovernanceModel) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDeleteGovernanceModel
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitHardwareDiff) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitHardwareDiff_messageType
+func (x *fastReflection_MsgDeleteGovernanceModel) Type() protoreflect.MessageType {
+	return _fastReflection_MsgDeleteGovernanceModel_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitHardwareDiff) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitHardwareDiff)
+func (x *fastReflection_MsgDeleteGovernanceModel) New() protoreflect.Message {
+	return new(fastReflection_MsgDeleteGovernanceModel)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitHardwareDiff) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitHardwareDiff)(x)
+func (x *fastReflection_MsgDeleteGovernanceModel) Interface() protoreflect.ProtoMessage {
+	return (*MsgDeleteGovernanceModel)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -19099,22 +19069,16 @@ func (x *fastReflection_MsgSubmitHardwareDiff) Interface() protoreflect.ProtoMes
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitHardwareDiff) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Creator != "" {
-		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgSubmitHardwareDiff_creator, value) {
-			return
-		}
-	}
-	if len(x.NewOrModified) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_2_list{list: &x.NewOrModified})
-		if !f(fd_MsgSubmitHardwareDiff_newOrModified, value) {
+func (x *fastReflection_MsgDeleteGovernanceModel) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgDeleteGovernanceModel_authority, value) {
 			return
 		}
 	}
-	if len(x.Removed) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_3_list{list: &x.Removed})
-		if !f(fd_MsgSubmitHardwareDiff_removed, value) {
+	if x.Id != "" {
+		value := protoreflect.ValueOfString(x.Id)
+		if !f(fd_MsgDeleteGovernanceModel_id, value) {
 			return
 		}
 	}
@@ -19131,19 +19095,17 @@ func (x *fastReflection_MsgSubmitHardwareDiff) Range(f func(protoreflect.FieldDe
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitHardwareDiff) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgDeleteGovernanceModel) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitHardwareDiff.creator":
-		return x.Creator != ""
-	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
-		return len(x.NewOrModified) != 0
-	case "inference.inference.MsgSubmitHardwareDiff.removed":
-		return len(x.Removed) != 0
+	case "inference.inference.MsgDeleteGovernanceModel.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgDeleteGovernanceModel.id":
+		return x.Id != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19153,19 +19115,17 @@ func (x *fastReflection_MsgSubmitHardwareDiff) Has(fd protoreflect.FieldDescript
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiff) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgDeleteGovernanceModel) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitHardwareDiff.creator":
-		x.Creator = ""
-	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
-		x.NewOrModified = nil
-	case "inference.inference.MsgSubmitHardwareDiff.removed":
-		x.Removed = nil
+	case "inference.inference.MsgDeleteGovernanceModel.authority":
+		x.Authority = ""
+	case "inference.inference.MsgDeleteGovernanceModel.id":
+		x.Id = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19175,28 +19135,19 @@ func (x *fastReflection_MsgSubmitHardwareDiff) Clear(fd protoreflect.FieldDescri
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitHardwareDiff) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDeleteGovernanceModel) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSubmitHardwareDiff.creator":
-		value := x.Creator
+	case "inference.inference.MsgDeleteGovernanceModel.authority":
+		value := x.Authority
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgDeleteGovernanceModel.id":
+		value := x.Id
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
-		if len(x.NewOrModified) == 0 {
-			return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_2_list{})
-		}
-		listValue := &_MsgSubmitHardwareDiff_2_list{list: &x.NewOrModified}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgSubmitHardwareDiff.removed":
-		if len(x.Removed) == 0 {
-			return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_3_list{})
-		}
-		listValue := &_MsgSubmitHardwareDiff_3_list{list: &x.Removed}
-		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -19210,23 +19161,17 @@ func (x *fastReflection_MsgSubmitHardwareDiff) Get(descriptor protoreflect.Field
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiff) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgDeleteGovernanceModel) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitHardwareDiff.creator":
-		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
-		lv := value.List()
-		clv := lv.(*_MsgSubmitHardwareDiff_2_list)
-		x.NewOrModified = *clv.list
-	case "inference.inference.MsgSubmitHardwareDiff.removed":
-		lv := value.List()
-		clv := lv.(*_MsgSubmitHardwareDiff_3_list)
-		x.Removed = *clv.list
+	case "inference.inference.MsgDeleteGovernanceModel.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgDeleteGovernanceModel.id":
+		x.Id = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19240,58 +19185,44 @@ func (x *fastReflection_MsgSubmitHardwareDiff) Set(fd protoreflect.FieldDescript
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiff) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDeleteGovernanceModel) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
-		if x.NewOrModified == nil {
-			x.NewOrModified = []*HardwareNode{}
-		}
-		value := &_MsgSubmitHardwareDiff_2_list{list: &x.NewOrModified}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSubmitHardwareDiff.removed":
-		if x.Removed == nil {
-			x.Removed = []*HardwareNode{}
-		}
-		value := &_MsgSubmitHardwareDiff_3_list{list: &x.Removed}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSubmitHardwareDiff.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitHardwareDiff is not mutable"))
+	case "inference.inference.MsgDeleteGovernanceModel.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgDeleteGovernanceModel is not mutable"))
+	case "inference.inference.MsgDeleteGovernanceModel.id":
+		panic(fmt.Errorf("field id of message inference.inference.MsgDeleteGovernanceModel is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitHardwareDiff) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDeleteGovernanceModel) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSubmitHardwareDiff.creator":
+	case "inference.inference.MsgDeleteGovernanceModel.authority":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgDeleteGovernanceModel.id":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
-		list := []*HardwareNode{}
-		return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_2_list{list: &list})
-	case "inference.inference.MsgSubmitHardwareDiff.removed":
-		list := []*HardwareNode{}
-		return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_3_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModel"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModel does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitHardwareDiff) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgDeleteGovernanceModel) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitHardwareDiff", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgDeleteGovernanceModel", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -19299,7 +19230,7 @@ func (x *fastReflection_MsgSubmitHardwareDiff) WhichOneof(d protoreflect.OneofDe
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitHardwareDiff) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgDeleteGovernanceModel) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -19310,7 +19241,7 @@ func (x *fastReflection_MsgSubmitHardwareDiff) GetUnknown() protoreflect.RawFiel
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiff) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgDeleteGovernanceModel) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -19322,7 +19253,7 @@ func (x *fastReflection_MsgSubmitHardwareDiff) SetUnknown(fields protoreflect.Ra
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitHardwareDiff) IsValid() bool {
+func (x *fastReflection_MsgDeleteGovernanceModel) IsValid() bool {
 	return x != nil
 }
 
@@ -19332,9 +19263,9 @@ func (x *fastReflection_MsgSubmitHardwareDiff) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgDeleteGovernanceModel) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitHardwareDiff)
+		x := input.Message.Interface().(*MsgDeleteGovernanceModel)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19346,21 +19277,13 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 		var n int
 		var l int
 		_ = l
-		l = len(x.Creator)
+		l = len(x.Authority)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if len(x.NewOrModified) > 0 {
-			for _, e := range x.NewOrModified {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if len(x.Removed) > 0 {
-			for _, e := range x.Removed {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		l = len(x.Id)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -19372,7 +19295,7 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitHardwareDiff)
+		x := input.Message.Interface().(*MsgDeleteGovernanceModel)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19391,42 +19314,17 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Removed) > 0 {
-			for iNdEx := len(x.Removed) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Removed[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x1a
-			}
-		}
-		if len(x.NewOrModified) > 0 {
-			for iNdEx := len(x.NewOrModified) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.NewOrModified[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x12
-			}
+		if len(x.Id) > 0 {
+			i -= len(x.Id)
+			copy(dAtA[i:], x.Id)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
+			i--
+			dAtA[i] = 0x12
 		}
-		if len(x.Creator) > 0 {
-			i -= len(x.Creator)
-			copy(dAtA[i:], x.Creator)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -19441,7 +19339,7 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitHardwareDiff)
+		x := input.Message.Interface().(*MsgDeleteGovernanceModel)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19473,15 +19371,15 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiff: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModel: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiff: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModel: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -19509,47 +19407,13 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Creator = string(dAtA[iNdEx:postIndex])
+				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewOrModified", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.NewOrModified = append(x.NewOrModified, &HardwareNode{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.NewOrModified[len(x.NewOrModified)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Removed", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
 				}
-				var msglen int
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -19559,25 +19423,23 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + msglen
+				postIndex := iNdEx + intStringLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Removed = append(x.Removed, &HardwareNode{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Removed[len(x.Removed)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
+				x.Id = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -19615,23 +19477,23 @@ func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Method
 }
 
 var (
-	md_MsgSubmitHardwareDiffResponse protoreflect.MessageDescriptor
+	md_MsgDeleteGovernanceModelResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSubmitHardwareDiffResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitHardwareDiffResponse")
+	md_MsgDeleteGovernanceModelResponse = File_inference_inference_tx_proto.Messages().ByName("MsgDeleteGovernanceModelResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSubmitHardwareDiffResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgDeleteGovernanceModelResponse)(nil)
 
-type fastReflection_MsgSubmitHardwareDiffResponse MsgSubmitHardwareDiffResponse
+type fastReflection_MsgDeleteGovernanceModelResponse MsgDeleteGovernanceModelResponse
 
-func (x *MsgSubmitHardwareDiffResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSubmitHardwareDiffResponse)(x)
+func (x *MsgDeleteGovernanceModelResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgDeleteGovernanceModelResponse)(x)
 }
 
-func (x *MsgSubmitHardwareDiffResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgDeleteGovernanceModelResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[35]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -19643,43 +19505,43 @@ func (x *MsgSubmitHardwareDiffResponse) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSubmitHardwareDiffResponse_messageType fastReflection_MsgSubmitHardwareDiffResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSubmitHardwareDiffResponse_messageType{}
+var _fastReflection_MsgDeleteGovernanceModelResponse_messageType fastReflection_MsgDeleteGovernanceModelResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgDeleteGovernanceModelResponse_messageType{}
 
-type fastReflection_MsgSubmitHardwareDiffResponse_messageType struct{}
+type fastReflection_MsgDeleteGovernanceModelResponse_messageType struct{}
 
-func (x fastReflection_MsgSubmitHardwareDiffResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSubmitHardwareDiffResponse)(nil)
+func (x fastReflection_MsgDeleteGovernanceModelResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgDeleteGovernanceModelResponse)(nil)
 }
-func (x fastReflection_MsgSubmitHardwareDiffResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitHardwareDiffResponse)
+func (x fastReflection_MsgDeleteGovernanceModelResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgDeleteGovernanceModelResponse)
 }
-func (x fastReflection_MsgSubmitHardwareDiffResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitHardwareDiffResponse
+func (x fastReflection_MsgDeleteGovernanceModelResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDeleteGovernanceModelResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSubmitHardwareDiffResponse
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgDeleteGovernanceModelResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSubmitHardwareDiffResponse_messageType
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgDeleteGovernanceModelResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgSubmitHardwareDiffResponse)
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgDeleteGovernanceModelResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgSubmitHardwareDiffResponse)(x)
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgDeleteGovernanceModelResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -19687,7 +19549,7 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -19701,13 +19563,13 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19717,13 +19579,13 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19733,13 +19595,13 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -19753,13 +19615,13 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -19773,36 +19635,36 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgDeleteGovernanceModelResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgDeleteGovernanceModelResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitHardwareDiffResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgDeleteGovernanceModelResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -19810,7 +19672,7 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -19821,7 +19683,7 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -19833,7 +19695,7 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) IsValid() bool {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -19843,9 +19705,9 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSubmitHardwareDiffResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgDeleteGovernanceModelResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSubmitHardwareDiffResponse)
+		x := input.Message.Interface().(*MsgDeleteGovernanceModelResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19867,7 +19729,7 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitHardwareDiffResponse)
+		x := input.Message.Interface().(*MsgDeleteGovernanceModelResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19897,7 +19759,7 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSubmitHardwareDiffResponse)
+		x := input.Message.Interface().(*MsgDeleteGovernanceModelResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -19929,10 +19791,10 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiffResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModelResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiffResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDeleteGovernanceModelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -19970,32 +19832,132 @@ func (x *fastReflection_MsgSubmitHardwareDiffResponse) ProtoMethods() *protoifac
 	}
 }
 
+var _ protoreflect.List = (*_MsgSubmitHardwareDiff_2_list)(nil)
+
+type _MsgSubmitHardwareDiff_2_list struct {
+	list *[]*HardwareNode
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) AppendMutable() protoreflect.Value {
+	v := new(HardwareNode)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) NewElement() protoreflect.Value {
+	v := new(HardwareNode)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSubmitHardwareDiff_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_MsgSubmitHardwareDiff_3_list)(nil)
+
+type _MsgSubmitHardwareDiff_3_list struct {
+	list *[]*HardwareNode
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*HardwareNode)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) AppendMutable() protoreflect.Value {
+	v := new(HardwareNode)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) NewElement() protoreflect.Value {
+	v := new(HardwareNode)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSubmitHardwareDiff_3_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_MsgCreatePartialUpgrade                 protoreflect.MessageDescriptor
-	fd_MsgCreatePartialUpgrade_authority       protoreflect.FieldDescriptor
-	fd_MsgCreatePartialUpgrade_height          protoreflect.FieldDescriptor
-	fd_MsgCreatePartialUpgrade_nodeVersion     protoreflect.FieldDescriptor
-	fd_MsgCreatePartialUpgrade_apiBinariesJson protoreflect.FieldDescriptor
+	md_MsgSubmitHardwareDiff               protoreflect.MessageDescriptor
+	fd_MsgSubmitHardwareDiff_creator       protoreflect.FieldDescriptor
+	fd_MsgSubmitHardwareDiff_newOrModified protoreflect.FieldDescriptor
+	fd_MsgSubmitHardwareDiff_removed       protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgCreatePartialUpgrade = File_inference_inference_tx_proto.Messages().ByName("MsgCreatePartialUpgrade")
-	fd_MsgCreatePartialUpgrade_authority = md_MsgCreatePartialUpgrade.Fields().ByName("authority")
-	fd_MsgCreatePartialUpgrade_height = md_MsgCreatePartialUpgrade.Fields().ByName("height")
-	fd_MsgCreatePartialUpgrade_nodeVersion = md_MsgCreatePartialUpgrade.Fields().ByName("nodeVersion")
-	fd_MsgCreatePartialUpgrade_apiBinariesJson = md_MsgCreatePartialUpgrade.Fields().ByName("apiBinariesJson")
+	md_MsgSubmitHardwareDiff = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitHardwareDiff")
+	fd_MsgSubmitHardwareDiff_creator = md_MsgSubmitHardwareDiff.Fields().ByName("creator")
+	fd_MsgSubmitHardwareDiff_newOrModified = md_MsgSubmitHardwareDiff.Fields().ByName("newOrModified")
+	fd_MsgSubmitHardwareDiff_removed = md_MsgSubmitHardwareDiff.Fields().ByName("removed")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgCreatePartialUpgrade)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitHardwareDiff)(nil)
 
-type fastReflection_MsgCreatePartialUpgrade MsgCreatePartialUpgrade
+type fastReflection_MsgSubmitHardwareDiff MsgSubmitHardwareDiff
 
-func (x *MsgCreatePartialUpgrade) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgCreatePartialUpgrade)(x)
+func (x *MsgSubmitHardwareDiff) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitHardwareDiff)(x)
 }
 
-func (x *MsgCreatePartialUpgrade) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitHardwareDiff) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[36]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -20007,43 +19969,43 @@ func (x *MsgCreatePartialUpgrade) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgCreatePartialUpgrade_messageType fastReflection_MsgCreatePartialUpgrade_messageType
-var _ protoreflect.MessageType = fastReflection_MsgCreatePartialUpgrade_messageType{}
+var _fastReflection_MsgSubmitHardwareDiff_messageType fastReflection_MsgSubmitHardwareDiff_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitHardwareDiff_messageType{}
 
-type fastReflection_MsgCreatePartialUpgrade_messageType struct{}
+type fastReflection_MsgSubmitHardwareDiff_messageType struct{}
 
-func (x fastReflection_MsgCreatePartialUpgrade_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgCreatePartialUpgrade)(nil)
+func (x fastReflection_MsgSubmitHardwareDiff_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitHardwareDiff)(nil)
 }
-func (x fastReflection_MsgCreatePartialUpgrade_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgCreatePartialUpgrade)
+func (x fastReflection_MsgSubmitHardwareDiff_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitHardwareDiff)
 }
-func (x fastReflection_MsgCreatePartialUpgrade_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreatePartialUpgrade
+func (x fastReflection_MsgSubmitHardwareDiff_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitHardwareDiff
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgCreatePartialUpgrade) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreatePartialUpgrade
+func (x *fastReflection_MsgSubmitHardwareDiff) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitHardwareDiff
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgCreatePartialUpgrade) Type() protoreflect.MessageType {
-	return _fastReflection_MsgCreatePartialUpgrade_messageType
+func (x *fastReflection_MsgSubmitHardwareDiff) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitHardwareDiff_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgCreatePartialUpgrade) New() protoreflect.Message {
-	return new(fastReflection_MsgCreatePartialUpgrade)
+func (x *fastReflection_MsgSubmitHardwareDiff) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitHardwareDiff)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgCreatePartialUpgrade) Interface() protoreflect.ProtoMessage {
-	return (*MsgCreatePartialUpgrade)(x)
+func (x *fastReflection_MsgSubmitHardwareDiff) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitHardwareDiff)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -20051,28 +20013,22 @@ func (x *fastReflection_MsgCreatePartialUpgrade) Interface() protoreflect.ProtoM
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgCreatePartialUpgrade) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgCreatePartialUpgrade_authority, value) {
-			return
-		}
-	}
-	if x.Height != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Height)
-		if !f(fd_MsgCreatePartialUpgrade_height, value) {
+func (x *fastReflection_MsgSubmitHardwareDiff) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgSubmitHardwareDiff_creator, value) {
 			return
 		}
 	}
-	if x.NodeVersion != "" {
-		value := protoreflect.ValueOfString(x.NodeVersion)
-		if !f(fd_MsgCreatePartialUpgrade_nodeVersion, value) {
+	if len(x.NewOrModified) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_2_list{list: &x.NewOrModified})
+		if !f(fd_MsgSubmitHardwareDiff_newOrModified, value) {
 			return
 		}
 	}
-	if x.ApiBinariesJson != "" {
-		value := protoreflect.ValueOfString(x.ApiBinariesJson)
-		if !f(fd_MsgCreatePartialUpgrade_apiBinariesJson, value) {
+	if len(x.Removed) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_3_list{list: &x.Removed})
+		if !f(fd_MsgSubmitHardwareDiff_removed, value) {
 			return
 		}
 	}
@@ -20089,21 +20045,19 @@ func (x *fastReflection_MsgCreatePartialUpgrade) Range(f func(protoreflect.Field
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgCreatePartialUpgrade) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitHardwareDiff) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreatePartialUpgrade.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgCreatePartialUpgrade.height":
-		return x.Height != uint64(0)
-	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
-		return x.NodeVersion != ""
-	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
-		return x.ApiBinariesJson != ""
+	case "inference.inference.MsgSubmitHardwareDiff.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
+		return len(x.NewOrModified) != 0
+	case "inference.inference.MsgSubmitHardwareDiff.removed":
+		return len(x.Removed) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20113,21 +20067,19 @@ func (x *fastReflection_MsgCreatePartialUpgrade) Has(fd protoreflect.FieldDescri
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgrade) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitHardwareDiff) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreatePartialUpgrade.authority":
-		x.Authority = ""
-	case "inference.inference.MsgCreatePartialUpgrade.height":
-		x.Height = uint64(0)
-	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
-		x.NodeVersion = ""
-	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
-		x.ApiBinariesJson = ""
+	case "inference.inference.MsgSubmitHardwareDiff.creator":
+		x.Creator = ""
+	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
+		x.NewOrModified = nil
+	case "inference.inference.MsgSubmitHardwareDiff.removed":
+		x.Removed = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20137,25 +20089,28 @@ func (x *fastReflection_MsgCreatePartialUpgrade) Clear(fd protoreflect.FieldDesc
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgCreatePartialUpgrade) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitHardwareDiff) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgCreatePartialUpgrade.authority":
-		value := x.Authority
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgCreatePartialUpgrade.height":
-		value := x.Height
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
-		value := x.NodeVersion
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
-		value := x.ApiBinariesJson
+	case "inference.inference.MsgSubmitHardwareDiff.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
+		if len(x.NewOrModified) == 0 {
+			return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_2_list{})
+		}
+		listValue := &_MsgSubmitHardwareDiff_2_list{list: &x.NewOrModified}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgSubmitHardwareDiff.removed":
+		if len(x.Removed) == 0 {
+			return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_3_list{})
+		}
+		listValue := &_MsgSubmitHardwareDiff_3_list{list: &x.Removed}
+		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -20169,21 +20124,23 @@ func (x *fastReflection_MsgCreatePartialUpgrade) Get(descriptor protoreflect.Fie
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgrade) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitHardwareDiff) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreatePartialUpgrade.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgCreatePartialUpgrade.height":
-		x.Height = value.Uint()
-	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
-		x.NodeVersion = value.Interface().(string)
-	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
-		x.ApiBinariesJson = value.Interface().(string)
+	case "inference.inference.MsgSubmitHardwareDiff.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
+		lv := value.List()
+		clv := lv.(*_MsgSubmitHardwareDiff_2_list)
+		x.NewOrModified = *clv.list
+	case "inference.inference.MsgSubmitHardwareDiff.removed":
+		lv := value.List()
+		clv := lv.(*_MsgSubmitHardwareDiff_3_list)
+		x.Removed = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20197,52 +20154,58 @@ func (x *fastReflection_MsgCreatePartialUpgrade) Set(fd protoreflect.FieldDescri
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgrade) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitHardwareDiff) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreatePartialUpgrade.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
-	case "inference.inference.MsgCreatePartialUpgrade.height":
-		panic(fmt.Errorf("field height of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
-	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
-		panic(fmt.Errorf("field nodeVersion of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
-	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
-		panic(fmt.Errorf("field apiBinariesJson of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
+	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
+		if x.NewOrModified == nil {
+			x.NewOrModified = []*HardwareNode{}
+		}
+		value := &_MsgSubmitHardwareDiff_2_list{list: &x.NewOrModified}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgSubmitHardwareDiff.removed":
+		if x.Removed == nil {
+			x.Removed = []*HardwareNode{}
+		}
+		value := &_MsgSubmitHardwareDiff_3_list{list: &x.Removed}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgSubmitHardwareDiff.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgSubmitHardwareDiff is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgCreatePartialUpgrade) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitHardwareDiff) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreatePartialUpgrade.authority":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgCreatePartialUpgrade.height":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
+	case "inference.inference.MsgSubmitHardwareDiff.creator":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgSubmitHardwareDiff.newOrModified":
+		list := []*HardwareNode{}
+		return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_2_list{list: &list})
+	case "inference.inference.MsgSubmitHardwareDiff.removed":
+		list := []*HardwareNode{}
+		return protoreflect.ValueOfList(&_MsgSubmitHardwareDiff_3_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiff"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiff does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgCreatePartialUpgrade) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitHardwareDiff) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreatePartialUpgrade", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitHardwareDiff", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -20250,7 +20213,7 @@ func (x *fastReflection_MsgCreatePartialUpgrade) WhichOneof(d protoreflect.Oneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgCreatePartialUpgrade) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitHardwareDiff) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -20261,7 +20224,7 @@ func (x *fastReflection_MsgCreatePartialUpgrade) GetUnknown() protoreflect.RawFi
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgrade) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitHardwareDiff) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -20273,7 +20236,7 @@ func (x *fastReflection_MsgCreatePartialUpgrade) SetUnknown(fields protoreflect.
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgCreatePartialUpgrade) IsValid() bool {
+func (x *fastReflection_MsgSubmitHardwareDiff) IsValid() bool {
 	return x != nil
 }
 
@@ -20283,9 +20246,9 @@ func (x *fastReflection_MsgCreatePartialUpgrade) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitHardwareDiff) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgCreatePartialUpgrade)
+		x := input.Message.Interface().(*MsgSubmitHardwareDiff)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20297,20 +20260,21 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Height != 0 {
-			n += 1 + runtime.Sov(uint64(x.Height))
-		}
-		l = len(x.NodeVersion)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.NewOrModified) > 0 {
+			for _, e := range x.NewOrModified {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
-		l = len(x.ApiBinariesJson)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if len(x.Removed) > 0 {
+			for _, e := range x.Removed {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -20322,7 +20286,7 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreatePartialUpgrade)
+		x := input.Message.Interface().(*MsgSubmitHardwareDiff)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20341,29 +20305,42 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ApiBinariesJson) > 0 {
-			i -= len(x.ApiBinariesJson)
-			copy(dAtA[i:], x.ApiBinariesJson)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ApiBinariesJson)))
-			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.NodeVersion) > 0 {
-			i -= len(x.NodeVersion)
-			copy(dAtA[i:], x.NodeVersion)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NodeVersion)))
-			i--
-			dAtA[i] = 0x1a
+		if len(x.Removed) > 0 {
+			for iNdEx := len(x.Removed) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Removed[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x1a
+			}
 		}
-		if x.Height != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Height))
-			i--
-			dAtA[i] = 0x10
+		if len(x.NewOrModified) > 0 {
+			for iNdEx := len(x.NewOrModified) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.NewOrModified[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x12
+			}
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -20378,7 +20355,7 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreatePartialUpgrade)
+		x := input.Message.Interface().(*MsgSubmitHardwareDiff)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20410,15 +20387,15 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgrade: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiff: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgrade: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiff: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -20446,32 +20423,13 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
-				}
-				x.Height = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Height |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NodeVersion", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewOrModified", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -20481,29 +20439,31 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.NodeVersion = string(dAtA[iNdEx:postIndex])
+				x.NewOrModified = append(x.NewOrModified, &HardwareNode{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.NewOrModified[len(x.NewOrModified)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
-			case 4:
+			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ApiBinariesJson", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Removed", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -20513,23 +20473,25 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ApiBinariesJson = string(dAtA[iNdEx:postIndex])
+				x.Removed = append(x.Removed, &HardwareNode{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Removed[len(x.Removed)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -20567,23 +20529,23 @@ func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Meth
 }
 
 var (
-	md_MsgCreatePartialUpgradeResponse protoreflect.MessageDescriptor
+	md_MsgSubmitHardwareDiffResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgCreatePartialUpgradeResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCreatePartialUpgradeResponse")
+	md_MsgSubmitHardwareDiffResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSubmitHardwareDiffResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgCreatePartialUpgradeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSubmitHardwareDiffResponse)(nil)
 
-type fastReflection_MsgCreatePartialUpgradeResponse MsgCreatePartialUpgradeResponse
+type fastReflection_MsgSubmitHardwareDiffResponse MsgSubmitHardwareDiffResponse
 
-func (x *MsgCreatePartialUpgradeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgCreatePartialUpgradeResponse)(x)
+func (x *MsgSubmitHardwareDiffResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSubmitHardwareDiffResponse)(x)
 }
 
-func (x *MsgCreatePartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgSubmitHardwareDiffResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[37]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -20595,43 +20557,43 @@ func (x *MsgCreatePartialUpgradeResponse) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgCreatePartialUpgradeResponse_messageType fastReflection_MsgCreatePartialUpgradeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgCreatePartialUpgradeResponse_messageType{}
+var _fastReflection_MsgSubmitHardwareDiffResponse_messageType fastReflection_MsgSubmitHardwareDiffResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSubmitHardwareDiffResponse_messageType{}
 
-type fastReflection_MsgCreatePartialUpgradeResponse_messageType struct{}
+type fastReflection_MsgSubmitHardwareDiffResponse_messageType struct{}
 
-func (x fastReflection_MsgCreatePartialUpgradeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgCreatePartialUpgradeResponse)(nil)
+func (x fastReflection_MsgSubmitHardwareDiffResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSubmitHardwareDiffResponse)(nil)
 }
-func (x fastReflection_MsgCreatePartialUpgradeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgCreatePartialUpgradeResponse)
+func (x fastReflection_MsgSubmitHardwareDiffResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitHardwareDiffResponse)
 }
-func (x fastReflection_MsgCreatePartialUpgradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreatePartialUpgradeResponse
+func (x fastReflection_MsgSubmitHardwareDiffResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitHardwareDiffResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreatePartialUpgradeResponse
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSubmitHardwareDiffResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgCreatePartialUpgradeResponse_messageType
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSubmitHardwareDiffResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgCreatePartialUpgradeResponse)
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSubmitHardwareDiffResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgCreatePartialUpgradeResponse)(x)
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSubmitHardwareDiffResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -20639,7 +20601,7 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -20653,13 +20615,13 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20669,13 +20631,13 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20685,13 +20647,13 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -20705,13 +20667,13 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -20725,36 +20687,36 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSubmitHardwareDiffResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSubmitHardwareDiffResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreatePartialUpgradeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSubmitHardwareDiffResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -20762,7 +20724,7 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -20773,7 +20735,7 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -20785,7 +20747,7 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) IsValid() bool {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -20795,9 +20757,9 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgCreatePartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSubmitHardwareDiffResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgCreatePartialUpgradeResponse)
+		x := input.Message.Interface().(*MsgSubmitHardwareDiffResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20819,7 +20781,7 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreatePartialUpgradeResponse)
+		x := input.Message.Interface().(*MsgSubmitHardwareDiffResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20849,7 +20811,7 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreatePartialUpgradeResponse)
+		x := input.Message.Interface().(*MsgSubmitHardwareDiffResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -20881,10 +20843,10 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgradeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiffResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSubmitHardwareDiffResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -20923,41 +20885,31 @@ func (x *fastReflection_MsgCreatePartialUpgradeResponse) ProtoMethods() *protoif
 }
 
 var (
-	md_MsgBridgeExchange                 protoreflect.MessageDescriptor
-	fd_MsgBridgeExchange_validator       protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_originChain     protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_contractAddress protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_ownerAddress    protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_ownerPubKey     protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_amount          protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_blockNumber     protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_receiptIndex    protoreflect.FieldDescriptor
-	fd_MsgBridgeExchange_receiptsRoot    protoreflect.FieldDescriptor
+	md_MsgCreatePartialUpgrade                 protoreflect.MessageDescriptor
+	fd_MsgCreatePartialUpgrade_authority       protoreflect.FieldDescriptor
+	fd_MsgCreatePartialUpgrade_height          protoreflect.FieldDescriptor
+	fd_MsgCreatePartialUpgrade_nodeVersion     protoreflect.FieldDescriptor
+	fd_MsgCreatePartialUpgrade_apiBinariesJson protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgBridgeExchange = File_inference_inference_tx_proto.Messages().ByName("MsgBridgeExchange")
-	fd_MsgBridgeExchange_validator = md_MsgBridgeExchange.Fields().ByName("validator")
-	fd_MsgBridgeExchange_originChain = md_MsgBridgeExchange.Fields().ByName("originChain")
-	fd_MsgBridgeExchange_contractAddress = md_MsgBridgeExchange.Fields().ByName("contractAddress")
-	fd_MsgBridgeExchange_ownerAddress = md_MsgBridgeExchange.Fields().ByName("ownerAddress")
-	fd_MsgBridgeExchange_ownerPubKey = md_MsgBridgeExchange.Fields().ByName("ownerPubKey")
-	fd_MsgBridgeExchange_amount = md_MsgBridgeExchange.Fields().ByName("amount")
-	fd_MsgBridgeExchange_blockNumber = md_MsgBridgeExchange.Fields().ByName("blockNumber")
-	fd_MsgBridgeExchange_receiptIndex = md_MsgBridgeExchange.Fields().ByName("receiptIndex")
-	fd_MsgBridgeExchange_receiptsRoot = md_MsgBridgeExchange.Fields().ByName("receiptsRoot")
+	md_MsgCreatePartialUpgrade = File_inference_inference_tx_proto.Messages().ByName("MsgCreatePartialUpgrade")
+	fd_MsgCreatePartialUpgrade_authority = md_MsgCreatePartialUpgrade.Fields().ByName("authority")
+	fd_MsgCreatePartialUpgrade_height = md_MsgCreatePartialUpgrade.Fields().ByName("height")
+	fd_MsgCreatePartialUpgrade_nodeVersion = md_MsgCreatePartialUpgrade.Fields().ByName("nodeVersion")
+	fd_MsgCreatePartialUpgrade_apiBinariesJson = md_MsgCreatePartialUpgrade.Fields().ByName("apiBinariesJson")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgBridgeExchange)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCreatePartialUpgrade)(nil)
 
-type fastReflection_MsgBridgeExchange MsgBridgeExchange
+type fastReflection_MsgCreatePartialUpgrade MsgCreatePartialUpgrade
 
-func (x *MsgBridgeExchange) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgBridgeExchange)(x)
+func (x *MsgCreatePartialUpgrade) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCreatePartialUpgrade)(x)
 }
 
-func (x *MsgBridgeExchange) slowProtoReflect() protoreflect.Message {
+func (x *MsgCreatePartialUpgrade) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[38]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -20969,43 +20921,43 @@ func (x *MsgBridgeExchange) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgBridgeExchange_messageType fastReflection_MsgBridgeExchange_messageType
-var _ protoreflect.MessageType = fastReflection_MsgBridgeExchange_messageType{}
+var _fastReflection_MsgCreatePartialUpgrade_messageType fastReflection_MsgCreatePartialUpgrade_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCreatePartialUpgrade_messageType{}
 
-type fastReflection_MsgBridgeExchange_messageType struct{}
+type fastReflection_MsgCreatePartialUpgrade_messageType struct{}
 
-func (x fastReflection_MsgBridgeExchange_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgBridgeExchange)(nil)
+func (x fastReflection_MsgCreatePartialUpgrade_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCreatePartialUpgrade)(nil)
 }
-func (x fastReflection_MsgBridgeExchange_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgBridgeExchange)
+func (x fastReflection_MsgCreatePartialUpgrade_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCreatePartialUpgrade)
 }
-func (x fastReflection_MsgBridgeExchange_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgBridgeExchange
+func (x fastReflection_MsgCreatePartialUpgrade_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreatePartialUpgrade
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgBridgeExchange) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgBridgeExchange
+func (x *fastReflection_MsgCreatePartialUpgrade) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreatePartialUpgrade
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgBridgeExchange) Type() protoreflect.MessageType {
-	return _fastReflection_MsgBridgeExchange_messageType
+func (x *fastReflection_MsgCreatePartialUpgrade) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCreatePartialUpgrade_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgBridgeExchange) New() protoreflect.Message {
-	return new(fastReflection_MsgBridgeExchange)
+func (x *fastReflection_MsgCreatePartialUpgrade) New() protoreflect.Message {
+	return new(fastReflection_MsgCreatePartialUpgrade)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgBridgeExchange) Interface() protoreflect.ProtoMessage {
-	return (*MsgBridgeExchange)(x)
+func (x *fastReflection_MsgCreatePartialUpgrade) Interface() protoreflect.ProtoMessage {
+	return (*MsgCreatePartialUpgrade)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -21013,58 +20965,28 @@ func (x *fastReflection_MsgBridgeExchange) Interface() protoreflect.ProtoMessage
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgBridgeExchange) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Validator != "" {
-		value := protoreflect.ValueOfString(x.Validator)
-		if !f(fd_MsgBridgeExchange_validator, value) {
-			return
-		}
-	}
-	if x.OriginChain != "" {
-		value := protoreflect.ValueOfString(x.OriginChain)
-		if !f(fd_MsgBridgeExchange_originChain, value) {
-			return
-		}
-	}
-	if x.ContractAddress != "" {
-		value := protoreflect.ValueOfString(x.ContractAddress)
-		if !f(fd_MsgBridgeExchange_contractAddress, value) {
-			return
-		}
-	}
-	if x.OwnerAddress != "" {
-		value := protoreflect.ValueOfString(x.OwnerAddress)
-		if !f(fd_MsgBridgeExchange_ownerAddress, value) {
-			return
-		}
-	}
-	if x.OwnerPubKey != "" {
-		value := protoreflect.ValueOfString(x.OwnerPubKey)
-		if !f(fd_MsgBridgeExchange_ownerPubKey, value) {
-			return
-		}
-	}
-	if x.Amount != "" {
-		value := protoreflect.ValueOfString(x.Amount)
-		if !f(fd_MsgBridgeExchange_amount, value) {
+func (x *fastReflection_MsgCreatePartialUpgrade) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgCreatePartialUpgrade_authority, value) {
 			return
 		}
 	}
-	if x.BlockNumber != "" {
-		value := protoreflect.ValueOfString(x.BlockNumber)
-		if !f(fd_MsgBridgeExchange_blockNumber, value) {
+	if x.Height != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Height)
+		if !f(fd_MsgCreatePartialUpgrade_height, value) {
 			return
 		}
 	}
-	if x.ReceiptIndex != "" {
-		value := protoreflect.ValueOfString(x.ReceiptIndex)
-		if !f(fd_MsgBridgeExchange_receiptIndex, value) {
+	if x.NodeVersion != "" {
+		value := protoreflect.ValueOfString(x.NodeVersion)
+		if !f(fd_MsgCreatePartialUpgrade_nodeVersion, value) {
 			return
 		}
 	}
-	if x.ReceiptsRoot != "" {
-		value := protoreflect.ValueOfString(x.ReceiptsRoot)
-		if !f(fd_MsgBridgeExchange_receiptsRoot, value) {
+	if x.ApiBinariesJson != "" {
+		value := protoreflect.ValueOfString(x.ApiBinariesJson)
+		if !f(fd_MsgCreatePartialUpgrade_apiBinariesJson, value) {
 			return
 		}
 	}
@@ -21081,31 +21003,21 @@ func (x *fastReflection_MsgBridgeExchange) Range(f func(protoreflect.FieldDescri
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgBridgeExchange) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCreatePartialUpgrade) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchange.validator":
-		return x.Validator != ""
-	case "inference.inference.MsgBridgeExchange.originChain":
-		return x.OriginChain != ""
-	case "inference.inference.MsgBridgeExchange.contractAddress":
-		return x.ContractAddress != ""
-	case "inference.inference.MsgBridgeExchange.ownerAddress":
-		return x.OwnerAddress != ""
-	case "inference.inference.MsgBridgeExchange.ownerPubKey":
-		return x.OwnerPubKey != ""
-	case "inference.inference.MsgBridgeExchange.amount":
-		return x.Amount != ""
-	case "inference.inference.MsgBridgeExchange.blockNumber":
-		return x.BlockNumber != ""
-	case "inference.inference.MsgBridgeExchange.receiptIndex":
-		return x.ReceiptIndex != ""
-	case "inference.inference.MsgBridgeExchange.receiptsRoot":
-		return x.ReceiptsRoot != ""
+	case "inference.inference.MsgCreatePartialUpgrade.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgCreatePartialUpgrade.height":
+		return x.Height != uint64(0)
+	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
+		return x.NodeVersion != ""
+	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
+		return x.ApiBinariesJson != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21115,31 +21027,21 @@ func (x *fastReflection_MsgBridgeExchange) Has(fd protoreflect.FieldDescriptor)
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchange) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCreatePartialUpgrade) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchange.validator":
-		x.Validator = ""
-	case "inference.inference.MsgBridgeExchange.originChain":
-		x.OriginChain = ""
-	case "inference.inference.MsgBridgeExchange.contractAddress":
-		x.ContractAddress = ""
-	case "inference.inference.MsgBridgeExchange.ownerAddress":
-		x.OwnerAddress = ""
-	case "inference.inference.MsgBridgeExchange.ownerPubKey":
-		x.OwnerPubKey = ""
-	case "inference.inference.MsgBridgeExchange.amount":
-		x.Amount = ""
-	case "inference.inference.MsgBridgeExchange.blockNumber":
-		x.BlockNumber = ""
-	case "inference.inference.MsgBridgeExchange.receiptIndex":
-		x.ReceiptIndex = ""
-	case "inference.inference.MsgBridgeExchange.receiptsRoot":
-		x.ReceiptsRoot = ""
+	case "inference.inference.MsgCreatePartialUpgrade.authority":
+		x.Authority = ""
+	case "inference.inference.MsgCreatePartialUpgrade.height":
+		x.Height = uint64(0)
+	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
+		x.NodeVersion = ""
+	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
+		x.ApiBinariesJson = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21149,40 +21051,25 @@ func (x *fastReflection_MsgBridgeExchange) Clear(fd protoreflect.FieldDescriptor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgBridgeExchange) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreatePartialUpgrade) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgBridgeExchange.validator":
-		value := x.Validator
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.originChain":
-		value := x.OriginChain
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.contractAddress":
-		value := x.ContractAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.ownerAddress":
-		value := x.OwnerAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.ownerPubKey":
-		value := x.OwnerPubKey
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.amount":
-		value := x.Amount
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.blockNumber":
-		value := x.BlockNumber
+	case "inference.inference.MsgCreatePartialUpgrade.authority":
+		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.receiptIndex":
-		value := x.ReceiptIndex
+	case "inference.inference.MsgCreatePartialUpgrade.height":
+		value := x.Height
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
+		value := x.NodeVersion
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgBridgeExchange.receiptsRoot":
-		value := x.ReceiptsRoot
+	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
+		value := x.ApiBinariesJson
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -21196,31 +21083,21 @@ func (x *fastReflection_MsgBridgeExchange) Get(descriptor protoreflect.FieldDesc
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchange) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCreatePartialUpgrade) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchange.validator":
-		x.Validator = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.originChain":
-		x.OriginChain = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.contractAddress":
-		x.ContractAddress = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.ownerAddress":
-		x.OwnerAddress = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.ownerPubKey":
-		x.OwnerPubKey = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.amount":
-		x.Amount = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.blockNumber":
-		x.BlockNumber = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.receiptIndex":
-		x.ReceiptIndex = value.Interface().(string)
-	case "inference.inference.MsgBridgeExchange.receiptsRoot":
-		x.ReceiptsRoot = value.Interface().(string)
+	case "inference.inference.MsgCreatePartialUpgrade.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgCreatePartialUpgrade.height":
+		x.Height = value.Uint()
+	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
+		x.NodeVersion = value.Interface().(string)
+	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
+		x.ApiBinariesJson = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21234,72 +21111,52 @@ func (x *fastReflection_MsgBridgeExchange) Set(fd protoreflect.FieldDescriptor,
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchange) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreatePartialUpgrade) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchange.validator":
-		panic(fmt.Errorf("field validator of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.originChain":
-		panic(fmt.Errorf("field originChain of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.contractAddress":
-		panic(fmt.Errorf("field contractAddress of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.ownerAddress":
-		panic(fmt.Errorf("field ownerAddress of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.ownerPubKey":
-		panic(fmt.Errorf("field ownerPubKey of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.amount":
-		panic(fmt.Errorf("field amount of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.blockNumber":
-		panic(fmt.Errorf("field blockNumber of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.receiptIndex":
-		panic(fmt.Errorf("field receiptIndex of message inference.inference.MsgBridgeExchange is not mutable"))
-	case "inference.inference.MsgBridgeExchange.receiptsRoot":
-		panic(fmt.Errorf("field receiptsRoot of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgCreatePartialUpgrade.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
+	case "inference.inference.MsgCreatePartialUpgrade.height":
+		panic(fmt.Errorf("field height of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
+	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
+		panic(fmt.Errorf("field nodeVersion of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
+	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
+		panic(fmt.Errorf("field apiBinariesJson of message inference.inference.MsgCreatePartialUpgrade is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgBridgeExchange) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreatePartialUpgrade) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchange.validator":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.originChain":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.contractAddress":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.ownerAddress":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.ownerPubKey":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.amount":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.blockNumber":
+	case "inference.inference.MsgCreatePartialUpgrade.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.receiptIndex":
+	case "inference.inference.MsgCreatePartialUpgrade.height":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgCreatePartialUpgrade.nodeVersion":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+	case "inference.inference.MsgCreatePartialUpgrade.apiBinariesJson":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgrade"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgrade does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgBridgeExchange) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCreatePartialUpgrade) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgBridgeExchange", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreatePartialUpgrade", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -21307,7 +21164,7 @@ func (x *fastReflection_MsgBridgeExchange) WhichOneof(d protoreflect.OneofDescri
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgBridgeExchange) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCreatePartialUpgrade) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -21318,7 +21175,7 @@ func (x *fastReflection_MsgBridgeExchange) GetUnknown() protoreflect.RawFields {
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchange) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCreatePartialUpgrade) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -21330,7 +21187,7 @@ func (x *fastReflection_MsgBridgeExchange) SetUnknown(fields protoreflect.RawFie
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgBridgeExchange) IsValid() bool {
+func (x *fastReflection_MsgCreatePartialUpgrade) IsValid() bool {
 	return x != nil
 }
 
@@ -21340,9 +21197,9 @@ func (x *fastReflection_MsgBridgeExchange) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCreatePartialUpgrade) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgBridgeExchange)
+		x := input.Message.Interface().(*MsgCreatePartialUpgrade)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21354,39 +21211,18 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 		var n int
 		var l int
 		_ = l
-		l = len(x.Validator)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.OriginChain)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.ContractAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.OwnerAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.OwnerPubKey)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.Amount)
+		l = len(x.Authority)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.BlockNumber)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Height != 0 {
+			n += 1 + runtime.Sov(uint64(x.Height))
 		}
-		l = len(x.ReceiptIndex)
+		l = len(x.NodeVersion)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ReceiptsRoot)
+		l = len(x.ApiBinariesJson)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -21400,7 +21236,7 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgBridgeExchange)
+		x := input.Message.Interface().(*MsgCreatePartialUpgrade)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21419,73 +21255,36 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ReceiptsRoot) > 0 {
-			i -= len(x.ReceiptsRoot)
-			copy(dAtA[i:], x.ReceiptsRoot)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptsRoot)))
-			i--
-			dAtA[i] = 0x4a
-		}
-		if len(x.ReceiptIndex) > 0 {
-			i -= len(x.ReceiptIndex)
-			copy(dAtA[i:], x.ReceiptIndex)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptIndex)))
+		if len(x.ApiBinariesJson) > 0 {
+			i -= len(x.ApiBinariesJson)
+			copy(dAtA[i:], x.ApiBinariesJson)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ApiBinariesJson)))
 			i--
-			dAtA[i] = 0x42
+			dAtA[i] = 0x22
 		}
-		if len(x.BlockNumber) > 0 {
-			i -= len(x.BlockNumber)
-			copy(dAtA[i:], x.BlockNumber)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlockNumber)))
+		if len(x.NodeVersion) > 0 {
+			i -= len(x.NodeVersion)
+			copy(dAtA[i:], x.NodeVersion)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NodeVersion)))
 			i--
-			dAtA[i] = 0x3a
+			dAtA[i] = 0x1a
 		}
-		if len(x.Amount) > 0 {
-			i -= len(x.Amount)
-			copy(dAtA[i:], x.Amount)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Amount)))
+		if x.Height != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Height))
 			i--
-			dAtA[i] = 0x32
+			dAtA[i] = 0x10
 		}
-		if len(x.OwnerPubKey) > 0 {
-			i -= len(x.OwnerPubKey)
-			copy(dAtA[i:], x.OwnerPubKey)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OwnerPubKey)))
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
 			i--
-			dAtA[i] = 0x2a
+			dAtA[i] = 0xa
 		}
-		if len(x.OwnerAddress) > 0 {
-			i -= len(x.OwnerAddress)
-			copy(dAtA[i:], x.OwnerAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OwnerAddress)))
-			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.ContractAddress) > 0 {
-			i -= len(x.ContractAddress)
-			copy(dAtA[i:], x.ContractAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.OriginChain) > 0 {
-			i -= len(x.OriginChain)
-			copy(dAtA[i:], x.OriginChain)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OriginChain)))
-			i--
-			dAtA[i] = 0x12
-		}
-		if len(x.Validator) > 0 {
-			i -= len(x.Validator)
-			copy(dAtA[i:], x.Validator)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validator)))
-			i--
-			dAtA[i] = 0xa
-		}
-		if input.Buf != nil {
-			input.Buf = append(input.Buf, dAtA...)
-		} else {
-			input.Buf = dAtA
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
 		}
 		return protoiface.MarshalOutput{
 			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21493,7 +21292,7 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgBridgeExchange)
+		x := input.Message.Interface().(*MsgCreatePartialUpgrade)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -21525,15 +21324,15 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchange: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgrade: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchange: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgrade: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -21561,13 +21360,13 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Validator = string(dAtA[iNdEx:postIndex])
+				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OriginChain", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
 				}
-				var stringLen uint64
+				x.Height = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -21577,27 +21376,14 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.Height |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.OriginChain = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NodeVersion", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -21625,171 +21411,11 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ContractAddress = string(dAtA[iNdEx:postIndex])
+				x.NodeVersion = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 4:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OwnerAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.OwnerAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OwnerPubKey", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.OwnerPubKey = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 6:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Amount = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 7:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.BlockNumber = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 8:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptIndex", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ReceiptIndex = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 9:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ApiBinariesJson", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -21817,7 +21443,7 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ReceiptsRoot = string(dAtA[iNdEx:postIndex])
+				x.ApiBinariesJson = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -21855,25 +21481,23 @@ func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
 }
 
 var (
-	md_MsgBridgeExchangeResponse    protoreflect.MessageDescriptor
-	fd_MsgBridgeExchangeResponse_id protoreflect.FieldDescriptor
+	md_MsgCreatePartialUpgradeResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgBridgeExchangeResponse = File_inference_inference_tx_proto.Messages().ByName("MsgBridgeExchangeResponse")
-	fd_MsgBridgeExchangeResponse_id = md_MsgBridgeExchangeResponse.Fields().ByName("id")
+	md_MsgCreatePartialUpgradeResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCreatePartialUpgradeResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgBridgeExchangeResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCreatePartialUpgradeResponse)(nil)
 
-type fastReflection_MsgBridgeExchangeResponse MsgBridgeExchangeResponse
+type fastReflection_MsgCreatePartialUpgradeResponse MsgCreatePartialUpgradeResponse
 
-func (x *MsgBridgeExchangeResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgBridgeExchangeResponse)(x)
+func (x *MsgCreatePartialUpgradeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCreatePartialUpgradeResponse)(x)
 }
 
-func (x *MsgBridgeExchangeResponse) slowProtoReflect() protoreflect.Message {
+func (x *MsgCreatePartialUpgradeResponse) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[39]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -21885,43 +21509,43 @@ func (x *MsgBridgeExchangeResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgBridgeExchangeResponse_messageType fastReflection_MsgBridgeExchangeResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgBridgeExchangeResponse_messageType{}
+var _fastReflection_MsgCreatePartialUpgradeResponse_messageType fastReflection_MsgCreatePartialUpgradeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCreatePartialUpgradeResponse_messageType{}
 
-type fastReflection_MsgBridgeExchangeResponse_messageType struct{}
+type fastReflection_MsgCreatePartialUpgradeResponse_messageType struct{}
 
-func (x fastReflection_MsgBridgeExchangeResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgBridgeExchangeResponse)(nil)
+func (x fastReflection_MsgCreatePartialUpgradeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCreatePartialUpgradeResponse)(nil)
 }
-func (x fastReflection_MsgBridgeExchangeResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgBridgeExchangeResponse)
+func (x fastReflection_MsgCreatePartialUpgradeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCreatePartialUpgradeResponse)
 }
-func (x fastReflection_MsgBridgeExchangeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgBridgeExchangeResponse
+func (x fastReflection_MsgCreatePartialUpgradeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreatePartialUpgradeResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgBridgeExchangeResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgBridgeExchangeResponse
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreatePartialUpgradeResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgBridgeExchangeResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgBridgeExchangeResponse_messageType
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCreatePartialUpgradeResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgBridgeExchangeResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgBridgeExchangeResponse)
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgCreatePartialUpgradeResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgBridgeExchangeResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgBridgeExchangeResponse)(x)
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgCreatePartialUpgradeResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -21929,13 +21553,7 @@ func (x *fastReflection_MsgBridgeExchangeResponse) Interface() protoreflect.Prot
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgBridgeExchangeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Id != "" {
-		value := protoreflect.ValueOfString(x.Id)
-		if !f(fd_MsgBridgeExchangeResponse_id, value) {
-			return
-		}
-	}
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -21949,15 +21567,13 @@ func (x *fastReflection_MsgBridgeExchangeResponse) Range(f func(protoreflect.Fie
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgBridgeExchangeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchangeResponse.id":
-		return x.Id != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21967,15 +21583,13 @@ func (x *fastReflection_MsgBridgeExchangeResponse) Has(fd protoreflect.FieldDesc
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchangeResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchangeResponse.id":
-		x.Id = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -21985,16 +21599,13 @@ func (x *fastReflection_MsgBridgeExchangeResponse) Clear(fd protoreflect.FieldDe
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgBridgeExchangeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgBridgeExchangeResponse.id":
-		value := x.Id
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -22008,15 +21619,13 @@ func (x *fastReflection_MsgBridgeExchangeResponse) Get(descriptor protoreflect.F
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchangeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchangeResponse.id":
-		x.Id = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22030,40 +21639,36 @@ func (x *fastReflection_MsgBridgeExchangeResponse) Set(fd protoreflect.FieldDesc
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchangeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchangeResponse.id":
-		panic(fmt.Errorf("field id of message inference.inference.MsgBridgeExchangeResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgBridgeExchangeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgBridgeExchangeResponse.id":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreatePartialUpgradeResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreatePartialUpgradeResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgBridgeExchangeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgBridgeExchangeResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreatePartialUpgradeResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -22071,7 +21676,7 @@ func (x *fastReflection_MsgBridgeExchangeResponse) WhichOneof(d protoreflect.One
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgBridgeExchangeResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -22082,7 +21687,7 @@ func (x *fastReflection_MsgBridgeExchangeResponse) GetUnknown() protoreflect.Raw
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgBridgeExchangeResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -22094,7 +21699,7 @@ func (x *fastReflection_MsgBridgeExchangeResponse) SetUnknown(fields protoreflec
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgBridgeExchangeResponse) IsValid() bool {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -22104,9 +21709,9 @@ func (x *fastReflection_MsgBridgeExchangeResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCreatePartialUpgradeResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgBridgeExchangeResponse)
+		x := input.Message.Interface().(*MsgCreatePartialUpgradeResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22118,10 +21723,6 @@ func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Me
 		var n int
 		var l int
 		_ = l
-		l = len(x.Id)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -22132,7 +21733,7 @@ func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Me
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgBridgeExchangeResponse)
+		x := input.Message.Interface().(*MsgCreatePartialUpgradeResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22151,13 +21752,6 @@ func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Me
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Id) > 0 {
-			i -= len(x.Id)
-			copy(dAtA[i:], x.Id)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -22169,7 +21763,7 @@ func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Me
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgBridgeExchangeResponse)
+		x := input.Message.Interface().(*MsgCreatePartialUpgradeResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22201,44 +21795,12 @@ func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Me
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchangeResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgradeResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreatePartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Id = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -22274,74 +21836,42 @@ func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Me
 	}
 }
 
-var _ protoreflect.List = (*_MsgAddParticipantsToAllowList_2_list)(nil)
-
-type _MsgAddParticipantsToAllowList_2_list struct {
-	list *[]string
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfString((*x.list)[i])
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message MsgAddParticipantsToAllowList at list field Addresses as it is not of Message kind"))
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) Truncate(n int) {
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) NewElement() protoreflect.Value {
-	v := ""
-	return protoreflect.ValueOfString(v)
-}
-
-func (x *_MsgAddParticipantsToAllowList_2_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MsgAddParticipantsToAllowList           protoreflect.MessageDescriptor
-	fd_MsgAddParticipantsToAllowList_authority protoreflect.FieldDescriptor
-	fd_MsgAddParticipantsToAllowList_addresses protoreflect.FieldDescriptor
+	md_MsgBridgeExchange                 protoreflect.MessageDescriptor
+	fd_MsgBridgeExchange_validator       protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_originChain     protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_contractAddress protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_ownerAddress    protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_ownerPubKey     protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_amount          protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_blockNumber     protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_receiptIndex    protoreflect.FieldDescriptor
+	fd_MsgBridgeExchange_receiptsRoot    protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgAddParticipantsToAllowList = File_inference_inference_tx_proto.Messages().ByName("MsgAddParticipantsToAllowList")
-	fd_MsgAddParticipantsToAllowList_authority = md_MsgAddParticipantsToAllowList.Fields().ByName("authority")
-	fd_MsgAddParticipantsToAllowList_addresses = md_MsgAddParticipantsToAllowList.Fields().ByName("addresses")
+	md_MsgBridgeExchange = File_inference_inference_tx_proto.Messages().ByName("MsgBridgeExchange")
+	fd_MsgBridgeExchange_validator = md_MsgBridgeExchange.Fields().ByName("validator")
+	fd_MsgBridgeExchange_originChain = md_MsgBridgeExchange.Fields().ByName("originChain")
+	fd_MsgBridgeExchange_contractAddress = md_MsgBridgeExchange.Fields().ByName("contractAddress")
+	fd_MsgBridgeExchange_ownerAddress = md_MsgBridgeExchange.Fields().ByName("ownerAddress")
+	fd_MsgBridgeExchange_ownerPubKey = md_MsgBridgeExchange.Fields().ByName("ownerPubKey")
+	fd_MsgBridgeExchange_amount = md_MsgBridgeExchange.Fields().ByName("amount")
+	fd_MsgBridgeExchange_blockNumber = md_MsgBridgeExchange.Fields().ByName("blockNumber")
+	fd_MsgBridgeExchange_receiptIndex = md_MsgBridgeExchange.Fields().ByName("receiptIndex")
+	fd_MsgBridgeExchange_receiptsRoot = md_MsgBridgeExchange.Fields().ByName("receiptsRoot")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgAddParticipantsToAllowList)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgBridgeExchange)(nil)
 
-type fastReflection_MsgAddParticipantsToAllowList MsgAddParticipantsToAllowList
+type fastReflection_MsgBridgeExchange MsgBridgeExchange
 
-func (x *MsgAddParticipantsToAllowList) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgAddParticipantsToAllowList)(x)
+func (x *MsgBridgeExchange) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgBridgeExchange)(x)
 }
 
-func (x *MsgAddParticipantsToAllowList) slowProtoReflect() protoreflect.Message {
+func (x *MsgBridgeExchange) slowProtoReflect() protoreflect.Message {
 	mi := &file_inference_inference_tx_proto_msgTypes[40]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -22353,43 +21883,43 @@ func (x *MsgAddParticipantsToAllowList) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgAddParticipantsToAllowList_messageType fastReflection_MsgAddParticipantsToAllowList_messageType
-var _ protoreflect.MessageType = fastReflection_MsgAddParticipantsToAllowList_messageType{}
+var _fastReflection_MsgBridgeExchange_messageType fastReflection_MsgBridgeExchange_messageType
+var _ protoreflect.MessageType = fastReflection_MsgBridgeExchange_messageType{}
 
-type fastReflection_MsgAddParticipantsToAllowList_messageType struct{}
+type fastReflection_MsgBridgeExchange_messageType struct{}
 
-func (x fastReflection_MsgAddParticipantsToAllowList_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgAddParticipantsToAllowList)(nil)
+func (x fastReflection_MsgBridgeExchange_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgBridgeExchange)(nil)
 }
-func (x fastReflection_MsgAddParticipantsToAllowList_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgAddParticipantsToAllowList)
+func (x fastReflection_MsgBridgeExchange_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgBridgeExchange)
 }
-func (x fastReflection_MsgAddParticipantsToAllowList_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgAddParticipantsToAllowList
+func (x fastReflection_MsgBridgeExchange_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBridgeExchange
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgAddParticipantsToAllowList
+func (x *fastReflection_MsgBridgeExchange) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBridgeExchange
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Type() protoreflect.MessageType {
-	return _fastReflection_MsgAddParticipantsToAllowList_messageType
+func (x *fastReflection_MsgBridgeExchange) Type() protoreflect.MessageType {
+	return _fastReflection_MsgBridgeExchange_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgAddParticipantsToAllowList) New() protoreflect.Message {
-	return new(fastReflection_MsgAddParticipantsToAllowList)
+func (x *fastReflection_MsgBridgeExchange) New() protoreflect.Message {
+	return new(fastReflection_MsgBridgeExchange)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Interface() protoreflect.ProtoMessage {
-	return (*MsgAddParticipantsToAllowList)(x)
+func (x *fastReflection_MsgBridgeExchange) Interface() protoreflect.ProtoMessage {
+	return (*MsgBridgeExchange)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -22397,16 +21927,3208 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
+func (x *fastReflection_MsgBridgeExchange) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Validator != "" {
+		value := protoreflect.ValueOfString(x.Validator)
+		if !f(fd_MsgBridgeExchange_validator, value) {
+			return
+		}
+	}
+	if x.OriginChain != "" {
+		value := protoreflect.ValueOfString(x.OriginChain)
+		if !f(fd_MsgBridgeExchange_originChain, value) {
+			return
+		}
+	}
+	if x.ContractAddress != "" {
+		value := protoreflect.ValueOfString(x.ContractAddress)
+		if !f(fd_MsgBridgeExchange_contractAddress, value) {
+			return
+		}
+	}
+	if x.OwnerAddress != "" {
+		value := protoreflect.ValueOfString(x.OwnerAddress)
+		if !f(fd_MsgBridgeExchange_ownerAddress, value) {
+			return
+		}
+	}
+	if x.OwnerPubKey != "" {
+		value := protoreflect.ValueOfString(x.OwnerPubKey)
+		if !f(fd_MsgBridgeExchange_ownerPubKey, value) {
+			return
+		}
+	}
+	if x.Amount != "" {
+		value := protoreflect.ValueOfString(x.Amount)
+		if !f(fd_MsgBridgeExchange_amount, value) {
+			return
+		}
+	}
+	if x.BlockNumber != "" {
+		value := protoreflect.ValueOfString(x.BlockNumber)
+		if !f(fd_MsgBridgeExchange_blockNumber, value) {
+			return
+		}
+	}
+	if x.ReceiptIndex != "" {
+		value := protoreflect.ValueOfString(x.ReceiptIndex)
+		if !f(fd_MsgBridgeExchange_receiptIndex, value) {
+			return
+		}
+	}
+	if x.ReceiptsRoot != "" {
+		value := protoreflect.ValueOfString(x.ReceiptsRoot)
+		if !f(fd_MsgBridgeExchange_receiptsRoot, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgBridgeExchange) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchange.validator":
+		return x.Validator != ""
+	case "inference.inference.MsgBridgeExchange.originChain":
+		return x.OriginChain != ""
+	case "inference.inference.MsgBridgeExchange.contractAddress":
+		return x.ContractAddress != ""
+	case "inference.inference.MsgBridgeExchange.ownerAddress":
+		return x.OwnerAddress != ""
+	case "inference.inference.MsgBridgeExchange.ownerPubKey":
+		return x.OwnerPubKey != ""
+	case "inference.inference.MsgBridgeExchange.amount":
+		return x.Amount != ""
+	case "inference.inference.MsgBridgeExchange.blockNumber":
+		return x.BlockNumber != ""
+	case "inference.inference.MsgBridgeExchange.receiptIndex":
+		return x.ReceiptIndex != ""
+	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+		return x.ReceiptsRoot != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchange) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchange.validator":
+		x.Validator = ""
+	case "inference.inference.MsgBridgeExchange.originChain":
+		x.OriginChain = ""
+	case "inference.inference.MsgBridgeExchange.contractAddress":
+		x.ContractAddress = ""
+	case "inference.inference.MsgBridgeExchange.ownerAddress":
+		x.OwnerAddress = ""
+	case "inference.inference.MsgBridgeExchange.ownerPubKey":
+		x.OwnerPubKey = ""
+	case "inference.inference.MsgBridgeExchange.amount":
+		x.Amount = ""
+	case "inference.inference.MsgBridgeExchange.blockNumber":
+		x.BlockNumber = ""
+	case "inference.inference.MsgBridgeExchange.receiptIndex":
+		x.ReceiptIndex = ""
+	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+		x.ReceiptsRoot = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgBridgeExchange) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MsgBridgeExchange.validator":
+		value := x.Validator
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.originChain":
+		value := x.OriginChain
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.contractAddress":
+		value := x.ContractAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.ownerAddress":
+		value := x.OwnerAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.ownerPubKey":
+		value := x.OwnerPubKey
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.amount":
+		value := x.Amount
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.blockNumber":
+		value := x.BlockNumber
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.receiptIndex":
+		value := x.ReceiptIndex
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+		value := x.ReceiptsRoot
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchange) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchange.validator":
+		x.Validator = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.originChain":
+		x.OriginChain = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.contractAddress":
+		x.ContractAddress = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.ownerAddress":
+		x.OwnerAddress = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.ownerPubKey":
+		x.OwnerPubKey = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.amount":
+		x.Amount = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.blockNumber":
+		x.BlockNumber = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.receiptIndex":
+		x.ReceiptIndex = value.Interface().(string)
+	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+		x.ReceiptsRoot = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchange) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchange.validator":
+		panic(fmt.Errorf("field validator of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.originChain":
+		panic(fmt.Errorf("field originChain of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.contractAddress":
+		panic(fmt.Errorf("field contractAddress of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.ownerAddress":
+		panic(fmt.Errorf("field ownerAddress of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.ownerPubKey":
+		panic(fmt.Errorf("field ownerPubKey of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.amount":
+		panic(fmt.Errorf("field amount of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.blockNumber":
+		panic(fmt.Errorf("field blockNumber of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.receiptIndex":
+		panic(fmt.Errorf("field receiptIndex of message inference.inference.MsgBridgeExchange is not mutable"))
+	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+		panic(fmt.Errorf("field receiptsRoot of message inference.inference.MsgBridgeExchange is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgBridgeExchange) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchange.validator":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.originChain":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.contractAddress":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.ownerAddress":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.ownerPubKey":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.amount":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.blockNumber":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.receiptIndex":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgBridgeExchange.receiptsRoot":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchange"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchange does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgBridgeExchange) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgBridgeExchange", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgBridgeExchange) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchange) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgBridgeExchange) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgBridgeExchange) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgBridgeExchange)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Validator)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.OriginChain)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ContractAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.OwnerAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.OwnerPubKey)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Amount)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.BlockNumber)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ReceiptIndex)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ReceiptsRoot)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBridgeExchange)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.ReceiptsRoot) > 0 {
+			i -= len(x.ReceiptsRoot)
+			copy(dAtA[i:], x.ReceiptsRoot)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptsRoot)))
+			i--
+			dAtA[i] = 0x4a
+		}
+		if len(x.ReceiptIndex) > 0 {
+			i -= len(x.ReceiptIndex)
+			copy(dAtA[i:], x.ReceiptIndex)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ReceiptIndex)))
+			i--
+			dAtA[i] = 0x42
+		}
+		if len(x.BlockNumber) > 0 {
+			i -= len(x.BlockNumber)
+			copy(dAtA[i:], x.BlockNumber)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlockNumber)))
+			i--
+			dAtA[i] = 0x3a
+		}
+		if len(x.Amount) > 0 {
+			i -= len(x.Amount)
+			copy(dAtA[i:], x.Amount)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Amount)))
+			i--
+			dAtA[i] = 0x32
+		}
+		if len(x.OwnerPubKey) > 0 {
+			i -= len(x.OwnerPubKey)
+			copy(dAtA[i:], x.OwnerPubKey)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OwnerPubKey)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.OwnerAddress) > 0 {
+			i -= len(x.OwnerAddress)
+			copy(dAtA[i:], x.OwnerAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OwnerAddress)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.ContractAddress) > 0 {
+			i -= len(x.ContractAddress)
+			copy(dAtA[i:], x.ContractAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.OriginChain) > 0 {
+			i -= len(x.OriginChain)
+			copy(dAtA[i:], x.OriginChain)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OriginChain)))
+			i--
+			dAtA[i] = 0x12
+		}
+		if len(x.Validator) > 0 {
+			i -= len(x.Validator)
+			copy(dAtA[i:], x.Validator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Validator)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBridgeExchange)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchange: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchange: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Validator = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OriginChain", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.OriginChain = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ContractAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OwnerAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.OwnerAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OwnerPubKey", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.OwnerPubKey = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 6:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Amount = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.BlockNumber = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 8:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptIndex", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ReceiptIndex = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 9:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReceiptsRoot", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ReceiptsRoot = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgBridgeExchangeResponse    protoreflect.MessageDescriptor
+	fd_MsgBridgeExchangeResponse_id protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgBridgeExchangeResponse = File_inference_inference_tx_proto.Messages().ByName("MsgBridgeExchangeResponse")
+	fd_MsgBridgeExchangeResponse_id = md_MsgBridgeExchangeResponse.Fields().ByName("id")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgBridgeExchangeResponse)(nil)
+
+type fastReflection_MsgBridgeExchangeResponse MsgBridgeExchangeResponse
+
+func (x *MsgBridgeExchangeResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgBridgeExchangeResponse)(x)
+}
+
+func (x *MsgBridgeExchangeResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[41]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgBridgeExchangeResponse_messageType fastReflection_MsgBridgeExchangeResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgBridgeExchangeResponse_messageType{}
+
+type fastReflection_MsgBridgeExchangeResponse_messageType struct{}
+
+func (x fastReflection_MsgBridgeExchangeResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgBridgeExchangeResponse)(nil)
+}
+func (x fastReflection_MsgBridgeExchangeResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgBridgeExchangeResponse)
+}
+func (x fastReflection_MsgBridgeExchangeResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBridgeExchangeResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgBridgeExchangeResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgBridgeExchangeResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgBridgeExchangeResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgBridgeExchangeResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgBridgeExchangeResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgBridgeExchangeResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgBridgeExchangeResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgBridgeExchangeResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgBridgeExchangeResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Id != "" {
+		value := protoreflect.ValueOfString(x.Id)
+		if !f(fd_MsgBridgeExchangeResponse_id, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgBridgeExchangeResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchangeResponse.id":
+		return x.Id != ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchangeResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchangeResponse.id":
+		x.Id = ""
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgBridgeExchangeResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MsgBridgeExchangeResponse.id":
+		value := x.Id
+		return protoreflect.ValueOfString(value)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchangeResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchangeResponse.id":
+		x.Id = value.Interface().(string)
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchangeResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchangeResponse.id":
+		panic(fmt.Errorf("field id of message inference.inference.MsgBridgeExchangeResponse is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgBridgeExchangeResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgBridgeExchangeResponse.id":
+		return protoreflect.ValueOfString("")
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgBridgeExchangeResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgBridgeExchangeResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgBridgeExchangeResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgBridgeExchangeResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgBridgeExchangeResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgBridgeExchangeResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgBridgeExchangeResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgBridgeExchangeResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgBridgeExchangeResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Id)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBridgeExchangeResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Id) > 0 {
+			i -= len(x.Id)
+			copy(dAtA[i:], x.Id)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgBridgeExchangeResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchangeResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgBridgeExchangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Id = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_MsgAddParticipantsToAllowList_2_list)(nil)
+
+type _MsgAddParticipantsToAllowList_2_list struct {
+	list *[]string
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message MsgAddParticipantsToAllowList at list field Addresses as it is not of Message kind"))
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_MsgAddParticipantsToAllowList_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_MsgAddParticipantsToAllowList           protoreflect.MessageDescriptor
+	fd_MsgAddParticipantsToAllowList_authority protoreflect.FieldDescriptor
+	fd_MsgAddParticipantsToAllowList_addresses protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgAddParticipantsToAllowList = File_inference_inference_tx_proto.Messages().ByName("MsgAddParticipantsToAllowList")
+	fd_MsgAddParticipantsToAllowList_authority = md_MsgAddParticipantsToAllowList.Fields().ByName("authority")
+	fd_MsgAddParticipantsToAllowList_addresses = md_MsgAddParticipantsToAllowList.Fields().ByName("addresses")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgAddParticipantsToAllowList)(nil)
+
+type fastReflection_MsgAddParticipantsToAllowList MsgAddParticipantsToAllowList
+
+func (x *MsgAddParticipantsToAllowList) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgAddParticipantsToAllowList)(x)
+}
+
+func (x *MsgAddParticipantsToAllowList) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[42]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgAddParticipantsToAllowList_messageType fastReflection_MsgAddParticipantsToAllowList_messageType
+var _ protoreflect.MessageType = fastReflection_MsgAddParticipantsToAllowList_messageType{}
+
+type fastReflection_MsgAddParticipantsToAllowList_messageType struct{}
+
+func (x fastReflection_MsgAddParticipantsToAllowList_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgAddParticipantsToAllowList)(nil)
+}
+func (x fastReflection_MsgAddParticipantsToAllowList_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgAddParticipantsToAllowList)
+}
+func (x fastReflection_MsgAddParticipantsToAllowList_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgAddParticipantsToAllowList
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgAddParticipantsToAllowList
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Type() protoreflect.MessageType {
+	return _fastReflection_MsgAddParticipantsToAllowList_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgAddParticipantsToAllowList) New() protoreflect.Message {
+	return new(fastReflection_MsgAddParticipantsToAllowList)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Interface() protoreflect.ProtoMessage {
+	return (*MsgAddParticipantsToAllowList)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgAddParticipantsToAllowList_authority, value) {
+			return
+		}
+	}
+	if len(x.Addresses) != 0 {
+		value := protoreflect.ValueOfList(&_MsgAddParticipantsToAllowList_2_list{list: &x.Addresses})
+		if !f(fd_MsgAddParticipantsToAllowList_addresses, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+		return len(x.Addresses) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+		x.Authority = ""
+	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+		x.Addresses = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+		value := x.Authority
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+		if len(x.Addresses) == 0 {
+			return protoreflect.ValueOfList(&_MsgAddParticipantsToAllowList_2_list{})
+		}
+		listValue := &_MsgAddParticipantsToAllowList_2_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+		lv := value.List()
+		clv := lv.(*_MsgAddParticipantsToAllowList_2_list)
+		x.Addresses = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowList) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+		if x.Addresses == nil {
+			x.Addresses = []string{}
+		}
+		value := &_MsgAddParticipantsToAllowList_2_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgAddParticipantsToAllowList is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgAddParticipantsToAllowList) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+		list := []string{}
+		return protoreflect.ValueOfList(&_MsgAddParticipantsToAllowList_2_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgAddParticipantsToAllowList) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgAddParticipantsToAllowList", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgAddParticipantsToAllowList) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowList) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgAddParticipantsToAllowList) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgAddParticipantsToAllowList)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Authority)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Addresses) > 0 {
+			for _, s := range x.Addresses {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgAddParticipantsToAllowList)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Addresses) > 0 {
+			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.Addresses[iNdEx])
+				copy(dAtA[i:], x.Addresses[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgAddParticipantsToAllowList)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowList: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowList: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Authority = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgAddParticipantsToAllowListResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgAddParticipantsToAllowListResponse = File_inference_inference_tx_proto.Messages().ByName("MsgAddParticipantsToAllowListResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgAddParticipantsToAllowListResponse)(nil)
+
+type fastReflection_MsgAddParticipantsToAllowListResponse MsgAddParticipantsToAllowListResponse
+
+func (x *MsgAddParticipantsToAllowListResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgAddParticipantsToAllowListResponse)(x)
+}
+
+func (x *MsgAddParticipantsToAllowListResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[43]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgAddParticipantsToAllowListResponse_messageType fastReflection_MsgAddParticipantsToAllowListResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgAddParticipantsToAllowListResponse_messageType{}
+
+type fastReflection_MsgAddParticipantsToAllowListResponse_messageType struct{}
+
+func (x fastReflection_MsgAddParticipantsToAllowListResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgAddParticipantsToAllowListResponse)(nil)
+}
+func (x fastReflection_MsgAddParticipantsToAllowListResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgAddParticipantsToAllowListResponse)
+}
+func (x fastReflection_MsgAddParticipantsToAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgAddParticipantsToAllowListResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgAddParticipantsToAllowListResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgAddParticipantsToAllowListResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgAddParticipantsToAllowListResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgAddParticipantsToAllowListResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgAddParticipantsToAllowListResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgAddParticipantsToAllowListResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgAddParticipantsToAllowListResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgAddParticipantsToAllowListResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgAddParticipantsToAllowListResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowListResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_MsgRemoveParticipantsFromAllowList_2_list)(nil)
+
+type _MsgRemoveParticipantsFromAllowList_2_list struct {
+	list *[]string
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message MsgRemoveParticipantsFromAllowList at list field Addresses as it is not of Message kind"))
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_MsgRemoveParticipantsFromAllowList_2_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_MsgRemoveParticipantsFromAllowList           protoreflect.MessageDescriptor
+	fd_MsgRemoveParticipantsFromAllowList_authority protoreflect.FieldDescriptor
+	fd_MsgRemoveParticipantsFromAllowList_addresses protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgRemoveParticipantsFromAllowList = File_inference_inference_tx_proto.Messages().ByName("MsgRemoveParticipantsFromAllowList")
+	fd_MsgRemoveParticipantsFromAllowList_authority = md_MsgRemoveParticipantsFromAllowList.Fields().ByName("authority")
+	fd_MsgRemoveParticipantsFromAllowList_addresses = md_MsgRemoveParticipantsFromAllowList.Fields().ByName("addresses")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgRemoveParticipantsFromAllowList)(nil)
+
+type fastReflection_MsgRemoveParticipantsFromAllowList MsgRemoveParticipantsFromAllowList
+
+func (x *MsgRemoveParticipantsFromAllowList) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRemoveParticipantsFromAllowList)(x)
+}
+
+func (x *MsgRemoveParticipantsFromAllowList) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[44]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgRemoveParticipantsFromAllowList_messageType fastReflection_MsgRemoveParticipantsFromAllowList_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRemoveParticipantsFromAllowList_messageType{}
+
+type fastReflection_MsgRemoveParticipantsFromAllowList_messageType struct{}
+
+func (x fastReflection_MsgRemoveParticipantsFromAllowList_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRemoveParticipantsFromAllowList)(nil)
+}
+func (x fastReflection_MsgRemoveParticipantsFromAllowList_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRemoveParticipantsFromAllowList)
+}
+func (x fastReflection_MsgRemoveParticipantsFromAllowList_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRemoveParticipantsFromAllowList
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRemoveParticipantsFromAllowList
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRemoveParticipantsFromAllowList_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) New() protoreflect.Message {
+	return new(fastReflection_MsgRemoveParticipantsFromAllowList)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Interface() protoreflect.ProtoMessage {
+	return (*MsgRemoveParticipantsFromAllowList)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgRemoveParticipantsFromAllowList_authority, value) {
+			return
+		}
+	}
+	if len(x.Addresses) != 0 {
+		value := protoreflect.ValueOfList(&_MsgRemoveParticipantsFromAllowList_2_list{list: &x.Addresses})
+		if !f(fd_MsgRemoveParticipantsFromAllowList_addresses, value) {
+			return
+		}
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
+		return len(x.Addresses) != 0
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+		x.Authority = ""
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
+		x.Addresses = nil
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+		value := x.Authority
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
+		if len(x.Addresses) == 0 {
+			return protoreflect.ValueOfList(&_MsgRemoveParticipantsFromAllowList_2_list{})
+		}
+		listValue := &_MsgRemoveParticipantsFromAllowList_2_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(listValue)
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
+		lv := value.List()
+		clv := lv.(*_MsgRemoveParticipantsFromAllowList_2_list)
+		x.Addresses = *clv.list
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
+		if x.Addresses == nil {
+			x.Addresses = []string{}
+		}
+		value := &_MsgRemoveParticipantsFromAllowList_2_list{list: &x.Addresses}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRemoveParticipantsFromAllowList is not mutable"))
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
+		list := []string{}
+		return protoreflect.ValueOfList(&_MsgRemoveParticipantsFromAllowList_2_list{list: &list})
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRemoveParticipantsFromAllowList", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowList)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		l = len(x.Authority)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if len(x.Addresses) > 0 {
+			for _, s := range x.Addresses {
+				l = len(s)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowList)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if len(x.Addresses) > 0 {
+			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
+				i -= len(x.Addresses[iNdEx])
+				copy(dAtA[i:], x.Addresses[iNdEx])
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
+				i--
+				dAtA[i] = 0x12
+			}
+		}
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+			i--
+			dAtA[i] = 0xa
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowList)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowList: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowList: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Authority = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
+				iNdEx = postIndex
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var (
+	md_MsgRemoveParticipantsFromAllowListResponse protoreflect.MessageDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgRemoveParticipantsFromAllowListResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRemoveParticipantsFromAllowListResponse")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgRemoveParticipantsFromAllowListResponse)(nil)
+
+type fastReflection_MsgRemoveParticipantsFromAllowListResponse MsgRemoveParticipantsFromAllowListResponse
+
+func (x *MsgRemoveParticipantsFromAllowListResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRemoveParticipantsFromAllowListResponse)(x)
+}
+
+func (x *MsgRemoveParticipantsFromAllowListResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[45]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType{}
+
+type fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType struct{}
+
+func (x fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRemoveParticipantsFromAllowListResponse)(nil)
+}
+func (x fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRemoveParticipantsFromAllowListResponse)
+}
+func (x fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRemoveParticipantsFromAllowListResponse
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRemoveParticipantsFromAllowListResponse
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRemoveParticipantsFromAllowListResponse)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRemoveParticipantsFromAllowListResponse)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Clear clears the field such that a subsequent Has call reports false.
+//
+// Clearing an extension field clears both the extension type and value
+// associated with the given field number.
+//
+// Clear is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Get retrieves the value for a field.
+//
+// For unpopulated scalars, it returns the default value, where
+// the default value of a bytes scalar is guaranteed to be a copy.
+// For unpopulated composite types, it returns an empty, read-only view
+// of the value; to obtain a mutable reference, use Mutable.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+	switch descriptor.FullName() {
+	default:
+		if descriptor.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", descriptor.FullName()))
+	}
+}
+
+// Set stores the value for a field.
+//
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType.
+// When setting a composite type, it is unspecified whether the stored value
+// aliases the source's memory in any way. If the composite value is an
+// empty, read-only value, then it panics.
+//
+// Set is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// Mutable returns a mutable reference to a composite type.
+//
+// If the field is unpopulated, it may allocate a composite value.
+// For a field belonging to a oneof, it implicitly clears any other field
+// that may be currently set within the same oneof.
+// For extension fields, it implicitly stores the provided ExtensionType
+// if not already stored.
+// It panics if the field does not contain a composite type.
+//
+// Mutable is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// NewField returns a new value that is assignable to the field
+// for the given descriptor. For scalars, this returns the default value.
+// For lists, maps, and messages, this returns a new, empty, mutable value.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+	switch fd.FullName() {
+	default:
+		if fd.IsExtension() {
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+		}
+		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+	}
+}
+
+// WhichOneof reports which field within the oneof is populated,
+// returning nil if none are populated.
+// It panics if the oneof descriptor does not belong to this message.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+	switch d.FullName() {
+	default:
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRemoveParticipantsFromAllowListResponse", d.FullName()))
+	}
+	panic("unreachable")
+}
+
+// GetUnknown retrieves the entire list of unknown fields.
+// The caller may only mutate the contents of the RawFields
+// if the mutated bytes are stored back into the message with SetUnknown.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) GetUnknown() protoreflect.RawFields {
+	return x.unknownFields
+}
+
+// SetUnknown stores an entire list of unknown fields.
+// The raw fields must be syntactically valid according to the wire format.
+// An implementation may panic if this is not the case.
+// Once stored, the caller must not mutate the content of the RawFields.
+// An empty RawFields may be passed to clear the fields.
+//
+// SetUnknown is a mutating operation and unsafe for concurrent use.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) SetUnknown(fields protoreflect.RawFields) {
+	x.unknownFields = fields
+}
+
+// IsValid reports whether the message is valid.
+//
+// An invalid message is an empty, read-only value.
+//
+// An invalid message often corresponds to a nil pointer of the concrete
+// message type, but the details are implementation dependent.
+// Validity is not part of the protobuf data model, and may not
+// be preserved in marshaling or other operations.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) IsValid() bool {
+	return x != nil
+}
+
+// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
+// This method may return nil.
+//
+// The returned methods type is identical to
+// "google.golang.org/protobuf/runtime/protoiface".Methods.
+// Consult the protoiface package documentation for details.
+func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) ProtoMethods() *protoiface.Methods {
+	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
+		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowListResponse)
+		if x == nil {
+			return protoiface.SizeOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Size:              0,
+			}
+		}
+		options := runtime.SizeInputToOptions(input)
+		_ = options
+		var n int
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			n += len(x.unknownFields)
+		}
+		return protoiface.SizeOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Size:              n,
+		}
+	}
+
+	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
+		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowListResponse)
+		if x == nil {
+			return protoiface.MarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Buf:               input.Buf,
+			}, nil
+		}
+		options := runtime.MarshalInputToOptions(input)
+		_ = options
+		size := options.Size(x)
+		dAtA := make([]byte, size)
+		i := len(dAtA)
+		_ = i
+		var l int
+		_ = l
+		if x.unknownFields != nil {
+			i -= len(x.unknownFields)
+			copy(dAtA[i:], x.unknownFields)
+		}
+		if input.Buf != nil {
+			input.Buf = append(input.Buf, dAtA...)
+		} else {
+			input.Buf = dAtA
+		}
+		return protoiface.MarshalOutput{
+			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+			Buf:               input.Buf,
+		}, nil
+	}
+	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
+		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowListResponse)
+		if x == nil {
+			return protoiface.UnmarshalOutput{
+				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+				Flags:             input.Flags,
+			}, nil
+		}
+		options := runtime.UnmarshalInputToOptions(input)
+		_ = options
+		dAtA := input.Buf
+		l := len(dAtA)
+		iNdEx := 0
+		for iNdEx < l {
+			preIndex := iNdEx
+			var wire uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowListResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			default:
+				iNdEx = preIndex
+				skippy, err := runtime.Skip(dAtA[iNdEx:])
+				if err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				if (skippy < 0) || (iNdEx+skippy) < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if (iNdEx + skippy) > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				if !options.DiscardUnknown {
+					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+				}
+				iNdEx += skippy
+			}
+		}
+
+		if iNdEx > l {
+			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+		}
+		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
+	}
+	return &protoiface.Methods{
+		NoUnkeyedLiterals: struct{}{},
+		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
+		Size:              size,
+		Marshal:           marshal,
+		Unmarshal:         unmarshal,
+		Merge:             nil,
+		CheckInitialized:  nil,
+	}
+}
+
+var _ protoreflect.List = (*_MsgRegisterBridgeAddresses_3_list)(nil)
+
+type _MsgRegisterBridgeAddresses_3_list struct {
+	list *[]string
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfString((*x.list)[i])
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.String()
+	concreteValue := valueUnwrapped
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) AppendMutable() protoreflect.Value {
+	panic(fmt.Errorf("AppendMutable can not be called on message MsgRegisterBridgeAddresses at list field Addresses as it is not of Message kind"))
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) Truncate(n int) {
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) NewElement() protoreflect.Value {
+	v := ""
+	return protoreflect.ValueOfString(v)
+}
+
+func (x *_MsgRegisterBridgeAddresses_3_list) IsValid() bool {
+	return x.list != nil
+}
+
+var (
+	md_MsgRegisterBridgeAddresses           protoreflect.MessageDescriptor
+	fd_MsgRegisterBridgeAddresses_authority protoreflect.FieldDescriptor
+	fd_MsgRegisterBridgeAddresses_chainName protoreflect.FieldDescriptor
+	fd_MsgRegisterBridgeAddresses_addresses protoreflect.FieldDescriptor
+)
+
+func init() {
+	file_inference_inference_tx_proto_init()
+	md_MsgRegisterBridgeAddresses = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterBridgeAddresses")
+	fd_MsgRegisterBridgeAddresses_authority = md_MsgRegisterBridgeAddresses.Fields().ByName("authority")
+	fd_MsgRegisterBridgeAddresses_chainName = md_MsgRegisterBridgeAddresses.Fields().ByName("chainName")
+	fd_MsgRegisterBridgeAddresses_addresses = md_MsgRegisterBridgeAddresses.Fields().ByName("addresses")
+}
+
+var _ protoreflect.Message = (*fastReflection_MsgRegisterBridgeAddresses)(nil)
+
+type fastReflection_MsgRegisterBridgeAddresses MsgRegisterBridgeAddresses
+
+func (x *MsgRegisterBridgeAddresses) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterBridgeAddresses)(x)
+}
+
+func (x *MsgRegisterBridgeAddresses) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[46]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+var _fastReflection_MsgRegisterBridgeAddresses_messageType fastReflection_MsgRegisterBridgeAddresses_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterBridgeAddresses_messageType{}
+
+type fastReflection_MsgRegisterBridgeAddresses_messageType struct{}
+
+func (x fastReflection_MsgRegisterBridgeAddresses_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterBridgeAddresses)(nil)
+}
+func (x fastReflection_MsgRegisterBridgeAddresses_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterBridgeAddresses)
+}
+func (x fastReflection_MsgRegisterBridgeAddresses_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterBridgeAddresses
+}
+
+// Descriptor returns message descriptor, which contains only the protobuf
+// type information for the message.
+func (x *fastReflection_MsgRegisterBridgeAddresses) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterBridgeAddresses
+}
+
+// Type returns the message type, which encapsulates both Go and protobuf
+// type information. If the Go type information is not needed,
+// it is recommended that the message descriptor be used instead.
+func (x *fastReflection_MsgRegisterBridgeAddresses) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterBridgeAddresses_messageType
+}
+
+// New returns a newly allocated and mutable empty message.
+func (x *fastReflection_MsgRegisterBridgeAddresses) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterBridgeAddresses)
+}
+
+// Interface unwraps the message reflection interface and
+// returns the underlying ProtoMessage interface.
+func (x *fastReflection_MsgRegisterBridgeAddresses) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterBridgeAddresses)(x)
+}
+
+// Range iterates over every populated field in an undefined order,
+// calling f for each field descriptor and value encountered.
+// Range returns immediately if f returns false.
+// While iterating, mutating operations may only be performed
+// on the current field descriptor.
+func (x *fastReflection_MsgRegisterBridgeAddresses) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgAddParticipantsToAllowList_authority, value) {
+		if !f(fd_MsgRegisterBridgeAddresses_authority, value) {
+			return
+		}
+	}
+	if x.ChainName != "" {
+		value := protoreflect.ValueOfString(x.ChainName)
+		if !f(fd_MsgRegisterBridgeAddresses_chainName, value) {
 			return
 		}
 	}
 	if len(x.Addresses) != 0 {
-		value := protoreflect.ValueOfList(&_MsgAddParticipantsToAllowList_2_list{list: &x.Addresses})
-		if !f(fd_MsgAddParticipantsToAllowList_addresses, value) {
+		value := protoreflect.ValueOfList(&_MsgRegisterBridgeAddresses_3_list{list: &x.Addresses})
+		if !f(fd_MsgRegisterBridgeAddresses_addresses, value) {
 			return
 		}
 	}
@@ -22423,17 +25145,19 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterBridgeAddresses) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+	case "inference.inference.MsgRegisterBridgeAddresses.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+		return x.ChainName != ""
+	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
 		return len(x.Addresses) != 0
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22443,17 +25167,19 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterBridgeAddresses) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+	case "inference.inference.MsgRegisterBridgeAddresses.authority":
 		x.Authority = ""
-	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+		x.ChainName = ""
+	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
 		x.Addresses = nil
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22463,22 +25189,25 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterBridgeAddresses) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+	case "inference.inference.MsgRegisterBridgeAddresses.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+		value := x.ChainName
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
 		if len(x.Addresses) == 0 {
-			return protoreflect.ValueOfList(&_MsgAddParticipantsToAllowList_2_list{})
+			return protoreflect.ValueOfList(&_MsgRegisterBridgeAddresses_3_list{})
 		}
-		listValue := &_MsgAddParticipantsToAllowList_2_list{list: &x.Addresses}
+		listValue := &_MsgRegisterBridgeAddresses_3_list{list: &x.Addresses}
 		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -22492,19 +25221,21 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterBridgeAddresses) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+	case "inference.inference.MsgRegisterBridgeAddresses.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+		x.ChainName = value.Interface().(string)
+	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
 		lv := value.List()
-		clv := lv.(*_MsgAddParticipantsToAllowList_2_list)
+		clv := lv.(*_MsgRegisterBridgeAddresses_3_list)
 		x.Addresses = *clv.list
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22518,49 +25249,53 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowList) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterBridgeAddresses) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
 		if x.Addresses == nil {
 			x.Addresses = []string{}
 		}
-		value := &_MsgAddParticipantsToAllowList_2_list{list: &x.Addresses}
+		value := &_MsgRegisterBridgeAddresses_3_list{list: &x.Addresses}
 		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgAddParticipantsToAllowList.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgAddParticipantsToAllowList is not mutable"))
+	case "inference.inference.MsgRegisterBridgeAddresses.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterBridgeAddresses is not mutable"))
+	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+		panic(fmt.Errorf("field chainName of message inference.inference.MsgRegisterBridgeAddresses is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgAddParticipantsToAllowList) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterBridgeAddresses) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgAddParticipantsToAllowList.authority":
+	case "inference.inference.MsgRegisterBridgeAddresses.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgAddParticipantsToAllowList.addresses":
+	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
 		list := []string{}
-		return protoreflect.ValueOfList(&_MsgAddParticipantsToAllowList_2_list{list: &list})
+		return protoreflect.ValueOfList(&_MsgRegisterBridgeAddresses_3_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgAddParticipantsToAllowList) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterBridgeAddresses) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgAddParticipantsToAllowList", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterBridgeAddresses", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -22568,7 +25303,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgAddParticipantsToAllowList) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterBridgeAddresses) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -22579,7 +25314,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowList) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterBridgeAddresses) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -22591,7 +25326,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgAddParticipantsToAllowList) IsValid() bool {
+func (x *fastReflection_MsgRegisterBridgeAddresses) IsValid() bool {
 	return x != nil
 }
 
@@ -22601,9 +25336,9 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgAddParticipantsToAllowList)
+		x := input.Message.Interface().(*MsgRegisterBridgeAddresses)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22619,6 +25354,10 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
+		l = len(x.ChainName)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if len(x.Addresses) > 0 {
 			for _, s := range x.Addresses {
 				l = len(s)
@@ -22635,7 +25374,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgAddParticipantsToAllowList)
+		x := input.Message.Interface().(*MsgRegisterBridgeAddresses)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22660,9 +25399,16 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 				copy(dAtA[i:], x.Addresses[iNdEx])
 				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
 				i--
-				dAtA[i] = 0x12
+				dAtA[i] = 0x1a
 			}
 		}
+		if len(x.ChainName) > 0 {
+			i -= len(x.ChainName)
+			copy(dAtA[i:], x.ChainName)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName)))
+			i--
+			dAtA[i] = 0x12
+		}
 		if len(x.Authority) > 0 {
 			i -= len(x.Authority)
 			copy(dAtA[i:], x.Authority)
@@ -22681,7 +25427,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgAddParticipantsToAllowList)
+		x := input.Message.Interface().(*MsgRegisterBridgeAddresses)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -22713,10 +25459,10 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowList: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddresses: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowList: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -22752,6 +25498,38 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainName", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ChainName = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
 				if wireType != 2 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
 				}
@@ -22819,24 +25597,24 @@ func (x *fastReflection_MsgAddParticipantsToAllowList) ProtoMethods() *protoifac
 }
 
 var (
-	md_MsgAddParticipantsToAllowListResponse protoreflect.MessageDescriptor
+	md_MsgRegisterBridgeAddressesResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgAddParticipantsToAllowListResponse = File_inference_inference_tx_proto.Messages().ByName("MsgAddParticipantsToAllowListResponse")
+	md_MsgRegisterBridgeAddressesResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterBridgeAddressesResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgAddParticipantsToAllowListResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterBridgeAddressesResponse)(nil)
 
-type fastReflection_MsgAddParticipantsToAllowListResponse MsgAddParticipantsToAllowListResponse
+type fastReflection_MsgRegisterBridgeAddressesResponse MsgRegisterBridgeAddressesResponse
 
-func (x *MsgAddParticipantsToAllowListResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgAddParticipantsToAllowListResponse)(x)
+func (x *MsgRegisterBridgeAddressesResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterBridgeAddressesResponse)(x)
 }
 
-func (x *MsgAddParticipantsToAllowListResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[41]
+func (x *MsgRegisterBridgeAddressesResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[47]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -22847,43 +25625,43 @@ func (x *MsgAddParticipantsToAllowListResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgAddParticipantsToAllowListResponse_messageType fastReflection_MsgAddParticipantsToAllowListResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgAddParticipantsToAllowListResponse_messageType{}
+var _fastReflection_MsgRegisterBridgeAddressesResponse_messageType fastReflection_MsgRegisterBridgeAddressesResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterBridgeAddressesResponse_messageType{}
 
-type fastReflection_MsgAddParticipantsToAllowListResponse_messageType struct{}
+type fastReflection_MsgRegisterBridgeAddressesResponse_messageType struct{}
 
-func (x fastReflection_MsgAddParticipantsToAllowListResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgAddParticipantsToAllowListResponse)(nil)
+func (x fastReflection_MsgRegisterBridgeAddressesResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterBridgeAddressesResponse)(nil)
 }
-func (x fastReflection_MsgAddParticipantsToAllowListResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgAddParticipantsToAllowListResponse)
+func (x fastReflection_MsgRegisterBridgeAddressesResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterBridgeAddressesResponse)
 }
-func (x fastReflection_MsgAddParticipantsToAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgAddParticipantsToAllowListResponse
+func (x fastReflection_MsgRegisterBridgeAddressesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterBridgeAddressesResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgAddParticipantsToAllowListResponse
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterBridgeAddressesResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgAddParticipantsToAllowListResponse_messageType
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterBridgeAddressesResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgAddParticipantsToAllowListResponse)
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterBridgeAddressesResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgAddParticipantsToAllowListResponse)(x)
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterBridgeAddressesResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -22891,7 +25669,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -22905,13 +25683,13 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22921,13 +25699,13 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22937,13 +25715,13 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -22957,13 +25735,13 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -22977,36 +25755,36 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgAddParticipantsToAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgAddParticipantsToAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgAddParticipantsToAllowListResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterBridgeAddressesResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -23014,7 +25792,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -23025,7 +25803,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -23037,7 +25815,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) IsValid() bool {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -23047,9 +25825,9 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgAddParticipantsToAllowListResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterBridgeAddressesResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgAddParticipantsToAllowListResponse)
+		x := input.Message.Interface().(*MsgRegisterBridgeAddressesResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23071,7 +25849,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgAddParticipantsToAllowListResponse)
+		x := input.Message.Interface().(*MsgRegisterBridgeAddressesResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23101,7 +25879,7 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgAddParticipantsToAllowListResponse)
+		x := input.Message.Interface().(*MsgRegisterBridgeAddressesResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23133,10 +25911,10 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowListResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddressesResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgAddParticipantsToAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddressesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -23174,75 +25952,39 @@ func (x *fastReflection_MsgAddParticipantsToAllowListResponse) ProtoMethods() *p
 	}
 }
 
-var _ protoreflect.List = (*_MsgRemoveParticipantsFromAllowList_2_list)(nil)
-
-type _MsgRemoveParticipantsFromAllowList_2_list struct {
-	list *[]string
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfString((*x.list)[i])
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message MsgRemoveParticipantsFromAllowList at list field Addresses as it is not of Message kind"))
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) Truncate(n int) {
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) NewElement() protoreflect.Value {
-	v := ""
-	return protoreflect.ValueOfString(v)
-}
-
-func (x *_MsgRemoveParticipantsFromAllowList_2_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MsgRemoveParticipantsFromAllowList           protoreflect.MessageDescriptor
-	fd_MsgRemoveParticipantsFromAllowList_authority protoreflect.FieldDescriptor
-	fd_MsgRemoveParticipantsFromAllowList_addresses protoreflect.FieldDescriptor
+	md_MsgRegisterTokenMetadata                 protoreflect.MessageDescriptor
+	fd_MsgRegisterTokenMetadata_authority       protoreflect.FieldDescriptor
+	fd_MsgRegisterTokenMetadata_chainId         protoreflect.FieldDescriptor
+	fd_MsgRegisterTokenMetadata_contractAddress protoreflect.FieldDescriptor
+	fd_MsgRegisterTokenMetadata_name            protoreflect.FieldDescriptor
+	fd_MsgRegisterTokenMetadata_symbol          protoreflect.FieldDescriptor
+	fd_MsgRegisterTokenMetadata_decimals        protoreflect.FieldDescriptor
+	fd_MsgRegisterTokenMetadata_overwrite       protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRemoveParticipantsFromAllowList = File_inference_inference_tx_proto.Messages().ByName("MsgRemoveParticipantsFromAllowList")
-	fd_MsgRemoveParticipantsFromAllowList_authority = md_MsgRemoveParticipantsFromAllowList.Fields().ByName("authority")
-	fd_MsgRemoveParticipantsFromAllowList_addresses = md_MsgRemoveParticipantsFromAllowList.Fields().ByName("addresses")
+	md_MsgRegisterTokenMetadata = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterTokenMetadata")
+	fd_MsgRegisterTokenMetadata_authority = md_MsgRegisterTokenMetadata.Fields().ByName("authority")
+	fd_MsgRegisterTokenMetadata_chainId = md_MsgRegisterTokenMetadata.Fields().ByName("chainId")
+	fd_MsgRegisterTokenMetadata_contractAddress = md_MsgRegisterTokenMetadata.Fields().ByName("contractAddress")
+	fd_MsgRegisterTokenMetadata_name = md_MsgRegisterTokenMetadata.Fields().ByName("name")
+	fd_MsgRegisterTokenMetadata_symbol = md_MsgRegisterTokenMetadata.Fields().ByName("symbol")
+	fd_MsgRegisterTokenMetadata_decimals = md_MsgRegisterTokenMetadata.Fields().ByName("decimals")
+	fd_MsgRegisterTokenMetadata_overwrite = md_MsgRegisterTokenMetadata.Fields().ByName("overwrite")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRemoveParticipantsFromAllowList)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterTokenMetadata)(nil)
 
-type fastReflection_MsgRemoveParticipantsFromAllowList MsgRemoveParticipantsFromAllowList
+type fastReflection_MsgRegisterTokenMetadata MsgRegisterTokenMetadata
 
-func (x *MsgRemoveParticipantsFromAllowList) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRemoveParticipantsFromAllowList)(x)
+func (x *MsgRegisterTokenMetadata) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterTokenMetadata)(x)
 }
 
-func (x *MsgRemoveParticipantsFromAllowList) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[42]
+func (x *MsgRegisterTokenMetadata) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[48]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -23253,43 +25995,43 @@ func (x *MsgRemoveParticipantsFromAllowList) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRemoveParticipantsFromAllowList_messageType fastReflection_MsgRemoveParticipantsFromAllowList_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRemoveParticipantsFromAllowList_messageType{}
+var _fastReflection_MsgRegisterTokenMetadata_messageType fastReflection_MsgRegisterTokenMetadata_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterTokenMetadata_messageType{}
 
-type fastReflection_MsgRemoveParticipantsFromAllowList_messageType struct{}
+type fastReflection_MsgRegisterTokenMetadata_messageType struct{}
 
-func (x fastReflection_MsgRemoveParticipantsFromAllowList_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRemoveParticipantsFromAllowList)(nil)
+func (x fastReflection_MsgRegisterTokenMetadata_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterTokenMetadata)(nil)
 }
-func (x fastReflection_MsgRemoveParticipantsFromAllowList_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRemoveParticipantsFromAllowList)
+func (x fastReflection_MsgRegisterTokenMetadata_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterTokenMetadata)
 }
-func (x fastReflection_MsgRemoveParticipantsFromAllowList_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRemoveParticipantsFromAllowList
+func (x fastReflection_MsgRegisterTokenMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterTokenMetadata
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRemoveParticipantsFromAllowList
+func (x *fastReflection_MsgRegisterTokenMetadata) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterTokenMetadata
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRemoveParticipantsFromAllowList_messageType
+func (x *fastReflection_MsgRegisterTokenMetadata) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterTokenMetadata_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) New() protoreflect.Message {
-	return new(fastReflection_MsgRemoveParticipantsFromAllowList)
+func (x *fastReflection_MsgRegisterTokenMetadata) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterTokenMetadata)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Interface() protoreflect.ProtoMessage {
-	return (*MsgRemoveParticipantsFromAllowList)(x)
+func (x *fastReflection_MsgRegisterTokenMetadata) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterTokenMetadata)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -23297,16 +26039,46 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterTokenMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRemoveParticipantsFromAllowList_authority, value) {
+		if !f(fd_MsgRegisterTokenMetadata_authority, value) {
+			return
+		}
+	}
+	if x.ChainId != "" {
+		value := protoreflect.ValueOfString(x.ChainId)
+		if !f(fd_MsgRegisterTokenMetadata_chainId, value) {
+			return
+		}
+	}
+	if x.ContractAddress != "" {
+		value := protoreflect.ValueOfString(x.ContractAddress)
+		if !f(fd_MsgRegisterTokenMetadata_contractAddress, value) {
+			return
+		}
+	}
+	if x.Name != "" {
+		value := protoreflect.ValueOfString(x.Name)
+		if !f(fd_MsgRegisterTokenMetadata_name, value) {
 			return
 		}
 	}
-	if len(x.Addresses) != 0 {
-		value := protoreflect.ValueOfList(&_MsgRemoveParticipantsFromAllowList_2_list{list: &x.Addresses})
-		if !f(fd_MsgRemoveParticipantsFromAllowList_addresses, value) {
+	if x.Symbol != "" {
+		value := protoreflect.ValueOfString(x.Symbol)
+		if !f(fd_MsgRegisterTokenMetadata_symbol, value) {
+			return
+		}
+	}
+	if x.Decimals != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Decimals)
+		if !f(fd_MsgRegisterTokenMetadata_decimals, value) {
+			return
+		}
+	}
+	if x.Overwrite != false {
+		value := protoreflect.ValueOfBool(x.Overwrite)
+		if !f(fd_MsgRegisterTokenMetadata_overwrite, value) {
 			return
 		}
 	}
@@ -23323,17 +26095,27 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterTokenMetadata) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+	case "inference.inference.MsgRegisterTokenMetadata.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
-		return len(x.Addresses) != 0
+	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+		return x.ChainId != ""
+	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+		return x.ContractAddress != ""
+	case "inference.inference.MsgRegisterTokenMetadata.name":
+		return x.Name != ""
+	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+		return x.Symbol != ""
+	case "inference.inference.MsgRegisterTokenMetadata.decimals":
+		return x.Decimals != uint32(0)
+	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
+		return x.Overwrite != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23343,17 +26125,27 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterTokenMetadata) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+	case "inference.inference.MsgRegisterTokenMetadata.authority":
 		x.Authority = ""
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
-		x.Addresses = nil
+	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+		x.ChainId = ""
+	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+		x.ContractAddress = ""
+	case "inference.inference.MsgRegisterTokenMetadata.name":
+		x.Name = ""
+	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+		x.Symbol = ""
+	case "inference.inference.MsgRegisterTokenMetadata.decimals":
+		x.Decimals = uint32(0)
+	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
+		x.Overwrite = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23363,22 +26155,34 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterTokenMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+	case "inference.inference.MsgRegisterTokenMetadata.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
-		if len(x.Addresses) == 0 {
-			return protoreflect.ValueOfList(&_MsgRemoveParticipantsFromAllowList_2_list{})
-		}
-		listValue := &_MsgRemoveParticipantsFromAllowList_2_list{list: &x.Addresses}
-		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+		value := x.ChainId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+		value := x.ContractAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterTokenMetadata.name":
+		value := x.Name
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+		value := x.Symbol
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterTokenMetadata.decimals":
+		value := x.Decimals
+		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
+		value := x.Overwrite
+		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -23392,19 +26196,27 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterTokenMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+	case "inference.inference.MsgRegisterTokenMetadata.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
-		lv := value.List()
-		clv := lv.(*_MsgRemoveParticipantsFromAllowList_2_list)
-		x.Addresses = *clv.list
+	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+		x.ChainId = value.Interface().(string)
+	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+		x.ContractAddress = value.Interface().(string)
+	case "inference.inference.MsgRegisterTokenMetadata.name":
+		x.Name = value.Interface().(string)
+	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+		x.Symbol = value.Interface().(string)
+	case "inference.inference.MsgRegisterTokenMetadata.decimals":
+		x.Decimals = uint32(value.Uint())
+	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
+		x.Overwrite = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23418,49 +26230,64 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterTokenMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
-		if x.Addresses == nil {
-			x.Addresses = []string{}
-		}
-		value := &_MsgRemoveParticipantsFromAllowList_2_list{list: &x.Addresses}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRemoveParticipantsFromAllowList is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+		panic(fmt.Errorf("field chainId of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+		panic(fmt.Errorf("field contractAddress of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.name":
+		panic(fmt.Errorf("field name of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+		panic(fmt.Errorf("field symbol of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.decimals":
+		panic(fmt.Errorf("field decimals of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
+		panic(fmt.Errorf("field overwrite of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterTokenMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.authority":
+	case "inference.inference.MsgRegisterTokenMetadata.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRemoveParticipantsFromAllowList.addresses":
-		list := []string{}
-		return protoreflect.ValueOfList(&_MsgRemoveParticipantsFromAllowList_2_list{list: &list})
+	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterTokenMetadata.name":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterTokenMetadata.decimals":
+		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
+		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowList"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowList does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterTokenMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRemoveParticipantsFromAllowList", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterTokenMetadata", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -23468,7 +26295,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterTokenMetadata) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -23479,7 +26306,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterTokenMetadata) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -23491,7 +26318,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) IsValid() bool {
+func (x *fastReflection_MsgRegisterTokenMetadata) IsValid() bool {
 	return x != nil
 }
 
@@ -23501,9 +26328,9 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowList)
+		x := input.Message.Interface().(*MsgRegisterTokenMetadata)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23519,11 +26346,27 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if len(x.Addresses) > 0 {
-			for _, s := range x.Addresses {
-				l = len(s)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		l = len(x.ChainId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.ContractAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Name)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Symbol)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Decimals != 0 {
+			n += 1 + runtime.Sov(uint64(x.Decimals))
+		}
+		if x.Overwrite {
+			n += 2
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -23535,7 +26378,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowList)
+		x := input.Message.Interface().(*MsgRegisterTokenMetadata)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23554,14 +26397,48 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Addresses) > 0 {
-			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
-				i -= len(x.Addresses[iNdEx])
-				copy(dAtA[i:], x.Addresses[iNdEx])
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
-				i--
-				dAtA[i] = 0x12
+		if x.Overwrite {
+			i--
+			if x.Overwrite {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
 			}
+			i--
+			dAtA[i] = 0x38
+		}
+		if x.Decimals != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
+			i--
+			dAtA[i] = 0x30
+		}
+		if len(x.Symbol) > 0 {
+			i -= len(x.Symbol)
+			copy(dAtA[i:], x.Symbol)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Symbol)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.Name) > 0 {
+			i -= len(x.Name)
+			copy(dAtA[i:], x.Name)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.ContractAddress) > 0 {
+			i -= len(x.ContractAddress)
+			copy(dAtA[i:], x.ContractAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if len(x.ChainId) > 0 {
+			i -= len(x.ChainId)
+			copy(dAtA[i:], x.ChainId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+			i--
+			dAtA[i] = 0x12
 		}
 		if len(x.Authority) > 0 {
 			i -= len(x.Authority)
@@ -23581,7 +26458,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowList)
+		x := input.Message.Interface().(*MsgRegisterTokenMetadata)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23613,10 +26490,10 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowList: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadata: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowList: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -23653,7 +26530,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -23681,8 +26558,143 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
+				x.ChainId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ContractAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Name = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Symbol = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
+			case 6:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
+				}
+				x.Decimals = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Decimals |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 7:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Overwrite", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Overwrite = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -23719,24 +26731,24 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowList) ProtoMethods() *prot
 }
 
 var (
-	md_MsgRemoveParticipantsFromAllowListResponse protoreflect.MessageDescriptor
+	md_MsgRegisterTokenMetadataResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRemoveParticipantsFromAllowListResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRemoveParticipantsFromAllowListResponse")
+	md_MsgRegisterTokenMetadataResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterTokenMetadataResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRemoveParticipantsFromAllowListResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterTokenMetadataResponse)(nil)
 
-type fastReflection_MsgRemoveParticipantsFromAllowListResponse MsgRemoveParticipantsFromAllowListResponse
+type fastReflection_MsgRegisterTokenMetadataResponse MsgRegisterTokenMetadataResponse
 
-func (x *MsgRemoveParticipantsFromAllowListResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRemoveParticipantsFromAllowListResponse)(x)
+func (x *MsgRegisterTokenMetadataResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterTokenMetadataResponse)(x)
 }
 
-func (x *MsgRemoveParticipantsFromAllowListResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[43]
+func (x *MsgRegisterTokenMetadataResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[49]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -23747,43 +26759,43 @@ func (x *MsgRemoveParticipantsFromAllowListResponse) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType{}
+var _fastReflection_MsgRegisterTokenMetadataResponse_messageType fastReflection_MsgRegisterTokenMetadataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterTokenMetadataResponse_messageType{}
 
-type fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType struct{}
+type fastReflection_MsgRegisterTokenMetadataResponse_messageType struct{}
 
-func (x fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRemoveParticipantsFromAllowListResponse)(nil)
+func (x fastReflection_MsgRegisterTokenMetadataResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterTokenMetadataResponse)(nil)
 }
-func (x fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRemoveParticipantsFromAllowListResponse)
+func (x fastReflection_MsgRegisterTokenMetadataResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterTokenMetadataResponse)
 }
-func (x fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRemoveParticipantsFromAllowListResponse
+func (x fastReflection_MsgRegisterTokenMetadataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterTokenMetadataResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRemoveParticipantsFromAllowListResponse
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterTokenMetadataResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRemoveParticipantsFromAllowListResponse_messageType
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterTokenMetadataResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRemoveParticipantsFromAllowListResponse)
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterTokenMetadataResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRemoveParticipantsFromAllowListResponse)(x)
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterTokenMetadataResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -23791,7 +26803,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -23805,13 +26817,13 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23821,13 +26833,13 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23837,13 +26849,13 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -23857,13 +26869,13 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -23877,36 +26889,36 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRemoveParticipantsFromAllowListResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRemoveParticipantsFromAllowListResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRemoveParticipantsFromAllowListResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterTokenMetadataResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -23914,7 +26926,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -23925,7 +26937,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -23937,7 +26949,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) IsValid() bool {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -23947,9 +26959,9 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterTokenMetadataResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowListResponse)
+		x := input.Message.Interface().(*MsgRegisterTokenMetadataResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -23971,7 +26983,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowListResponse)
+		x := input.Message.Interface().(*MsgRegisterTokenMetadataResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24001,7 +27013,7 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRemoveParticipantsFromAllowListResponse)
+		x := input.Message.Interface().(*MsgRegisterTokenMetadataResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24033,10 +27045,10 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowListResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadataResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRemoveParticipantsFromAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -24074,77 +27086,31 @@ func (x *fastReflection_MsgRemoveParticipantsFromAllowListResponse) ProtoMethods
 	}
 }
 
-var _ protoreflect.List = (*_MsgRegisterBridgeAddresses_3_list)(nil)
-
-type _MsgRegisterBridgeAddresses_3_list struct {
-	list *[]string
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfString((*x.list)[i])
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.String()
-	concreteValue := valueUnwrapped
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) AppendMutable() protoreflect.Value {
-	panic(fmt.Errorf("AppendMutable can not be called on message MsgRegisterBridgeAddresses at list field Addresses as it is not of Message kind"))
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) Truncate(n int) {
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) NewElement() protoreflect.Value {
-	v := ""
-	return protoreflect.ValueOfString(v)
-}
-
-func (x *_MsgRegisterBridgeAddresses_3_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MsgRegisterBridgeAddresses           protoreflect.MessageDescriptor
-	fd_MsgRegisterBridgeAddresses_authority protoreflect.FieldDescriptor
-	fd_MsgRegisterBridgeAddresses_chainName protoreflect.FieldDescriptor
-	fd_MsgRegisterBridgeAddresses_addresses protoreflect.FieldDescriptor
+	md_MsgApproveBridgeTokenForTrading                 protoreflect.MessageDescriptor
+	fd_MsgApproveBridgeTokenForTrading_authority       protoreflect.FieldDescriptor
+	fd_MsgApproveBridgeTokenForTrading_chainId         protoreflect.FieldDescriptor
+	fd_MsgApproveBridgeTokenForTrading_contractAddress protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterBridgeAddresses = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterBridgeAddresses")
-	fd_MsgRegisterBridgeAddresses_authority = md_MsgRegisterBridgeAddresses.Fields().ByName("authority")
-	fd_MsgRegisterBridgeAddresses_chainName = md_MsgRegisterBridgeAddresses.Fields().ByName("chainName")
-	fd_MsgRegisterBridgeAddresses_addresses = md_MsgRegisterBridgeAddresses.Fields().ByName("addresses")
+	md_MsgApproveBridgeTokenForTrading = File_inference_inference_tx_proto.Messages().ByName("MsgApproveBridgeTokenForTrading")
+	fd_MsgApproveBridgeTokenForTrading_authority = md_MsgApproveBridgeTokenForTrading.Fields().ByName("authority")
+	fd_MsgApproveBridgeTokenForTrading_chainId = md_MsgApproveBridgeTokenForTrading.Fields().ByName("chainId")
+	fd_MsgApproveBridgeTokenForTrading_contractAddress = md_MsgApproveBridgeTokenForTrading.Fields().ByName("contractAddress")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterBridgeAddresses)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgApproveBridgeTokenForTrading)(nil)
 
-type fastReflection_MsgRegisterBridgeAddresses MsgRegisterBridgeAddresses
+type fastReflection_MsgApproveBridgeTokenForTrading MsgApproveBridgeTokenForTrading
 
-func (x *MsgRegisterBridgeAddresses) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterBridgeAddresses)(x)
+func (x *MsgApproveBridgeTokenForTrading) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgApproveBridgeTokenForTrading)(x)
 }
 
-func (x *MsgRegisterBridgeAddresses) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[44]
+func (x *MsgApproveBridgeTokenForTrading) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[50]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -24155,43 +27121,43 @@ func (x *MsgRegisterBridgeAddresses) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterBridgeAddresses_messageType fastReflection_MsgRegisterBridgeAddresses_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterBridgeAddresses_messageType{}
+var _fastReflection_MsgApproveBridgeTokenForTrading_messageType fastReflection_MsgApproveBridgeTokenForTrading_messageType
+var _ protoreflect.MessageType = fastReflection_MsgApproveBridgeTokenForTrading_messageType{}
 
-type fastReflection_MsgRegisterBridgeAddresses_messageType struct{}
+type fastReflection_MsgApproveBridgeTokenForTrading_messageType struct{}
 
-func (x fastReflection_MsgRegisterBridgeAddresses_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterBridgeAddresses)(nil)
+func (x fastReflection_MsgApproveBridgeTokenForTrading_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgApproveBridgeTokenForTrading)(nil)
 }
-func (x fastReflection_MsgRegisterBridgeAddresses_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterBridgeAddresses)
+func (x fastReflection_MsgApproveBridgeTokenForTrading_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveBridgeTokenForTrading)
 }
-func (x fastReflection_MsgRegisterBridgeAddresses_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterBridgeAddresses
+func (x fastReflection_MsgApproveBridgeTokenForTrading_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveBridgeTokenForTrading
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterBridgeAddresses
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveBridgeTokenForTrading
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterBridgeAddresses_messageType
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Type() protoreflect.MessageType {
+	return _fastReflection_MsgApproveBridgeTokenForTrading_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterBridgeAddresses) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterBridgeAddresses)
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveBridgeTokenForTrading)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterBridgeAddresses)(x)
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Interface() protoreflect.ProtoMessage {
+	return (*MsgApproveBridgeTokenForTrading)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -24199,22 +27165,22 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) Interface() protoreflect.Pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRegisterBridgeAddresses_authority, value) {
+		if !f(fd_MsgApproveBridgeTokenForTrading_authority, value) {
 			return
 		}
 	}
-	if x.ChainName != "" {
-		value := protoreflect.ValueOfString(x.ChainName)
-		if !f(fd_MsgRegisterBridgeAddresses_chainName, value) {
+	if x.ChainId != "" {
+		value := protoreflect.ValueOfString(x.ChainId)
+		if !f(fd_MsgApproveBridgeTokenForTrading_chainId, value) {
 			return
 		}
 	}
-	if len(x.Addresses) != 0 {
-		value := protoreflect.ValueOfList(&_MsgRegisterBridgeAddresses_3_list{list: &x.Addresses})
-		if !f(fd_MsgRegisterBridgeAddresses_addresses, value) {
+	if x.ContractAddress != "" {
+		value := protoreflect.ValueOfString(x.ContractAddress)
+		if !f(fd_MsgApproveBridgeTokenForTrading_contractAddress, value) {
 			return
 		}
 	}
@@ -24231,19 +27197,19 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) Range(f func(protoreflect.Fi
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterBridgeAddresses.authority":
+	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
-		return x.ChainName != ""
-	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
-		return len(x.Addresses) != 0
+	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+		return x.ChainId != ""
+	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
+		return x.ContractAddress != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24253,19 +27219,19 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) Has(fd protoreflect.FieldDes
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterBridgeAddresses.authority":
+	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
 		x.Authority = ""
-	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
-		x.ChainName = ""
-	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
-		x.Addresses = nil
+	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+		x.ChainId = ""
+	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
+		x.ContractAddress = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24275,25 +27241,22 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) Clear(fd protoreflect.FieldD
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRegisterBridgeAddresses.authority":
+	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
-		value := x.ChainName
+	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+		value := x.ChainId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
+		value := x.ContractAddress
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
-		if len(x.Addresses) == 0 {
-			return protoreflect.ValueOfList(&_MsgRegisterBridgeAddresses_3_list{})
-		}
-		listValue := &_MsgRegisterBridgeAddresses_3_list{list: &x.Addresses}
-		return protoreflect.ValueOfList(listValue)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -24307,21 +27270,19 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) Get(descriptor protoreflect.
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterBridgeAddresses.authority":
+	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
-		x.ChainName = value.Interface().(string)
-	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
-		lv := value.List()
-		clv := lv.(*_MsgRegisterBridgeAddresses_3_list)
-		x.Addresses = *clv.list
+	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+		x.ChainId = value.Interface().(string)
+	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
+		x.ContractAddress = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24335,53 +27296,48 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) Set(fd protoreflect.FieldDes
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddresses) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
-		if x.Addresses == nil {
-			x.Addresses = []string{}
-		}
-		value := &_MsgRegisterBridgeAddresses_3_list{list: &x.Addresses}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgRegisterBridgeAddresses.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterBridgeAddresses is not mutable"))
-	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
-		panic(fmt.Errorf("field chainName of message inference.inference.MsgRegisterBridgeAddresses is not mutable"))
+	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgApproveBridgeTokenForTrading is not mutable"))
+	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+		panic(fmt.Errorf("field chainId of message inference.inference.MsgApproveBridgeTokenForTrading is not mutable"))
+	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
+		panic(fmt.Errorf("field contractAddress of message inference.inference.MsgApproveBridgeTokenForTrading is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterBridgeAddresses) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterBridgeAddresses.authority":
+	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterBridgeAddresses.chainName":
+	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterBridgeAddresses.addresses":
-		list := []string{}
-		return protoreflect.ValueOfList(&_MsgRegisterBridgeAddresses_3_list{list: &list})
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddresses"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddresses does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterBridgeAddresses) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterBridgeAddresses", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveBridgeTokenForTrading", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -24389,7 +27345,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) WhichOneof(d protoreflect.On
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterBridgeAddresses) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -24400,7 +27356,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) GetUnknown() protoreflect.Ra
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddresses) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -24412,7 +27368,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) SetUnknown(fields protorefle
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterBridgeAddresses) IsValid() bool {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) IsValid() bool {
 	return x != nil
 }
 
@@ -24422,9 +27378,9 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterBridgeAddresses)
+		x := input.Message.Interface().(*MsgApproveBridgeTokenForTrading)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24440,15 +27396,13 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ChainName)
+		l = len(x.ChainId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if len(x.Addresses) > 0 {
-			for _, s := range x.Addresses {
-				l = len(s)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		l = len(x.ContractAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -24460,7 +27414,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterBridgeAddresses)
+		x := input.Message.Interface().(*MsgApproveBridgeTokenForTrading)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24479,19 +27433,17 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Addresses) > 0 {
-			for iNdEx := len(x.Addresses) - 1; iNdEx >= 0; iNdEx-- {
-				i -= len(x.Addresses[iNdEx])
-				copy(dAtA[i:], x.Addresses[iNdEx])
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Addresses[iNdEx])))
-				i--
-				dAtA[i] = 0x1a
-			}
+		if len(x.ContractAddress) > 0 {
+			i -= len(x.ContractAddress)
+			copy(dAtA[i:], x.ContractAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+			i--
+			dAtA[i] = 0x1a
 		}
-		if len(x.ChainName) > 0 {
-			i -= len(x.ChainName)
-			copy(dAtA[i:], x.ChainName)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainName)))
+		if len(x.ChainId) > 0 {
+			i -= len(x.ChainId)
+			copy(dAtA[i:], x.ChainId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
 			i--
 			dAtA[i] = 0x12
 		}
@@ -24513,7 +27465,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterBridgeAddresses)
+		x := input.Message.Interface().(*MsgApproveBridgeTokenForTrading)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24545,10 +27497,10 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddresses: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTrading: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddresses: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTrading: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -24585,7 +27537,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainName", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -24613,11 +27565,11 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ChainName = string(dAtA[iNdEx:postIndex])
+				x.ChainId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -24645,7 +27597,7 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Addresses = append(x.Addresses, string(dAtA[iNdEx:postIndex]))
+				x.ContractAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -24683,24 +27635,24 @@ func (x *fastReflection_MsgRegisterBridgeAddresses) ProtoMethods() *protoiface.M
 }
 
 var (
-	md_MsgRegisterBridgeAddressesResponse protoreflect.MessageDescriptor
+	md_MsgApproveBridgeTokenForTradingResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterBridgeAddressesResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterBridgeAddressesResponse")
+	md_MsgApproveBridgeTokenForTradingResponse = File_inference_inference_tx_proto.Messages().ByName("MsgApproveBridgeTokenForTradingResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterBridgeAddressesResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgApproveBridgeTokenForTradingResponse)(nil)
 
-type fastReflection_MsgRegisterBridgeAddressesResponse MsgRegisterBridgeAddressesResponse
+type fastReflection_MsgApproveBridgeTokenForTradingResponse MsgApproveBridgeTokenForTradingResponse
 
-func (x *MsgRegisterBridgeAddressesResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterBridgeAddressesResponse)(x)
+func (x *MsgApproveBridgeTokenForTradingResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgApproveBridgeTokenForTradingResponse)(x)
 }
-
-func (x *MsgRegisterBridgeAddressesResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[45]
+
+func (x *MsgApproveBridgeTokenForTradingResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[51]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -24711,43 +27663,43 @@ func (x *MsgRegisterBridgeAddressesResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterBridgeAddressesResponse_messageType fastReflection_MsgRegisterBridgeAddressesResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterBridgeAddressesResponse_messageType{}
+var _fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType{}
 
-type fastReflection_MsgRegisterBridgeAddressesResponse_messageType struct{}
+type fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType struct{}
 
-func (x fastReflection_MsgRegisterBridgeAddressesResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterBridgeAddressesResponse)(nil)
+func (x fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgApproveBridgeTokenForTradingResponse)(nil)
 }
-func (x fastReflection_MsgRegisterBridgeAddressesResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterBridgeAddressesResponse)
+func (x fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveBridgeTokenForTradingResponse)
 }
-func (x fastReflection_MsgRegisterBridgeAddressesResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterBridgeAddressesResponse
+func (x fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveBridgeTokenForTradingResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterBridgeAddressesResponse
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveBridgeTokenForTradingResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterBridgeAddressesResponse_messageType
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterBridgeAddressesResponse)
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveBridgeTokenForTradingResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterBridgeAddressesResponse)(x)
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgApproveBridgeTokenForTradingResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -24755,7 +27707,7 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -24769,13 +27721,13 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24785,13 +27737,13 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24801,13 +27753,13 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -24821,13 +27773,13 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -24841,36 +27793,36 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterBridgeAddressesResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterBridgeAddressesResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterBridgeAddressesResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveBridgeTokenForTradingResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -24878,7 +27830,7 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -24889,7 +27841,7 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -24901,7 +27853,7 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) IsValid() bool {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -24911,9 +27863,9 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterBridgeAddressesResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterBridgeAddressesResponse)
+		x := input.Message.Interface().(*MsgApproveBridgeTokenForTradingResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24935,7 +27887,7 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterBridgeAddressesResponse)
+		x := input.Message.Interface().(*MsgApproveBridgeTokenForTradingResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24965,7 +27917,7 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterBridgeAddressesResponse)
+		x := input.Message.Interface().(*MsgApproveBridgeTokenForTradingResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -24997,10 +27949,10 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddressesResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTradingResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterBridgeAddressesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTradingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -25039,38 +27991,32 @@ func (x *fastReflection_MsgRegisterBridgeAddressesResponse) ProtoMethods() *prot
 }
 
 var (
-	md_MsgRegisterTokenMetadata                 protoreflect.MessageDescriptor
-	fd_MsgRegisterTokenMetadata_authority       protoreflect.FieldDescriptor
-	fd_MsgRegisterTokenMetadata_chainId         protoreflect.FieldDescriptor
-	fd_MsgRegisterTokenMetadata_contractAddress protoreflect.FieldDescriptor
-	fd_MsgRegisterTokenMetadata_name            protoreflect.FieldDescriptor
-	fd_MsgRegisterTokenMetadata_symbol          protoreflect.FieldDescriptor
-	fd_MsgRegisterTokenMetadata_decimals        protoreflect.FieldDescriptor
-	fd_MsgRegisterTokenMetadata_overwrite       protoreflect.FieldDescriptor
+	md_MsgRegisterLiquidityPool                 protoreflect.MessageDescriptor
+	fd_MsgRegisterLiquidityPool_authority       protoreflect.FieldDescriptor
+	fd_MsgRegisterLiquidityPool_code_id         protoreflect.FieldDescriptor
+	fd_MsgRegisterLiquidityPool_label           protoreflect.FieldDescriptor
+	fd_MsgRegisterLiquidityPool_instantiate_msg protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterTokenMetadata = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterTokenMetadata")
-	fd_MsgRegisterTokenMetadata_authority = md_MsgRegisterTokenMetadata.Fields().ByName("authority")
-	fd_MsgRegisterTokenMetadata_chainId = md_MsgRegisterTokenMetadata.Fields().ByName("chainId")
-	fd_MsgRegisterTokenMetadata_contractAddress = md_MsgRegisterTokenMetadata.Fields().ByName("contractAddress")
-	fd_MsgRegisterTokenMetadata_name = md_MsgRegisterTokenMetadata.Fields().ByName("name")
-	fd_MsgRegisterTokenMetadata_symbol = md_MsgRegisterTokenMetadata.Fields().ByName("symbol")
-	fd_MsgRegisterTokenMetadata_decimals = md_MsgRegisterTokenMetadata.Fields().ByName("decimals")
-	fd_MsgRegisterTokenMetadata_overwrite = md_MsgRegisterTokenMetadata.Fields().ByName("overwrite")
+	md_MsgRegisterLiquidityPool = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterLiquidityPool")
+	fd_MsgRegisterLiquidityPool_authority = md_MsgRegisterLiquidityPool.Fields().ByName("authority")
+	fd_MsgRegisterLiquidityPool_code_id = md_MsgRegisterLiquidityPool.Fields().ByName("code_id")
+	fd_MsgRegisterLiquidityPool_label = md_MsgRegisterLiquidityPool.Fields().ByName("label")
+	fd_MsgRegisterLiquidityPool_instantiate_msg = md_MsgRegisterLiquidityPool.Fields().ByName("instantiate_msg")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterTokenMetadata)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterLiquidityPool)(nil)
 
-type fastReflection_MsgRegisterTokenMetadata MsgRegisterTokenMetadata
+type fastReflection_MsgRegisterLiquidityPool MsgRegisterLiquidityPool
 
-func (x *MsgRegisterTokenMetadata) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterTokenMetadata)(x)
+func (x *MsgRegisterLiquidityPool) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterLiquidityPool)(x)
 }
 
-func (x *MsgRegisterTokenMetadata) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[46]
+func (x *MsgRegisterLiquidityPool) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[52]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -25081,43 +28027,43 @@ func (x *MsgRegisterTokenMetadata) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterTokenMetadata_messageType fastReflection_MsgRegisterTokenMetadata_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterTokenMetadata_messageType{}
+var _fastReflection_MsgRegisterLiquidityPool_messageType fastReflection_MsgRegisterLiquidityPool_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterLiquidityPool_messageType{}
 
-type fastReflection_MsgRegisterTokenMetadata_messageType struct{}
+type fastReflection_MsgRegisterLiquidityPool_messageType struct{}
 
-func (x fastReflection_MsgRegisterTokenMetadata_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterTokenMetadata)(nil)
+func (x fastReflection_MsgRegisterLiquidityPool_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterLiquidityPool)(nil)
 }
-func (x fastReflection_MsgRegisterTokenMetadata_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterTokenMetadata)
+func (x fastReflection_MsgRegisterLiquidityPool_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterLiquidityPool)
 }
-func (x fastReflection_MsgRegisterTokenMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterTokenMetadata
+func (x fastReflection_MsgRegisterLiquidityPool_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterLiquidityPool
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterTokenMetadata) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterTokenMetadata
+func (x *fastReflection_MsgRegisterLiquidityPool) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterLiquidityPool
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterTokenMetadata) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterTokenMetadata_messageType
+func (x *fastReflection_MsgRegisterLiquidityPool) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterLiquidityPool_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterTokenMetadata) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterTokenMetadata)
+func (x *fastReflection_MsgRegisterLiquidityPool) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterLiquidityPool)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterTokenMetadata) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterTokenMetadata)(x)
+func (x *fastReflection_MsgRegisterLiquidityPool) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterLiquidityPool)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -25125,46 +28071,28 @@ func (x *fastReflection_MsgRegisterTokenMetadata) Interface() protoreflect.Proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterTokenMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterLiquidityPool) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRegisterTokenMetadata_authority, value) {
-			return
-		}
-	}
-	if x.ChainId != "" {
-		value := protoreflect.ValueOfString(x.ChainId)
-		if !f(fd_MsgRegisterTokenMetadata_chainId, value) {
-			return
-		}
-	}
-	if x.ContractAddress != "" {
-		value := protoreflect.ValueOfString(x.ContractAddress)
-		if !f(fd_MsgRegisterTokenMetadata_contractAddress, value) {
-			return
-		}
-	}
-	if x.Name != "" {
-		value := protoreflect.ValueOfString(x.Name)
-		if !f(fd_MsgRegisterTokenMetadata_name, value) {
+		if !f(fd_MsgRegisterLiquidityPool_authority, value) {
 			return
 		}
 	}
-	if x.Symbol != "" {
-		value := protoreflect.ValueOfString(x.Symbol)
-		if !f(fd_MsgRegisterTokenMetadata_symbol, value) {
+	if x.CodeId != "" {
+		value := protoreflect.ValueOfString(x.CodeId)
+		if !f(fd_MsgRegisterLiquidityPool_code_id, value) {
 			return
 		}
 	}
-	if x.Decimals != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Decimals)
-		if !f(fd_MsgRegisterTokenMetadata_decimals, value) {
+	if x.Label != "" {
+		value := protoreflect.ValueOfString(x.Label)
+		if !f(fd_MsgRegisterLiquidityPool_label, value) {
 			return
 		}
 	}
-	if x.Overwrite != false {
-		value := protoreflect.ValueOfBool(x.Overwrite)
-		if !f(fd_MsgRegisterTokenMetadata_overwrite, value) {
+	if x.InstantiateMsg != "" {
+		value := protoreflect.ValueOfString(x.InstantiateMsg)
+		if !f(fd_MsgRegisterLiquidityPool_instantiate_msg, value) {
 			return
 		}
 	}
@@ -25181,27 +28109,21 @@ func (x *fastReflection_MsgRegisterTokenMetadata) Range(f func(protoreflect.Fiel
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterTokenMetadata) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterLiquidityPool) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterTokenMetadata.authority":
+	case "inference.inference.MsgRegisterLiquidityPool.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgRegisterTokenMetadata.chainId":
-		return x.ChainId != ""
-	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
-		return x.ContractAddress != ""
-	case "inference.inference.MsgRegisterTokenMetadata.name":
-		return x.Name != ""
-	case "inference.inference.MsgRegisterTokenMetadata.symbol":
-		return x.Symbol != ""
-	case "inference.inference.MsgRegisterTokenMetadata.decimals":
-		return x.Decimals != uint32(0)
-	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
-		return x.Overwrite != false
+	case "inference.inference.MsgRegisterLiquidityPool.code_id":
+		return x.CodeId != ""
+	case "inference.inference.MsgRegisterLiquidityPool.label":
+		return x.Label != ""
+	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
+		return x.InstantiateMsg != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25211,27 +28133,21 @@ func (x *fastReflection_MsgRegisterTokenMetadata) Has(fd protoreflect.FieldDescr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadata) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterLiquidityPool) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterTokenMetadata.authority":
+	case "inference.inference.MsgRegisterLiquidityPool.authority":
 		x.Authority = ""
-	case "inference.inference.MsgRegisterTokenMetadata.chainId":
-		x.ChainId = ""
-	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
-		x.ContractAddress = ""
-	case "inference.inference.MsgRegisterTokenMetadata.name":
-		x.Name = ""
-	case "inference.inference.MsgRegisterTokenMetadata.symbol":
-		x.Symbol = ""
-	case "inference.inference.MsgRegisterTokenMetadata.decimals":
-		x.Decimals = uint32(0)
-	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
-		x.Overwrite = false
+	case "inference.inference.MsgRegisterLiquidityPool.code_id":
+		x.CodeId = ""
+	case "inference.inference.MsgRegisterLiquidityPool.label":
+		x.Label = ""
+	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
+		x.InstantiateMsg = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25241,34 +28157,25 @@ func (x *fastReflection_MsgRegisterTokenMetadata) Clear(fd protoreflect.FieldDes
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterTokenMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterLiquidityPool) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRegisterTokenMetadata.authority":
+	case "inference.inference.MsgRegisterLiquidityPool.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterTokenMetadata.chainId":
-		value := x.ChainId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
-		value := x.ContractAddress
+	case "inference.inference.MsgRegisterLiquidityPool.code_id":
+		value := x.CodeId
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterTokenMetadata.name":
-		value := x.Name
+	case "inference.inference.MsgRegisterLiquidityPool.label":
+		value := x.Label
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterTokenMetadata.symbol":
-		value := x.Symbol
+	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
+		value := x.InstantiateMsg
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterTokenMetadata.decimals":
-		value := x.Decimals
-		return protoreflect.ValueOfUint32(value)
-	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
-		value := x.Overwrite
-		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -25282,27 +28189,21 @@ func (x *fastReflection_MsgRegisterTokenMetadata) Get(descriptor protoreflect.Fi
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterLiquidityPool) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterTokenMetadata.authority":
+	case "inference.inference.MsgRegisterLiquidityPool.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRegisterTokenMetadata.chainId":
-		x.ChainId = value.Interface().(string)
-	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
-		x.ContractAddress = value.Interface().(string)
-	case "inference.inference.MsgRegisterTokenMetadata.name":
-		x.Name = value.Interface().(string)
-	case "inference.inference.MsgRegisterTokenMetadata.symbol":
-		x.Symbol = value.Interface().(string)
-	case "inference.inference.MsgRegisterTokenMetadata.decimals":
-		x.Decimals = uint32(value.Uint())
-	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
-		x.Overwrite = value.Bool()
+	case "inference.inference.MsgRegisterLiquidityPool.code_id":
+		x.CodeId = value.Interface().(string)
+	case "inference.inference.MsgRegisterLiquidityPool.label":
+		x.Label = value.Interface().(string)
+	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
+		x.InstantiateMsg = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25316,64 +28217,52 @@ func (x *fastReflection_MsgRegisterTokenMetadata) Set(fd protoreflect.FieldDescr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterLiquidityPool) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterTokenMetadata.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterTokenMetadata.chainId":
-		panic(fmt.Errorf("field chainId of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
-		panic(fmt.Errorf("field contractAddress of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterTokenMetadata.name":
-		panic(fmt.Errorf("field name of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterTokenMetadata.symbol":
-		panic(fmt.Errorf("field symbol of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterTokenMetadata.decimals":
-		panic(fmt.Errorf("field decimals of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
-		panic(fmt.Errorf("field overwrite of message inference.inference.MsgRegisterTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterLiquidityPool.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
+	case "inference.inference.MsgRegisterLiquidityPool.code_id":
+		panic(fmt.Errorf("field code_id of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
+	case "inference.inference.MsgRegisterLiquidityPool.label":
+		panic(fmt.Errorf("field label of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
+	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
+		panic(fmt.Errorf("field instantiate_msg of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterTokenMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterLiquidityPool) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterTokenMetadata.authority":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterTokenMetadata.chainId":
+	case "inference.inference.MsgRegisterLiquidityPool.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterTokenMetadata.contractAddress":
+	case "inference.inference.MsgRegisterLiquidityPool.code_id":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterTokenMetadata.name":
+	case "inference.inference.MsgRegisterLiquidityPool.label":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterTokenMetadata.symbol":
+	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterTokenMetadata.decimals":
-		return protoreflect.ValueOfUint32(uint32(0))
-	case "inference.inference.MsgRegisterTokenMetadata.overwrite":
-		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterTokenMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterLiquidityPool) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterTokenMetadata", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterLiquidityPool", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -25381,7 +28270,7 @@ func (x *fastReflection_MsgRegisterTokenMetadata) WhichOneof(d protoreflect.Oneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterTokenMetadata) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterLiquidityPool) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -25392,7 +28281,7 @@ func (x *fastReflection_MsgRegisterTokenMetadata) GetUnknown() protoreflect.RawF
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadata) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterLiquidityPool) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -25404,7 +28293,7 @@ func (x *fastReflection_MsgRegisterTokenMetadata) SetUnknown(fields protoreflect
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterTokenMetadata) IsValid() bool {
+func (x *fastReflection_MsgRegisterLiquidityPool) IsValid() bool {
 	return x != nil
 }
 
@@ -25414,9 +28303,9 @@ func (x *fastReflection_MsgRegisterTokenMetadata) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterTokenMetadata)
+		x := input.Message.Interface().(*MsgRegisterLiquidityPool)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25432,28 +28321,18 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ChainId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.ContractAddress)
+		l = len(x.CodeId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Name)
+		l = len(x.Label)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Symbol)
+		l = len(x.InstantiateMsg)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Decimals != 0 {
-			n += 1 + runtime.Sov(uint64(x.Decimals))
-		}
-		if x.Overwrite {
-			n += 2
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -25464,7 +28343,7 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterTokenMetadata)
+		x := input.Message.Interface().(*MsgRegisterLiquidityPool)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25483,46 +28362,24 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Overwrite {
-			i--
-			if x.Overwrite {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
-			}
-			i--
-			dAtA[i] = 0x38
-		}
-		if x.Decimals != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
-			i--
-			dAtA[i] = 0x30
-		}
-		if len(x.Symbol) > 0 {
-			i -= len(x.Symbol)
-			copy(dAtA[i:], x.Symbol)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Symbol)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.Name) > 0 {
-			i -= len(x.Name)
-			copy(dAtA[i:], x.Name)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
+		if len(x.InstantiateMsg) > 0 {
+			i -= len(x.InstantiateMsg)
+			copy(dAtA[i:], x.InstantiateMsg)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InstantiateMsg)))
 			i--
 			dAtA[i] = 0x22
 		}
-		if len(x.ContractAddress) > 0 {
-			i -= len(x.ContractAddress)
-			copy(dAtA[i:], x.ContractAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+		if len(x.Label) > 0 {
+			i -= len(x.Label)
+			copy(dAtA[i:], x.Label)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Label)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.ChainId) > 0 {
-			i -= len(x.ChainId)
-			copy(dAtA[i:], x.ChainId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+		if len(x.CodeId) > 0 {
+			i -= len(x.CodeId)
+			copy(dAtA[i:], x.CodeId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CodeId)))
 			i--
 			dAtA[i] = 0x12
 		}
@@ -25544,7 +28401,7 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterTokenMetadata)
+		x := input.Message.Interface().(*MsgRegisterLiquidityPool)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -25576,10 +28433,10 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadata: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPool: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPool: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -25612,75 +28469,11 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ChainId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ContractAddress = string(dAtA[iNdEx:postIndex])
+				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 4:
+			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -25708,11 +28501,11 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Name = string(dAtA[iNdEx:postIndex])
+				x.CodeId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 5:
+			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -25740,13 +28533,13 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Symbol = string(dAtA[iNdEx:postIndex])
+				x.Label = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 6:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InstantiateMsg", wireType)
 				}
-				x.Decimals = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -25756,31 +28549,24 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Decimals |= uint32(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 7:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Overwrite", wireType)
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				var v int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				x.Overwrite = bool(v != 0)
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.InstantiateMsg = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -25817,24 +28603,24 @@ func (x *fastReflection_MsgRegisterTokenMetadata) ProtoMethods() *protoiface.Met
 }
 
 var (
-	md_MsgRegisterTokenMetadataResponse protoreflect.MessageDescriptor
+	md_MsgRegisterLiquidityPoolResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterTokenMetadataResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterTokenMetadataResponse")
+	md_MsgRegisterLiquidityPoolResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterLiquidityPoolResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterTokenMetadataResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterLiquidityPoolResponse)(nil)
 
-type fastReflection_MsgRegisterTokenMetadataResponse MsgRegisterTokenMetadataResponse
+type fastReflection_MsgRegisterLiquidityPoolResponse MsgRegisterLiquidityPoolResponse
 
-func (x *MsgRegisterTokenMetadataResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterTokenMetadataResponse)(x)
+func (x *MsgRegisterLiquidityPoolResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterLiquidityPoolResponse)(x)
 }
 
-func (x *MsgRegisterTokenMetadataResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[47]
+func (x *MsgRegisterLiquidityPoolResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[53]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -25845,43 +28631,43 @@ func (x *MsgRegisterTokenMetadataResponse) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterTokenMetadataResponse_messageType fastReflection_MsgRegisterTokenMetadataResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterTokenMetadataResponse_messageType{}
+var _fastReflection_MsgRegisterLiquidityPoolResponse_messageType fastReflection_MsgRegisterLiquidityPoolResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterLiquidityPoolResponse_messageType{}
 
-type fastReflection_MsgRegisterTokenMetadataResponse_messageType struct{}
+type fastReflection_MsgRegisterLiquidityPoolResponse_messageType struct{}
 
-func (x fastReflection_MsgRegisterTokenMetadataResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterTokenMetadataResponse)(nil)
+func (x fastReflection_MsgRegisterLiquidityPoolResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterLiquidityPoolResponse)(nil)
 }
-func (x fastReflection_MsgRegisterTokenMetadataResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterTokenMetadataResponse)
+func (x fastReflection_MsgRegisterLiquidityPoolResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterLiquidityPoolResponse)
 }
-func (x fastReflection_MsgRegisterTokenMetadataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterTokenMetadataResponse
+func (x fastReflection_MsgRegisterLiquidityPoolResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterLiquidityPoolResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterTokenMetadataResponse
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterLiquidityPoolResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterTokenMetadataResponse_messageType
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterLiquidityPoolResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterTokenMetadataResponse)
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterLiquidityPoolResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterTokenMetadataResponse)(x)
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterLiquidityPoolResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -25889,7 +28675,7 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -25903,13 +28689,13 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25919,13 +28705,13 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25935,13 +28721,13 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -25955,13 +28741,13 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -25975,36 +28761,36 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterTokenMetadataResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterLiquidityPoolResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -26012,7 +28798,7 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -26023,7 +28809,7 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -26035,7 +28821,7 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) IsValid() bool {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -26045,9 +28831,9 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterTokenMetadataResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterTokenMetadataResponse)
+		x := input.Message.Interface().(*MsgRegisterLiquidityPoolResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26069,7 +28855,7 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterTokenMetadataResponse)
+		x := input.Message.Interface().(*MsgRegisterLiquidityPoolResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26099,7 +28885,7 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterTokenMetadataResponse)
+		x := input.Message.Interface().(*MsgRegisterLiquidityPoolResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26131,10 +28917,10 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadataResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPoolResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterTokenMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -26173,30 +28959,34 @@ func (x *fastReflection_MsgRegisterTokenMetadataResponse) ProtoMethods() *protoi
 }
 
 var (
-	md_MsgApproveBridgeTokenForTrading                 protoreflect.MessageDescriptor
-	fd_MsgApproveBridgeTokenForTrading_authority       protoreflect.FieldDescriptor
-	fd_MsgApproveBridgeTokenForTrading_chainId         protoreflect.FieldDescriptor
-	fd_MsgApproveBridgeTokenForTrading_contractAddress protoreflect.FieldDescriptor
+	md_MsgRequestBridgeWithdrawal                            protoreflect.MessageDescriptor
+	fd_MsgRequestBridgeWithdrawal_creator                    protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeWithdrawal_user_address               protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeWithdrawal_amount                     protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeWithdrawal_destination_address        protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeWithdrawal_destination_bridge_address protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgApproveBridgeTokenForTrading = File_inference_inference_tx_proto.Messages().ByName("MsgApproveBridgeTokenForTrading")
-	fd_MsgApproveBridgeTokenForTrading_authority = md_MsgApproveBridgeTokenForTrading.Fields().ByName("authority")
-	fd_MsgApproveBridgeTokenForTrading_chainId = md_MsgApproveBridgeTokenForTrading.Fields().ByName("chainId")
-	fd_MsgApproveBridgeTokenForTrading_contractAddress = md_MsgApproveBridgeTokenForTrading.Fields().ByName("contractAddress")
+	md_MsgRequestBridgeWithdrawal = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeWithdrawal")
+	fd_MsgRequestBridgeWithdrawal_creator = md_MsgRequestBridgeWithdrawal.Fields().ByName("creator")
+	fd_MsgRequestBridgeWithdrawal_user_address = md_MsgRequestBridgeWithdrawal.Fields().ByName("user_address")
+	fd_MsgRequestBridgeWithdrawal_amount = md_MsgRequestBridgeWithdrawal.Fields().ByName("amount")
+	fd_MsgRequestBridgeWithdrawal_destination_address = md_MsgRequestBridgeWithdrawal.Fields().ByName("destination_address")
+	fd_MsgRequestBridgeWithdrawal_destination_bridge_address = md_MsgRequestBridgeWithdrawal.Fields().ByName("destination_bridge_address")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgApproveBridgeTokenForTrading)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeWithdrawal)(nil)
 
-type fastReflection_MsgApproveBridgeTokenForTrading MsgApproveBridgeTokenForTrading
+type fastReflection_MsgRequestBridgeWithdrawal MsgRequestBridgeWithdrawal
 
-func (x *MsgApproveBridgeTokenForTrading) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgApproveBridgeTokenForTrading)(x)
+func (x *MsgRequestBridgeWithdrawal) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeWithdrawal)(x)
 }
 
-func (x *MsgApproveBridgeTokenForTrading) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[48]
+func (x *MsgRequestBridgeWithdrawal) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[54]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -26207,43 +28997,43 @@ func (x *MsgApproveBridgeTokenForTrading) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgApproveBridgeTokenForTrading_messageType fastReflection_MsgApproveBridgeTokenForTrading_messageType
-var _ protoreflect.MessageType = fastReflection_MsgApproveBridgeTokenForTrading_messageType{}
+var _fastReflection_MsgRequestBridgeWithdrawal_messageType fastReflection_MsgRequestBridgeWithdrawal_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeWithdrawal_messageType{}
 
-type fastReflection_MsgApproveBridgeTokenForTrading_messageType struct{}
+type fastReflection_MsgRequestBridgeWithdrawal_messageType struct{}
 
-func (x fastReflection_MsgApproveBridgeTokenForTrading_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgApproveBridgeTokenForTrading)(nil)
+func (x fastReflection_MsgRequestBridgeWithdrawal_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeWithdrawal)(nil)
 }
-func (x fastReflection_MsgApproveBridgeTokenForTrading_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveBridgeTokenForTrading)
+func (x fastReflection_MsgRequestBridgeWithdrawal_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeWithdrawal)
 }
-func (x fastReflection_MsgApproveBridgeTokenForTrading_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveBridgeTokenForTrading
+func (x fastReflection_MsgRequestBridgeWithdrawal_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeWithdrawal
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveBridgeTokenForTrading
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeWithdrawal
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Type() protoreflect.MessageType {
-	return _fastReflection_MsgApproveBridgeTokenForTrading_messageType
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRequestBridgeWithdrawal_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveBridgeTokenForTrading)
+func (x *fastReflection_MsgRequestBridgeWithdrawal) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeWithdrawal)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Interface() protoreflect.ProtoMessage {
-	return (*MsgApproveBridgeTokenForTrading)(x)
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Interface() protoreflect.ProtoMessage {
+	return (*MsgRequestBridgeWithdrawal)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -26251,22 +29041,34 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgApproveBridgeTokenForTrading_authority, value) {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgRequestBridgeWithdrawal_creator, value) {
 			return
 		}
 	}
-	if x.ChainId != "" {
-		value := protoreflect.ValueOfString(x.ChainId)
-		if !f(fd_MsgApproveBridgeTokenForTrading_chainId, value) {
+	if x.UserAddress != "" {
+		value := protoreflect.ValueOfString(x.UserAddress)
+		if !f(fd_MsgRequestBridgeWithdrawal_user_address, value) {
 			return
 		}
 	}
-	if x.ContractAddress != "" {
-		value := protoreflect.ValueOfString(x.ContractAddress)
-		if !f(fd_MsgApproveBridgeTokenForTrading_contractAddress, value) {
+	if x.Amount != "" {
+		value := protoreflect.ValueOfString(x.Amount)
+		if !f(fd_MsgRequestBridgeWithdrawal_amount, value) {
+			return
+		}
+	}
+	if x.DestinationAddress != "" {
+		value := protoreflect.ValueOfString(x.DestinationAddress)
+		if !f(fd_MsgRequestBridgeWithdrawal_destination_address, value) {
+			return
+		}
+	}
+	if x.DestinationBridgeAddress != "" {
+		value := protoreflect.ValueOfString(x.DestinationBridgeAddress)
+		if !f(fd_MsgRequestBridgeWithdrawal_destination_bridge_address, value) {
 			return
 		}
 	}
@@ -26283,19 +29085,23 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
-		return x.ChainId != ""
-	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
-		return x.ContractAddress != ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
+		return x.UserAddress != ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
+		return x.Amount != ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+		return x.DestinationAddress != ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
+		return x.DestinationBridgeAddress != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26305,19 +29111,23 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
-		x.Authority = ""
-	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
-		x.ChainId = ""
-	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
-		x.ContractAddress = ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+		x.Creator = ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
+		x.UserAddress = ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
+		x.Amount = ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+		x.DestinationAddress = ""
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
+		x.DestinationBridgeAddress = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26327,22 +29137,28 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
-		value := x.Authority
+	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
-		value := x.ChainId
+	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
+		value := x.UserAddress
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
-		value := x.ContractAddress
+	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
+		value := x.Amount
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+		value := x.DestinationAddress
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
+		value := x.DestinationBridgeAddress
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -26356,19 +29172,23 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
-		x.ChainId = value.Interface().(string)
-	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
-		x.ContractAddress = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
+		x.UserAddress = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
+		x.Amount = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+		x.DestinationAddress = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
+		x.DestinationBridgeAddress = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26382,48 +29202,56 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgApproveBridgeTokenForTrading is not mutable"))
-	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
-		panic(fmt.Errorf("field chainId of message inference.inference.MsgApproveBridgeTokenForTrading is not mutable"))
-	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
-		panic(fmt.Errorf("field contractAddress of message inference.inference.MsgApproveBridgeTokenForTrading is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
+		panic(fmt.Errorf("field user_address of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
+		panic(fmt.Errorf("field amount of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+		panic(fmt.Errorf("field destination_address of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
+		panic(fmt.Errorf("field destination_bridge_address of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveBridgeTokenForTrading.authority":
+	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgApproveBridgeTokenForTrading.chainId":
+	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgApproveBridgeTokenForTrading.contractAddress":
+	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveBridgeTokenForTrading", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeWithdrawal", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -26431,7 +29259,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -26442,7 +29270,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -26454,7 +29282,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) IsValid() bool {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) IsValid() bool {
 	return x != nil
 }
 
@@ -26464,9 +29292,9 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgApproveBridgeTokenForTrading)
+		x := input.Message.Interface().(*MsgRequestBridgeWithdrawal)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26478,15 +29306,23 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ChainId)
+		l = len(x.UserAddress)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ContractAddress)
+		l = len(x.Amount)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.DestinationAddress)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.DestinationBridgeAddress)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -26500,7 +29336,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveBridgeTokenForTrading)
+		x := input.Message.Interface().(*MsgRequestBridgeWithdrawal)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26519,24 +29355,38 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ContractAddress) > 0 {
-			i -= len(x.ContractAddress)
-			copy(dAtA[i:], x.ContractAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ContractAddress)))
+		if len(x.DestinationBridgeAddress) > 0 {
+			i -= len(x.DestinationBridgeAddress)
+			copy(dAtA[i:], x.DestinationBridgeAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationBridgeAddress)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.DestinationAddress) > 0 {
+			i -= len(x.DestinationAddress)
+			copy(dAtA[i:], x.DestinationAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationAddress)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.Amount) > 0 {
+			i -= len(x.Amount)
+			copy(dAtA[i:], x.Amount)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Amount)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.ChainId) > 0 {
-			i -= len(x.ChainId)
-			copy(dAtA[i:], x.ChainId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+		if len(x.UserAddress) > 0 {
+			i -= len(x.UserAddress)
+			copy(dAtA[i:], x.UserAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.UserAddress)))
 			i--
 			dAtA[i] = 0x12
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -26551,7 +29401,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveBridgeTokenForTrading)
+		x := input.Message.Interface().(*MsgRequestBridgeWithdrawal)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26583,15 +29433,15 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTrading: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawal: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTrading: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawal: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -26619,11 +29469,11 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UserAddress", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -26651,11 +29501,11 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ChainId = string(dAtA[iNdEx:postIndex])
+				x.UserAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -26683,7 +29533,71 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ContractAddress = string(dAtA[iNdEx:postIndex])
+				x.Amount = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DestinationAddress = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationBridgeAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DestinationBridgeAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -26721,24 +29635,30 @@ func (x *fastReflection_MsgApproveBridgeTokenForTrading) ProtoMethods() *protoif
 }
 
 var (
-	md_MsgApproveBridgeTokenForTradingResponse protoreflect.MessageDescriptor
+	md_MsgRequestBridgeWithdrawalResponse                protoreflect.MessageDescriptor
+	fd_MsgRequestBridgeWithdrawalResponse_request_id     protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeWithdrawalResponse_epoch_index    protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeWithdrawalResponse_bls_request_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgApproveBridgeTokenForTradingResponse = File_inference_inference_tx_proto.Messages().ByName("MsgApproveBridgeTokenForTradingResponse")
+	md_MsgRequestBridgeWithdrawalResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeWithdrawalResponse")
+	fd_MsgRequestBridgeWithdrawalResponse_request_id = md_MsgRequestBridgeWithdrawalResponse.Fields().ByName("request_id")
+	fd_MsgRequestBridgeWithdrawalResponse_epoch_index = md_MsgRequestBridgeWithdrawalResponse.Fields().ByName("epoch_index")
+	fd_MsgRequestBridgeWithdrawalResponse_bls_request_id = md_MsgRequestBridgeWithdrawalResponse.Fields().ByName("bls_request_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgApproveBridgeTokenForTradingResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeWithdrawalResponse)(nil)
 
-type fastReflection_MsgApproveBridgeTokenForTradingResponse MsgApproveBridgeTokenForTradingResponse
+type fastReflection_MsgRequestBridgeWithdrawalResponse MsgRequestBridgeWithdrawalResponse
 
-func (x *MsgApproveBridgeTokenForTradingResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgApproveBridgeTokenForTradingResponse)(x)
+func (x *MsgRequestBridgeWithdrawalResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeWithdrawalResponse)(x)
 }
 
-func (x *MsgApproveBridgeTokenForTradingResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[49]
+func (x *MsgRequestBridgeWithdrawalResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[55]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -26749,43 +29669,43 @@ func (x *MsgApproveBridgeTokenForTradingResponse) slowProtoReflect() protoreflec
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType{}
+var _fastReflection_MsgRequestBridgeWithdrawalResponse_messageType fastReflection_MsgRequestBridgeWithdrawalResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeWithdrawalResponse_messageType{}
 
-type fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType struct{}
+type fastReflection_MsgRequestBridgeWithdrawalResponse_messageType struct{}
 
-func (x fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgApproveBridgeTokenForTradingResponse)(nil)
+func (x fastReflection_MsgRequestBridgeWithdrawalResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeWithdrawalResponse)(nil)
 }
-func (x fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveBridgeTokenForTradingResponse)
+func (x fastReflection_MsgRequestBridgeWithdrawalResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeWithdrawalResponse)
 }
-func (x fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveBridgeTokenForTradingResponse
+func (x fastReflection_MsgRequestBridgeWithdrawalResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeWithdrawalResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveBridgeTokenForTradingResponse
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeWithdrawalResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgApproveBridgeTokenForTradingResponse_messageType
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRequestBridgeWithdrawalResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveBridgeTokenForTradingResponse)
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeWithdrawalResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgApproveBridgeTokenForTradingResponse)(x)
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRequestBridgeWithdrawalResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -26793,7 +29713,25 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.RequestId != "" {
+		value := protoreflect.ValueOfString(x.RequestId)
+		if !f(fd_MsgRequestBridgeWithdrawalResponse_request_id, value) {
+			return
+		}
+	}
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_MsgRequestBridgeWithdrawalResponse_epoch_index, value) {
+			return
+		}
+	}
+	if x.BlsRequestId != "" {
+		value := protoreflect.ValueOfString(x.BlsRequestId)
+		if !f(fd_MsgRequestBridgeWithdrawalResponse_bls_request_id, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -26807,13 +29745,19 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
+		return x.RequestId != ""
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
+		return x.EpochIndex != uint64(0)
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
+		return x.BlsRequestId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26823,13 +29767,19 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
+		x.RequestId = ""
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
+		x.EpochIndex = uint64(0)
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
+		x.BlsRequestId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26839,13 +29789,22 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
+		value := x.RequestId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
+		value := x.BlsRequestId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -26859,13 +29818,19 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
+		x.RequestId = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
+		x.EpochIndex = value.Uint()
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
+		x.BlsRequestId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -26879,36 +29844,48 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
+		panic(fmt.Errorf("field request_id of message inference.inference.MsgRequestBridgeWithdrawalResponse is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.MsgRequestBridgeWithdrawalResponse is not mutable"))
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
+		panic(fmt.Errorf("field bls_request_id of message inference.inference.MsgRequestBridgeWithdrawalResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveBridgeTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveBridgeTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveBridgeTokenForTradingResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeWithdrawalResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -26916,7 +29893,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -26927,7 +29904,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -26939,7 +29916,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) IsValid() bool {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -26949,9 +29926,9 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgApproveBridgeTokenForTradingResponse)
+		x := input.Message.Interface().(*MsgRequestBridgeWithdrawalResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26963,6 +29940,17 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods()
 		var n int
 		var l int
 		_ = l
+		l = len(x.RequestId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
+		l = len(x.BlsRequestId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -26973,7 +29961,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveBridgeTokenForTradingResponse)
+		x := input.Message.Interface().(*MsgRequestBridgeWithdrawalResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -26992,6 +29980,25 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods()
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.BlsRequestId) > 0 {
+			i -= len(x.BlsRequestId)
+			copy(dAtA[i:], x.BlsRequestId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlsRequestId)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.RequestId) > 0 {
+			i -= len(x.RequestId)
+			copy(dAtA[i:], x.RequestId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -27003,7 +30010,7 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveBridgeTokenForTradingResponse)
+		x := input.Message.Interface().(*MsgRequestBridgeWithdrawalResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27035,12 +30042,95 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTradingResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawalResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveBridgeTokenForTradingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.RequestId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				}
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlsRequestId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.BlsRequestId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -27077,32 +30167,34 @@ func (x *fastReflection_MsgApproveBridgeTokenForTradingResponse) ProtoMethods()
 }
 
 var (
-	md_MsgRegisterLiquidityPool                 protoreflect.MessageDescriptor
-	fd_MsgRegisterLiquidityPool_authority       protoreflect.FieldDescriptor
-	fd_MsgRegisterLiquidityPool_code_id         protoreflect.FieldDescriptor
-	fd_MsgRegisterLiquidityPool_label           protoreflect.FieldDescriptor
-	fd_MsgRegisterLiquidityPool_instantiate_msg protoreflect.FieldDescriptor
+	md_MsgRequestBridgeMint                            protoreflect.MessageDescriptor
+	fd_MsgRequestBridgeMint_creator                    protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeMint_amount                     protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeMint_destination_address        protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeMint_chain_id                   protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeMint_destination_bridge_address protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterLiquidityPool = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterLiquidityPool")
-	fd_MsgRegisterLiquidityPool_authority = md_MsgRegisterLiquidityPool.Fields().ByName("authority")
-	fd_MsgRegisterLiquidityPool_code_id = md_MsgRegisterLiquidityPool.Fields().ByName("code_id")
-	fd_MsgRegisterLiquidityPool_label = md_MsgRegisterLiquidityPool.Fields().ByName("label")
-	fd_MsgRegisterLiquidityPool_instantiate_msg = md_MsgRegisterLiquidityPool.Fields().ByName("instantiate_msg")
+	md_MsgRequestBridgeMint = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeMint")
+	fd_MsgRequestBridgeMint_creator = md_MsgRequestBridgeMint.Fields().ByName("creator")
+	fd_MsgRequestBridgeMint_amount = md_MsgRequestBridgeMint.Fields().ByName("amount")
+	fd_MsgRequestBridgeMint_destination_address = md_MsgRequestBridgeMint.Fields().ByName("destination_address")
+	fd_MsgRequestBridgeMint_chain_id = md_MsgRequestBridgeMint.Fields().ByName("chain_id")
+	fd_MsgRequestBridgeMint_destination_bridge_address = md_MsgRequestBridgeMint.Fields().ByName("destination_bridge_address")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterLiquidityPool)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeMint)(nil)
 
-type fastReflection_MsgRegisterLiquidityPool MsgRegisterLiquidityPool
+type fastReflection_MsgRequestBridgeMint MsgRequestBridgeMint
 
-func (x *MsgRegisterLiquidityPool) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterLiquidityPool)(x)
+func (x *MsgRequestBridgeMint) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeMint)(x)
 }
 
-func (x *MsgRegisterLiquidityPool) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[50]
+func (x *MsgRequestBridgeMint) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[56]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -27113,43 +30205,43 @@ func (x *MsgRegisterLiquidityPool) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterLiquidityPool_messageType fastReflection_MsgRegisterLiquidityPool_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterLiquidityPool_messageType{}
+var _fastReflection_MsgRequestBridgeMint_messageType fastReflection_MsgRequestBridgeMint_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeMint_messageType{}
 
-type fastReflection_MsgRegisterLiquidityPool_messageType struct{}
+type fastReflection_MsgRequestBridgeMint_messageType struct{}
 
-func (x fastReflection_MsgRegisterLiquidityPool_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterLiquidityPool)(nil)
+func (x fastReflection_MsgRequestBridgeMint_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeMint)(nil)
 }
-func (x fastReflection_MsgRegisterLiquidityPool_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterLiquidityPool)
+func (x fastReflection_MsgRequestBridgeMint_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeMint)
 }
-func (x fastReflection_MsgRegisterLiquidityPool_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterLiquidityPool
+func (x fastReflection_MsgRequestBridgeMint_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeMint
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterLiquidityPool) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterLiquidityPool
+func (x *fastReflection_MsgRequestBridgeMint) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeMint
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterLiquidityPool) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterLiquidityPool_messageType
+func (x *fastReflection_MsgRequestBridgeMint) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRequestBridgeMint_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterLiquidityPool) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterLiquidityPool)
+func (x *fastReflection_MsgRequestBridgeMint) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeMint)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterLiquidityPool) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterLiquidityPool)(x)
+func (x *fastReflection_MsgRequestBridgeMint) Interface() protoreflect.ProtoMessage {
+	return (*MsgRequestBridgeMint)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -27157,28 +30249,34 @@ func (x *fastReflection_MsgRegisterLiquidityPool) Interface() protoreflect.Proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterLiquidityPool) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRegisterLiquidityPool_authority, value) {
+func (x *fastReflection_MsgRequestBridgeMint) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgRequestBridgeMint_creator, value) {
 			return
 		}
 	}
-	if x.CodeId != "" {
-		value := protoreflect.ValueOfString(x.CodeId)
-		if !f(fd_MsgRegisterLiquidityPool_code_id, value) {
+	if x.Amount != "" {
+		value := protoreflect.ValueOfString(x.Amount)
+		if !f(fd_MsgRequestBridgeMint_amount, value) {
 			return
 		}
 	}
-	if x.Label != "" {
-		value := protoreflect.ValueOfString(x.Label)
-		if !f(fd_MsgRegisterLiquidityPool_label, value) {
+	if x.DestinationAddress != "" {
+		value := protoreflect.ValueOfString(x.DestinationAddress)
+		if !f(fd_MsgRequestBridgeMint_destination_address, value) {
 			return
 		}
 	}
-	if x.InstantiateMsg != "" {
-		value := protoreflect.ValueOfString(x.InstantiateMsg)
-		if !f(fd_MsgRegisterLiquidityPool_instantiate_msg, value) {
+	if x.ChainId != "" {
+		value := protoreflect.ValueOfString(x.ChainId)
+		if !f(fd_MsgRequestBridgeMint_chain_id, value) {
+			return
+		}
+	}
+	if x.DestinationBridgeAddress != "" {
+		value := protoreflect.ValueOfString(x.DestinationBridgeAddress)
+		if !f(fd_MsgRequestBridgeMint_destination_bridge_address, value) {
 			return
 		}
 	}
@@ -27190,26 +30288,28 @@ func (x *fastReflection_MsgRegisterLiquidityPool) Range(f func(protoreflect.Fiel
 // distinguish between the default value of a field and whether the field
 // was explicitly populated with the default value. Singular message fields,
 // member fields of a oneof, and proto2 scalar fields are nullable. Such
-// fields are populated only if explicitly set.
-//
-// In other cases (aside from the nullable cases above),
-// a proto3 scalar field is populated if it contains a non-zero value, and
-// a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterLiquidityPool) Has(fd protoreflect.FieldDescriptor) bool {
-	switch fd.FullName() {
-	case "inference.inference.MsgRegisterLiquidityPool.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgRegisterLiquidityPool.code_id":
-		return x.CodeId != ""
-	case "inference.inference.MsgRegisterLiquidityPool.label":
-		return x.Label != ""
-	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
-		return x.InstantiateMsg != ""
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgRequestBridgeMint) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeMint.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgRequestBridgeMint.amount":
+		return x.Amount != ""
+	case "inference.inference.MsgRequestBridgeMint.destination_address":
+		return x.DestinationAddress != ""
+	case "inference.inference.MsgRequestBridgeMint.chain_id":
+		return x.ChainId != ""
+	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
+		return x.DestinationBridgeAddress != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27219,21 +30319,23 @@ func (x *fastReflection_MsgRegisterLiquidityPool) Has(fd protoreflect.FieldDescr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPool) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRequestBridgeMint) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterLiquidityPool.authority":
-		x.Authority = ""
-	case "inference.inference.MsgRegisterLiquidityPool.code_id":
-		x.CodeId = ""
-	case "inference.inference.MsgRegisterLiquidityPool.label":
-		x.Label = ""
-	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
-		x.InstantiateMsg = ""
+	case "inference.inference.MsgRequestBridgeMint.creator":
+		x.Creator = ""
+	case "inference.inference.MsgRequestBridgeMint.amount":
+		x.Amount = ""
+	case "inference.inference.MsgRequestBridgeMint.destination_address":
+		x.DestinationAddress = ""
+	case "inference.inference.MsgRequestBridgeMint.chain_id":
+		x.ChainId = ""
+	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
+		x.DestinationBridgeAddress = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27243,25 +30345,28 @@ func (x *fastReflection_MsgRegisterLiquidityPool) Clear(fd protoreflect.FieldDes
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterLiquidityPool) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeMint) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRegisterLiquidityPool.authority":
-		value := x.Authority
+	case "inference.inference.MsgRequestBridgeMint.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterLiquidityPool.code_id":
-		value := x.CodeId
+	case "inference.inference.MsgRequestBridgeMint.amount":
+		value := x.Amount
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterLiquidityPool.label":
-		value := x.Label
+	case "inference.inference.MsgRequestBridgeMint.destination_address":
+		value := x.DestinationAddress
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
-		value := x.InstantiateMsg
+	case "inference.inference.MsgRequestBridgeMint.chain_id":
+		value := x.ChainId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
+		value := x.DestinationBridgeAddress
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -27275,21 +30380,23 @@ func (x *fastReflection_MsgRegisterLiquidityPool) Get(descriptor protoreflect.Fi
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPool) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRequestBridgeMint) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterLiquidityPool.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRegisterLiquidityPool.code_id":
-		x.CodeId = value.Interface().(string)
-	case "inference.inference.MsgRegisterLiquidityPool.label":
-		x.Label = value.Interface().(string)
-	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
-		x.InstantiateMsg = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeMint.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeMint.amount":
+		x.Amount = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeMint.destination_address":
+		x.DestinationAddress = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeMint.chain_id":
+		x.ChainId = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
+		x.DestinationBridgeAddress = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27303,52 +30410,56 @@ func (x *fastReflection_MsgRegisterLiquidityPool) Set(fd protoreflect.FieldDescr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPool) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeMint) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterLiquidityPool.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
-	case "inference.inference.MsgRegisterLiquidityPool.code_id":
-		panic(fmt.Errorf("field code_id of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
-	case "inference.inference.MsgRegisterLiquidityPool.label":
-		panic(fmt.Errorf("field label of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
-	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
-		panic(fmt.Errorf("field instantiate_msg of message inference.inference.MsgRegisterLiquidityPool is not mutable"))
+	case "inference.inference.MsgRequestBridgeMint.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgRequestBridgeMint is not mutable"))
+	case "inference.inference.MsgRequestBridgeMint.amount":
+		panic(fmt.Errorf("field amount of message inference.inference.MsgRequestBridgeMint is not mutable"))
+	case "inference.inference.MsgRequestBridgeMint.destination_address":
+		panic(fmt.Errorf("field destination_address of message inference.inference.MsgRequestBridgeMint is not mutable"))
+	case "inference.inference.MsgRequestBridgeMint.chain_id":
+		panic(fmt.Errorf("field chain_id of message inference.inference.MsgRequestBridgeMint is not mutable"))
+	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
+		panic(fmt.Errorf("field destination_bridge_address of message inference.inference.MsgRequestBridgeMint is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterLiquidityPool) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeMint) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterLiquidityPool.authority":
+	case "inference.inference.MsgRequestBridgeMint.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterLiquidityPool.code_id":
+	case "inference.inference.MsgRequestBridgeMint.amount":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterLiquidityPool.label":
+	case "inference.inference.MsgRequestBridgeMint.destination_address":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterLiquidityPool.instantiate_msg":
+	case "inference.inference.MsgRequestBridgeMint.chain_id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPool"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPool does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterLiquidityPool) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRequestBridgeMint) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterLiquidityPool", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeMint", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -27356,7 +30467,7 @@ func (x *fastReflection_MsgRegisterLiquidityPool) WhichOneof(d protoreflect.Oneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterLiquidityPool) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRequestBridgeMint) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -27367,7 +30478,7 @@ func (x *fastReflection_MsgRegisterLiquidityPool) GetUnknown() protoreflect.RawF
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPool) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRequestBridgeMint) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -27379,7 +30490,7 @@ func (x *fastReflection_MsgRegisterLiquidityPool) SetUnknown(fields protoreflect
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterLiquidityPool) IsValid() bool {
+func (x *fastReflection_MsgRequestBridgeMint) IsValid() bool {
 	return x != nil
 }
 
@@ -27389,9 +30500,9 @@ func (x *fastReflection_MsgRegisterLiquidityPool) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterLiquidityPool)
+		x := input.Message.Interface().(*MsgRequestBridgeMint)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27403,19 +30514,23 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.CodeId)
+		l = len(x.Amount)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Label)
+		l = len(x.DestinationAddress)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.InstantiateMsg)
+		l = len(x.ChainId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.DestinationBridgeAddress)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -27429,7 +30544,7 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterLiquidityPool)
+		x := input.Message.Interface().(*MsgRequestBridgeMint)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27448,31 +30563,38 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.InstantiateMsg) > 0 {
-			i -= len(x.InstantiateMsg)
-			copy(dAtA[i:], x.InstantiateMsg)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.InstantiateMsg)))
+		if len(x.DestinationBridgeAddress) > 0 {
+			i -= len(x.DestinationBridgeAddress)
+			copy(dAtA[i:], x.DestinationBridgeAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationBridgeAddress)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.ChainId) > 0 {
+			i -= len(x.ChainId)
+			copy(dAtA[i:], x.ChainId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
 			i--
 			dAtA[i] = 0x22
 		}
-		if len(x.Label) > 0 {
-			i -= len(x.Label)
-			copy(dAtA[i:], x.Label)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Label)))
+		if len(x.DestinationAddress) > 0 {
+			i -= len(x.DestinationAddress)
+			copy(dAtA[i:], x.DestinationAddress)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationAddress)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.CodeId) > 0 {
-			i -= len(x.CodeId)
-			copy(dAtA[i:], x.CodeId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CodeId)))
+		if len(x.Amount) > 0 {
+			i -= len(x.Amount)
+			copy(dAtA[i:], x.Amount)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Amount)))
 			i--
 			dAtA[i] = 0x12
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -27487,7 +30609,7 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterLiquidityPool)
+		x := input.Message.Interface().(*MsgRequestBridgeMint)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27519,15 +30641,15 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPool: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMint: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPool: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMint: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -27555,11 +30677,11 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -27587,11 +30709,11 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.CodeId = string(dAtA[iNdEx:postIndex])
+				x.Amount = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationAddress", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -27619,11 +30741,11 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Label = string(dAtA[iNdEx:postIndex])
+				x.DestinationAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 4:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field InstantiateMsg", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -27651,7 +30773,39 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.InstantiateMsg = string(dAtA[iNdEx:postIndex])
+				x.ChainId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationBridgeAddress", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.DestinationBridgeAddress = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -27689,24 +30843,30 @@ func (x *fastReflection_MsgRegisterLiquidityPool) ProtoMethods() *protoiface.Met
 }
 
 var (
-	md_MsgRegisterLiquidityPoolResponse protoreflect.MessageDescriptor
+	md_MsgRequestBridgeMintResponse                protoreflect.MessageDescriptor
+	fd_MsgRequestBridgeMintResponse_request_id     protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeMintResponse_epoch_index    protoreflect.FieldDescriptor
+	fd_MsgRequestBridgeMintResponse_bls_request_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterLiquidityPoolResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterLiquidityPoolResponse")
+	md_MsgRequestBridgeMintResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeMintResponse")
+	fd_MsgRequestBridgeMintResponse_request_id = md_MsgRequestBridgeMintResponse.Fields().ByName("request_id")
+	fd_MsgRequestBridgeMintResponse_epoch_index = md_MsgRequestBridgeMintResponse.Fields().ByName("epoch_index")
+	fd_MsgRequestBridgeMintResponse_bls_request_id = md_MsgRequestBridgeMintResponse.Fields().ByName("bls_request_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterLiquidityPoolResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeMintResponse)(nil)
 
-type fastReflection_MsgRegisterLiquidityPoolResponse MsgRegisterLiquidityPoolResponse
+type fastReflection_MsgRequestBridgeMintResponse MsgRequestBridgeMintResponse
 
-func (x *MsgRegisterLiquidityPoolResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterLiquidityPoolResponse)(x)
+func (x *MsgRequestBridgeMintResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeMintResponse)(x)
 }
 
-func (x *MsgRegisterLiquidityPoolResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[51]
+func (x *MsgRequestBridgeMintResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[57]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -27717,43 +30877,43 @@ func (x *MsgRegisterLiquidityPoolResponse) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterLiquidityPoolResponse_messageType fastReflection_MsgRegisterLiquidityPoolResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterLiquidityPoolResponse_messageType{}
+var _fastReflection_MsgRequestBridgeMintResponse_messageType fastReflection_MsgRequestBridgeMintResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeMintResponse_messageType{}
 
-type fastReflection_MsgRegisterLiquidityPoolResponse_messageType struct{}
+type fastReflection_MsgRequestBridgeMintResponse_messageType struct{}
 
-func (x fastReflection_MsgRegisterLiquidityPoolResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterLiquidityPoolResponse)(nil)
+func (x fastReflection_MsgRequestBridgeMintResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRequestBridgeMintResponse)(nil)
 }
-func (x fastReflection_MsgRegisterLiquidityPoolResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterLiquidityPoolResponse)
+func (x fastReflection_MsgRequestBridgeMintResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeMintResponse)
 }
-func (x fastReflection_MsgRegisterLiquidityPoolResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterLiquidityPoolResponse
+func (x fastReflection_MsgRequestBridgeMintResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeMintResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterLiquidityPoolResponse
+func (x *fastReflection_MsgRequestBridgeMintResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRequestBridgeMintResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterLiquidityPoolResponse_messageType
+func (x *fastReflection_MsgRequestBridgeMintResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRequestBridgeMintResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterLiquidityPoolResponse)
+func (x *fastReflection_MsgRequestBridgeMintResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRequestBridgeMintResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterLiquidityPoolResponse)(x)
+func (x *fastReflection_MsgRequestBridgeMintResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRequestBridgeMintResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -27761,7 +30921,25 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRequestBridgeMintResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.RequestId != "" {
+		value := protoreflect.ValueOfString(x.RequestId)
+		if !f(fd_MsgRequestBridgeMintResponse_request_id, value) {
+			return
+		}
+	}
+	if x.EpochIndex != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EpochIndex)
+		if !f(fd_MsgRequestBridgeMintResponse_epoch_index, value) {
+			return
+		}
+	}
+	if x.BlsRequestId != "" {
+		value := protoreflect.ValueOfString(x.BlsRequestId)
+		if !f(fd_MsgRequestBridgeMintResponse_bls_request_id, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -27775,13 +30953,19 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRequestBridgeMintResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
+		return x.RequestId != ""
+	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
+		return x.EpochIndex != uint64(0)
+	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
+		return x.BlsRequestId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27791,13 +30975,19 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRequestBridgeMintResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
+		x.RequestId = ""
+	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
+		x.EpochIndex = uint64(0)
+	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
+		x.BlsRequestId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27807,13 +30997,22 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeMintResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
+		value := x.RequestId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
+		value := x.EpochIndex
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
+		value := x.BlsRequestId
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -27827,13 +31026,19 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRequestBridgeMintResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
+		x.RequestId = value.Interface().(string)
+	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
+		x.EpochIndex = value.Uint()
+	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
+		x.BlsRequestId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -27847,36 +31052,48 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeMintResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
+		panic(fmt.Errorf("field request_id of message inference.inference.MsgRequestBridgeMintResponse is not mutable"))
+	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
+		panic(fmt.Errorf("field epoch_index of message inference.inference.MsgRequestBridgeMintResponse is not mutable"))
+	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
+		panic(fmt.Errorf("field bls_request_id of message inference.inference.MsgRequestBridgeMintResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRequestBridgeMintResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
+		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterLiquidityPoolResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterLiquidityPoolResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRequestBridgeMintResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterLiquidityPoolResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeMintResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -27884,7 +31101,7 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRequestBridgeMintResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -27895,7 +31112,7 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRequestBridgeMintResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -27907,7 +31124,7 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) IsValid() bool {
+func (x *fastReflection_MsgRequestBridgeMintResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -27917,9 +31134,9 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterLiquidityPoolResponse)
+		x := input.Message.Interface().(*MsgRequestBridgeMintResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27931,6 +31148,17 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoi
 		var n int
 		var l int
 		_ = l
+		l = len(x.RequestId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.EpochIndex != 0 {
+			n += 1 + runtime.Sov(uint64(x.EpochIndex))
+		}
+		l = len(x.BlsRequestId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -27941,7 +31169,7 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterLiquidityPoolResponse)
+		x := input.Message.Interface().(*MsgRequestBridgeMintResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27960,6 +31188,25 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoi
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if len(x.BlsRequestId) > 0 {
+			i -= len(x.BlsRequestId)
+			copy(dAtA[i:], x.BlsRequestId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlsRequestId)))
+			i--
+			dAtA[i] = 0x1a
+		}
+		if x.EpochIndex != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
+			i--
+			dAtA[i] = 0x10
+		}
+		if len(x.RequestId) > 0 {
+			i -= len(x.RequestId)
+			copy(dAtA[i:], x.RequestId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
+			i--
+			dAtA[i] = 0xa
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -27971,7 +31218,7 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterLiquidityPoolResponse)
+		x := input.Message.Interface().(*MsgRequestBridgeMintResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -27990,25 +31237,108 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoi
 				if shift >= 64 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
 				}
-				if iNdEx >= l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				if iNdEx >= l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMintResponse: wiretype end group for non-group")
+			}
+			if fieldNum <= 0 {
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMintResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			}
+			switch fieldNum {
+			case 1:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.RequestId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				}
+				x.EpochIndex = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EpochIndex |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlsRequestId", wireType)
 				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				wire |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
 				}
-			}
-			fieldNum := int32(wire >> 3)
-			wireType := int(wire & 0x7)
-			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPoolResponse: wiretype end group for non-group")
-			}
-			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-			}
-			switch fieldNum {
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.BlsRequestId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -28045,34 +31375,28 @@ func (x *fastReflection_MsgRegisterLiquidityPoolResponse) ProtoMethods() *protoi
 }
 
 var (
-	md_MsgRequestBridgeWithdrawal                            protoreflect.MessageDescriptor
-	fd_MsgRequestBridgeWithdrawal_creator                    protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeWithdrawal_user_address               protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeWithdrawal_amount                     protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeWithdrawal_destination_address        protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeWithdrawal_destination_bridge_address protoreflect.FieldDescriptor
+	md_MsgCancelBridgeOperation            protoreflect.MessageDescriptor
+	fd_MsgCancelBridgeOperation_creator    protoreflect.FieldDescriptor
+	fd_MsgCancelBridgeOperation_request_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRequestBridgeWithdrawal = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeWithdrawal")
-	fd_MsgRequestBridgeWithdrawal_creator = md_MsgRequestBridgeWithdrawal.Fields().ByName("creator")
-	fd_MsgRequestBridgeWithdrawal_user_address = md_MsgRequestBridgeWithdrawal.Fields().ByName("user_address")
-	fd_MsgRequestBridgeWithdrawal_amount = md_MsgRequestBridgeWithdrawal.Fields().ByName("amount")
-	fd_MsgRequestBridgeWithdrawal_destination_address = md_MsgRequestBridgeWithdrawal.Fields().ByName("destination_address")
-	fd_MsgRequestBridgeWithdrawal_destination_bridge_address = md_MsgRequestBridgeWithdrawal.Fields().ByName("destination_bridge_address")
+	md_MsgCancelBridgeOperation = File_inference_inference_tx_proto.Messages().ByName("MsgCancelBridgeOperation")
+	fd_MsgCancelBridgeOperation_creator = md_MsgCancelBridgeOperation.Fields().ByName("creator")
+	fd_MsgCancelBridgeOperation_request_id = md_MsgCancelBridgeOperation.Fields().ByName("request_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeWithdrawal)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCancelBridgeOperation)(nil)
 
-type fastReflection_MsgRequestBridgeWithdrawal MsgRequestBridgeWithdrawal
+type fastReflection_MsgCancelBridgeOperation MsgCancelBridgeOperation
 
-func (x *MsgRequestBridgeWithdrawal) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeWithdrawal)(x)
+func (x *MsgCancelBridgeOperation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCancelBridgeOperation)(x)
 }
 
-func (x *MsgRequestBridgeWithdrawal) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[52]
+func (x *MsgCancelBridgeOperation) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[58]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -28083,43 +31407,43 @@ func (x *MsgRequestBridgeWithdrawal) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRequestBridgeWithdrawal_messageType fastReflection_MsgRequestBridgeWithdrawal_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeWithdrawal_messageType{}
+var _fastReflection_MsgCancelBridgeOperation_messageType fastReflection_MsgCancelBridgeOperation_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCancelBridgeOperation_messageType{}
 
-type fastReflection_MsgRequestBridgeWithdrawal_messageType struct{}
+type fastReflection_MsgCancelBridgeOperation_messageType struct{}
 
-func (x fastReflection_MsgRequestBridgeWithdrawal_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeWithdrawal)(nil)
+func (x fastReflection_MsgCancelBridgeOperation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCancelBridgeOperation)(nil)
 }
-func (x fastReflection_MsgRequestBridgeWithdrawal_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeWithdrawal)
+func (x fastReflection_MsgCancelBridgeOperation_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelBridgeOperation)
 }
-func (x fastReflection_MsgRequestBridgeWithdrawal_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeWithdrawal
+func (x fastReflection_MsgCancelBridgeOperation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelBridgeOperation
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeWithdrawal
+func (x *fastReflection_MsgCancelBridgeOperation) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelBridgeOperation
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRequestBridgeWithdrawal_messageType
+func (x *fastReflection_MsgCancelBridgeOperation) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCancelBridgeOperation_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeWithdrawal)
+func (x *fastReflection_MsgCancelBridgeOperation) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelBridgeOperation)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Interface() protoreflect.ProtoMessage {
-	return (*MsgRequestBridgeWithdrawal)(x)
+func (x *fastReflection_MsgCancelBridgeOperation) Interface() protoreflect.ProtoMessage {
+	return (*MsgCancelBridgeOperation)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -28127,34 +31451,16 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) Interface() protoreflect.Pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgCancelBridgeOperation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Creator != "" {
 		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgRequestBridgeWithdrawal_creator, value) {
-			return
-		}
-	}
-	if x.UserAddress != "" {
-		value := protoreflect.ValueOfString(x.UserAddress)
-		if !f(fd_MsgRequestBridgeWithdrawal_user_address, value) {
-			return
-		}
-	}
-	if x.Amount != "" {
-		value := protoreflect.ValueOfString(x.Amount)
-		if !f(fd_MsgRequestBridgeWithdrawal_amount, value) {
-			return
-		}
-	}
-	if x.DestinationAddress != "" {
-		value := protoreflect.ValueOfString(x.DestinationAddress)
-		if !f(fd_MsgRequestBridgeWithdrawal_destination_address, value) {
+		if !f(fd_MsgCancelBridgeOperation_creator, value) {
 			return
 		}
 	}
-	if x.DestinationBridgeAddress != "" {
-		value := protoreflect.ValueOfString(x.DestinationBridgeAddress)
-		if !f(fd_MsgRequestBridgeWithdrawal_destination_bridge_address, value) {
+	if x.RequestId != "" {
+		value := protoreflect.ValueOfString(x.RequestId)
+		if !f(fd_MsgCancelBridgeOperation_request_id, value) {
 			return
 		}
 	}
@@ -28171,23 +31477,17 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) Range(f func(protoreflect.Fi
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCancelBridgeOperation) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+	case "inference.inference.MsgCancelBridgeOperation.creator":
 		return x.Creator != ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
-		return x.UserAddress != ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
-		return x.Amount != ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
-		return x.DestinationAddress != ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
-		return x.DestinationBridgeAddress != ""
+	case "inference.inference.MsgCancelBridgeOperation.request_id":
+		return x.RequestId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28197,23 +31497,17 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) Has(fd protoreflect.FieldDes
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCancelBridgeOperation) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+	case "inference.inference.MsgCancelBridgeOperation.creator":
 		x.Creator = ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
-		x.UserAddress = ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
-		x.Amount = ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
-		x.DestinationAddress = ""
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
-		x.DestinationBridgeAddress = ""
+	case "inference.inference.MsgCancelBridgeOperation.request_id":
+		x.RequestId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28223,28 +31517,19 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) Clear(fd protoreflect.FieldD
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelBridgeOperation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+	case "inference.inference.MsgCancelBridgeOperation.creator":
 		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
-		value := x.UserAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
-		value := x.Amount
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
-		value := x.DestinationAddress
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
-		value := x.DestinationBridgeAddress
+	case "inference.inference.MsgCancelBridgeOperation.request_id":
+		value := x.RequestId
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -28258,23 +31543,17 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) Get(descriptor protoreflect.
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCancelBridgeOperation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
+	case "inference.inference.MsgCancelBridgeOperation.creator":
 		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
-		x.UserAddress = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
-		x.Amount = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
-		x.DestinationAddress = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
-		x.DestinationBridgeAddress = value.Interface().(string)
+	case "inference.inference.MsgCancelBridgeOperation.request_id":
+		x.RequestId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28288,56 +31567,44 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) Set(fd protoreflect.FieldDes
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelBridgeOperation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
-	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
-		panic(fmt.Errorf("field user_address of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
-	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
-		panic(fmt.Errorf("field amount of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
-		panic(fmt.Errorf("field destination_address of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
-		panic(fmt.Errorf("field destination_bridge_address of message inference.inference.MsgRequestBridgeWithdrawal is not mutable"))
+	case "inference.inference.MsgCancelBridgeOperation.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgCancelBridgeOperation.request_id":
+		panic(fmt.Errorf("field request_id of message inference.inference.MsgCancelBridgeOperation is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelBridgeOperation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawal.creator":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeWithdrawal.user_address":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeWithdrawal.amount":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_address":
+	case "inference.inference.MsgCancelBridgeOperation.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeWithdrawal.destination_bridge_address":
+	case "inference.inference.MsgCancelBridgeOperation.request_id":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawal"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawal does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCancelBridgeOperation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeWithdrawal", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCancelBridgeOperation", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -28345,7 +31612,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) WhichOneof(d protoreflect.On
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCancelBridgeOperation) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -28356,7 +31623,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) GetUnknown() protoreflect.Ra
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCancelBridgeOperation) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -28368,7 +31635,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) SetUnknown(fields protorefle
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) IsValid() bool {
+func (x *fastReflection_MsgCancelBridgeOperation) IsValid() bool {
 	return x != nil
 }
 
@@ -28378,9 +31645,9 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRequestBridgeWithdrawal)
+		x := input.Message.Interface().(*MsgCancelBridgeOperation)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28396,19 +31663,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.UserAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.Amount)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.DestinationAddress)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.DestinationBridgeAddress)
+		l = len(x.RequestId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -28422,7 +31677,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeWithdrawal)
+		x := input.Message.Interface().(*MsgCancelBridgeOperation)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28441,31 +31696,10 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.DestinationBridgeAddress) > 0 {
-			i -= len(x.DestinationBridgeAddress)
-			copy(dAtA[i:], x.DestinationBridgeAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationBridgeAddress)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.DestinationAddress) > 0 {
-			i -= len(x.DestinationAddress)
-			copy(dAtA[i:], x.DestinationAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationAddress)))
-			i--
-			dAtA[i] = 0x22
-		}
-		if len(x.Amount) > 0 {
-			i -= len(x.Amount)
-			copy(dAtA[i:], x.Amount)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Amount)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if len(x.UserAddress) > 0 {
-			i -= len(x.UserAddress)
-			copy(dAtA[i:], x.UserAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.UserAddress)))
+		if len(x.RequestId) > 0 {
+			i -= len(x.RequestId)
+			copy(dAtA[i:], x.RequestId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
 			i--
 			dAtA[i] = 0x12
 		}
@@ -28487,7 +31721,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeWithdrawal)
+		x := input.Message.Interface().(*MsgCancelBridgeOperation)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -28519,10 +31753,10 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawal: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperation: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawal: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperation: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -28559,103 +31793,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field UserAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.UserAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Amount = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationAddress", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.DestinationAddress = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationBridgeAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -28683,7 +31821,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.DestinationBridgeAddress = string(dAtA[iNdEx:postIndex])
+				x.RequestId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -28721,30 +31859,24 @@ func (x *fastReflection_MsgRequestBridgeWithdrawal) ProtoMethods() *protoiface.M
 }
 
 var (
-	md_MsgRequestBridgeWithdrawalResponse                protoreflect.MessageDescriptor
-	fd_MsgRequestBridgeWithdrawalResponse_request_id     protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeWithdrawalResponse_epoch_index    protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeWithdrawalResponse_bls_request_id protoreflect.FieldDescriptor
+	md_MsgCancelBridgeOperationResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRequestBridgeWithdrawalResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeWithdrawalResponse")
-	fd_MsgRequestBridgeWithdrawalResponse_request_id = md_MsgRequestBridgeWithdrawalResponse.Fields().ByName("request_id")
-	fd_MsgRequestBridgeWithdrawalResponse_epoch_index = md_MsgRequestBridgeWithdrawalResponse.Fields().ByName("epoch_index")
-	fd_MsgRequestBridgeWithdrawalResponse_bls_request_id = md_MsgRequestBridgeWithdrawalResponse.Fields().ByName("bls_request_id")
+	md_MsgCancelBridgeOperationResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCancelBridgeOperationResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeWithdrawalResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCancelBridgeOperationResponse)(nil)
 
-type fastReflection_MsgRequestBridgeWithdrawalResponse MsgRequestBridgeWithdrawalResponse
+type fastReflection_MsgCancelBridgeOperationResponse MsgCancelBridgeOperationResponse
 
-func (x *MsgRequestBridgeWithdrawalResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeWithdrawalResponse)(x)
+func (x *MsgCancelBridgeOperationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCancelBridgeOperationResponse)(x)
 }
 
-func (x *MsgRequestBridgeWithdrawalResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[53]
+func (x *MsgCancelBridgeOperationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[59]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -28755,43 +31887,43 @@ func (x *MsgRequestBridgeWithdrawalResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRequestBridgeWithdrawalResponse_messageType fastReflection_MsgRequestBridgeWithdrawalResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeWithdrawalResponse_messageType{}
+var _fastReflection_MsgCancelBridgeOperationResponse_messageType fastReflection_MsgCancelBridgeOperationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCancelBridgeOperationResponse_messageType{}
 
-type fastReflection_MsgRequestBridgeWithdrawalResponse_messageType struct{}
+type fastReflection_MsgCancelBridgeOperationResponse_messageType struct{}
 
-func (x fastReflection_MsgRequestBridgeWithdrawalResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeWithdrawalResponse)(nil)
+func (x fastReflection_MsgCancelBridgeOperationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCancelBridgeOperationResponse)(nil)
 }
-func (x fastReflection_MsgRequestBridgeWithdrawalResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeWithdrawalResponse)
+func (x fastReflection_MsgCancelBridgeOperationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelBridgeOperationResponse)
 }
-func (x fastReflection_MsgRequestBridgeWithdrawalResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeWithdrawalResponse
+func (x fastReflection_MsgCancelBridgeOperationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelBridgeOperationResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeWithdrawalResponse
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelBridgeOperationResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRequestBridgeWithdrawalResponse_messageType
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCancelBridgeOperationResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeWithdrawalResponse)
+func (x *fastReflection_MsgCancelBridgeOperationResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelBridgeOperationResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRequestBridgeWithdrawalResponse)(x)
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgCancelBridgeOperationResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -28799,25 +31931,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.RequestId != "" {
-		value := protoreflect.ValueOfString(x.RequestId)
-		if !f(fd_MsgRequestBridgeWithdrawalResponse_request_id, value) {
-			return
-		}
-	}
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_MsgRequestBridgeWithdrawalResponse_epoch_index, value) {
-			return
-		}
-	}
-	if x.BlsRequestId != "" {
-		value := protoreflect.ValueOfString(x.BlsRequestId)
-		if !f(fd_MsgRequestBridgeWithdrawalResponse_bls_request_id, value) {
-			return
-		}
-	}
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -28831,19 +31945,13 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
-		return x.RequestId != ""
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
-		return x.EpochIndex != uint64(0)
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
-		return x.BlsRequestId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28853,19 +31961,13 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
-		x.RequestId = ""
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
-		x.EpochIndex = uint64(0)
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
-		x.BlsRequestId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28875,22 +31977,13 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
-		value := x.RequestId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
-		value := x.BlsRequestId
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -28904,19 +31997,13 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
-		x.RequestId = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
-		x.EpochIndex = value.Uint()
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
-		x.BlsRequestId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -28930,48 +32017,36 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
-		panic(fmt.Errorf("field request_id of message inference.inference.MsgRequestBridgeWithdrawalResponse is not mutable"))
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.MsgRequestBridgeWithdrawalResponse is not mutable"))
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
-		panic(fmt.Errorf("field bls_request_id of message inference.inference.MsgRequestBridgeWithdrawalResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.request_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgRequestBridgeWithdrawalResponse.bls_request_id":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeWithdrawalResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeWithdrawalResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeWithdrawalResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCancelBridgeOperationResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -28979,7 +32054,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -28990,7 +32065,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -29002,7 +32077,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) IsValid() bool {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -29012,9 +32087,9 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCancelBridgeOperationResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRequestBridgeWithdrawalResponse)
+		x := input.Message.Interface().(*MsgCancelBridgeOperationResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29026,17 +32101,6 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		l = len(x.RequestId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
-		}
-		l = len(x.BlsRequestId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -29047,7 +32111,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeWithdrawalResponse)
+		x := input.Message.Interface().(*MsgCancelBridgeOperationResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29066,25 +32130,6 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.BlsRequestId) > 0 {
-			i -= len(x.BlsRequestId)
-			copy(dAtA[i:], x.BlsRequestId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlsRequestId)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
-			i--
-			dAtA[i] = 0x10
-		}
-		if len(x.RequestId) > 0 {
-			i -= len(x.RequestId)
-			copy(dAtA[i:], x.RequestId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -29096,7 +32141,7 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeWithdrawalResponse)
+		x := input.Message.Interface().(*MsgCancelBridgeOperationResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29128,95 +32173,12 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawalResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperationResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeWithdrawalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RequestId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-				}
-				x.EpochIndex = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlsRequestId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.BlsRequestId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -29253,34 +32215,34 @@ func (x *fastReflection_MsgRequestBridgeWithdrawalResponse) ProtoMethods() *prot
 }
 
 var (
-	md_MsgRequestBridgeMint                            protoreflect.MessageDescriptor
-	fd_MsgRequestBridgeMint_creator                    protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeMint_amount                     protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeMint_destination_address        protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeMint_chain_id                   protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeMint_destination_bridge_address protoreflect.FieldDescriptor
+	md_MsgGovernanceCancelBridgeOperation                           protoreflect.MessageDescriptor
+	fd_MsgGovernanceCancelBridgeOperation_authority                 protoreflect.FieldDescriptor
+	fd_MsgGovernanceCancelBridgeOperation_request_id                protoreflect.FieldDescriptor
+	fd_MsgGovernanceCancelBridgeOperation_override_recipient        protoreflect.FieldDescriptor
+	fd_MsgGovernanceCancelBridgeOperation_override_wrapped_contract protoreflect.FieldDescriptor
+	fd_MsgGovernanceCancelBridgeOperation_reason                    protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRequestBridgeMint = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeMint")
-	fd_MsgRequestBridgeMint_creator = md_MsgRequestBridgeMint.Fields().ByName("creator")
-	fd_MsgRequestBridgeMint_amount = md_MsgRequestBridgeMint.Fields().ByName("amount")
-	fd_MsgRequestBridgeMint_destination_address = md_MsgRequestBridgeMint.Fields().ByName("destination_address")
-	fd_MsgRequestBridgeMint_chain_id = md_MsgRequestBridgeMint.Fields().ByName("chain_id")
-	fd_MsgRequestBridgeMint_destination_bridge_address = md_MsgRequestBridgeMint.Fields().ByName("destination_bridge_address")
+	md_MsgGovernanceCancelBridgeOperation = File_inference_inference_tx_proto.Messages().ByName("MsgGovernanceCancelBridgeOperation")
+	fd_MsgGovernanceCancelBridgeOperation_authority = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("authority")
+	fd_MsgGovernanceCancelBridgeOperation_request_id = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("request_id")
+	fd_MsgGovernanceCancelBridgeOperation_override_recipient = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("override_recipient")
+	fd_MsgGovernanceCancelBridgeOperation_override_wrapped_contract = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("override_wrapped_contract")
+	fd_MsgGovernanceCancelBridgeOperation_reason = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("reason")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeMint)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgGovernanceCancelBridgeOperation)(nil)
 
-type fastReflection_MsgRequestBridgeMint MsgRequestBridgeMint
+type fastReflection_MsgGovernanceCancelBridgeOperation MsgGovernanceCancelBridgeOperation
 
-func (x *MsgRequestBridgeMint) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeMint)(x)
+func (x *MsgGovernanceCancelBridgeOperation) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgGovernanceCancelBridgeOperation)(x)
 }
 
-func (x *MsgRequestBridgeMint) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[54]
+func (x *MsgGovernanceCancelBridgeOperation) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[60]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -29291,43 +32253,43 @@ func (x *MsgRequestBridgeMint) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRequestBridgeMint_messageType fastReflection_MsgRequestBridgeMint_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeMint_messageType{}
+var _fastReflection_MsgGovernanceCancelBridgeOperation_messageType fastReflection_MsgGovernanceCancelBridgeOperation_messageType
+var _ protoreflect.MessageType = fastReflection_MsgGovernanceCancelBridgeOperation_messageType{}
 
-type fastReflection_MsgRequestBridgeMint_messageType struct{}
+type fastReflection_MsgGovernanceCancelBridgeOperation_messageType struct{}
 
-func (x fastReflection_MsgRequestBridgeMint_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeMint)(nil)
+func (x fastReflection_MsgGovernanceCancelBridgeOperation_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgGovernanceCancelBridgeOperation)(nil)
 }
-func (x fastReflection_MsgRequestBridgeMint_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeMint)
+func (x fastReflection_MsgGovernanceCancelBridgeOperation_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgGovernanceCancelBridgeOperation)
 }
-func (x fastReflection_MsgRequestBridgeMint_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeMint
+func (x fastReflection_MsgGovernanceCancelBridgeOperation_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgGovernanceCancelBridgeOperation
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRequestBridgeMint) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeMint
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgGovernanceCancelBridgeOperation
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRequestBridgeMint) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRequestBridgeMint_messageType
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Type() protoreflect.MessageType {
+	return _fastReflection_MsgGovernanceCancelBridgeOperation_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRequestBridgeMint) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeMint)
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) New() protoreflect.Message {
+	return new(fastReflection_MsgGovernanceCancelBridgeOperation)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRequestBridgeMint) Interface() protoreflect.ProtoMessage {
-	return (*MsgRequestBridgeMint)(x)
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Interface() protoreflect.ProtoMessage {
+	return (*MsgGovernanceCancelBridgeOperation)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -29335,34 +32297,34 @@ func (x *fastReflection_MsgRequestBridgeMint) Interface() protoreflect.ProtoMess
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRequestBridgeMint) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Creator != "" {
-		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgRequestBridgeMint_creator, value) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgGovernanceCancelBridgeOperation_authority, value) {
 			return
 		}
 	}
-	if x.Amount != "" {
-		value := protoreflect.ValueOfString(x.Amount)
-		if !f(fd_MsgRequestBridgeMint_amount, value) {
+	if x.RequestId != "" {
+		value := protoreflect.ValueOfString(x.RequestId)
+		if !f(fd_MsgGovernanceCancelBridgeOperation_request_id, value) {
 			return
 		}
 	}
-	if x.DestinationAddress != "" {
-		value := protoreflect.ValueOfString(x.DestinationAddress)
-		if !f(fd_MsgRequestBridgeMint_destination_address, value) {
+	if x.OverrideRecipient != "" {
+		value := protoreflect.ValueOfString(x.OverrideRecipient)
+		if !f(fd_MsgGovernanceCancelBridgeOperation_override_recipient, value) {
 			return
 		}
 	}
-	if x.ChainId != "" {
-		value := protoreflect.ValueOfString(x.ChainId)
-		if !f(fd_MsgRequestBridgeMint_chain_id, value) {
+	if x.OverrideWrappedContract != "" {
+		value := protoreflect.ValueOfString(x.OverrideWrappedContract)
+		if !f(fd_MsgGovernanceCancelBridgeOperation_override_wrapped_contract, value) {
 			return
 		}
 	}
-	if x.DestinationBridgeAddress != "" {
-		value := protoreflect.ValueOfString(x.DestinationBridgeAddress)
-		if !f(fd_MsgRequestBridgeMint_destination_bridge_address, value) {
+	if x.Reason != "" {
+		value := protoreflect.ValueOfString(x.Reason)
+		if !f(fd_MsgGovernanceCancelBridgeOperation_reason, value) {
 			return
 		}
 	}
@@ -29379,23 +32341,23 @@ func (x *fastReflection_MsgRequestBridgeMint) Range(f func(protoreflect.FieldDes
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRequestBridgeMint) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMint.creator":
-		return x.Creator != ""
-	case "inference.inference.MsgRequestBridgeMint.amount":
-		return x.Amount != ""
-	case "inference.inference.MsgRequestBridgeMint.destination_address":
-		return x.DestinationAddress != ""
-	case "inference.inference.MsgRequestBridgeMint.chain_id":
-		return x.ChainId != ""
-	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
-		return x.DestinationBridgeAddress != ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
+		return x.RequestId != ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
+		return x.OverrideRecipient != ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
+		return x.OverrideWrappedContract != ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
+		return x.Reason != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29405,23 +32367,23 @@ func (x *fastReflection_MsgRequestBridgeMint) Has(fd protoreflect.FieldDescripto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMint) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMint.creator":
-		x.Creator = ""
-	case "inference.inference.MsgRequestBridgeMint.amount":
-		x.Amount = ""
-	case "inference.inference.MsgRequestBridgeMint.destination_address":
-		x.DestinationAddress = ""
-	case "inference.inference.MsgRequestBridgeMint.chain_id":
-		x.ChainId = ""
-	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
-		x.DestinationBridgeAddress = ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+		x.Authority = ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
+		x.RequestId = ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
+		x.OverrideRecipient = ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
+		x.OverrideWrappedContract = ""
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
+		x.Reason = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29431,28 +32393,28 @@ func (x *fastReflection_MsgRequestBridgeMint) Clear(fd protoreflect.FieldDescrip
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRequestBridgeMint) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRequestBridgeMint.creator":
-		value := x.Creator
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeMint.amount":
-		value := x.Amount
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
+		value := x.RequestId
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeMint.destination_address":
-		value := x.DestinationAddress
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
+		value := x.OverrideRecipient
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeMint.chain_id":
-		value := x.ChainId
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
+		value := x.OverrideWrappedContract
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
-		value := x.DestinationBridgeAddress
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
+		value := x.Reason
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -29466,23 +32428,23 @@ func (x *fastReflection_MsgRequestBridgeMint) Get(descriptor protoreflect.FieldD
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMint) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMint.creator":
-		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeMint.amount":
-		x.Amount = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeMint.destination_address":
-		x.DestinationAddress = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeMint.chain_id":
-		x.ChainId = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
-		x.DestinationBridgeAddress = value.Interface().(string)
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
+		x.RequestId = value.Interface().(string)
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
+		x.OverrideRecipient = value.Interface().(string)
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
+		x.OverrideWrappedContract = value.Interface().(string)
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
+		x.Reason = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -29496,56 +32458,56 @@ func (x *fastReflection_MsgRequestBridgeMint) Set(fd protoreflect.FieldDescripto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMint) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMint.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgRequestBridgeMint is not mutable"))
-	case "inference.inference.MsgRequestBridgeMint.amount":
-		panic(fmt.Errorf("field amount of message inference.inference.MsgRequestBridgeMint is not mutable"))
-	case "inference.inference.MsgRequestBridgeMint.destination_address":
-		panic(fmt.Errorf("field destination_address of message inference.inference.MsgRequestBridgeMint is not mutable"))
-	case "inference.inference.MsgRequestBridgeMint.chain_id":
-		panic(fmt.Errorf("field chain_id of message inference.inference.MsgRequestBridgeMint is not mutable"))
-	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
-		panic(fmt.Errorf("field destination_bridge_address of message inference.inference.MsgRequestBridgeMint is not mutable"))
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
+		panic(fmt.Errorf("field request_id of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
+		panic(fmt.Errorf("field override_recipient of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
+		panic(fmt.Errorf("field override_wrapped_contract of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
+		panic(fmt.Errorf("field reason of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRequestBridgeMint) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMint.creator":
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeMint.amount":
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeMint.destination_address":
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeMint.chain_id":
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeMint.destination_bridge_address":
+	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMint"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMint does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRequestBridgeMint) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeMint", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgGovernanceCancelBridgeOperation", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -29553,7 +32515,7 @@ func (x *fastReflection_MsgRequestBridgeMint) WhichOneof(d protoreflect.OneofDes
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRequestBridgeMint) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -29564,7 +32526,7 @@ func (x *fastReflection_MsgRequestBridgeMint) GetUnknown() protoreflect.RawField
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMint) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -29576,7 +32538,7 @@ func (x *fastReflection_MsgRequestBridgeMint) SetUnknown(fields protoreflect.Raw
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRequestBridgeMint) IsValid() bool {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) IsValid() bool {
 	return x != nil
 }
 
@@ -29586,9 +32548,9 @@ func (x *fastReflection_MsgRequestBridgeMint) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRequestBridgeMint)
+		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperation)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29600,23 +32562,23 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 		var n int
 		var l int
 		_ = l
-		l = len(x.Creator)
+		l = len(x.Authority)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Amount)
+		l = len(x.RequestId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.DestinationAddress)
+		l = len(x.OverrideRecipient)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ChainId)
+		l = len(x.OverrideWrappedContract)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.DestinationBridgeAddress)
+		l = len(x.Reason)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -29630,7 +32592,7 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeMint)
+		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperation)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29649,38 +32611,38 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.DestinationBridgeAddress) > 0 {
-			i -= len(x.DestinationBridgeAddress)
-			copy(dAtA[i:], x.DestinationBridgeAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationBridgeAddress)))
+		if len(x.Reason) > 0 {
+			i -= len(x.Reason)
+			copy(dAtA[i:], x.Reason)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Reason)))
 			i--
 			dAtA[i] = 0x2a
 		}
-		if len(x.ChainId) > 0 {
-			i -= len(x.ChainId)
-			copy(dAtA[i:], x.ChainId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+		if len(x.OverrideWrappedContract) > 0 {
+			i -= len(x.OverrideWrappedContract)
+			copy(dAtA[i:], x.OverrideWrappedContract)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OverrideWrappedContract)))
 			i--
 			dAtA[i] = 0x22
 		}
-		if len(x.DestinationAddress) > 0 {
-			i -= len(x.DestinationAddress)
-			copy(dAtA[i:], x.DestinationAddress)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.DestinationAddress)))
+		if len(x.OverrideRecipient) > 0 {
+			i -= len(x.OverrideRecipient)
+			copy(dAtA[i:], x.OverrideRecipient)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OverrideRecipient)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.Amount) > 0 {
-			i -= len(x.Amount)
-			copy(dAtA[i:], x.Amount)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Amount)))
+		if len(x.RequestId) > 0 {
+			i -= len(x.RequestId)
+			copy(dAtA[i:], x.RequestId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
 			i--
 			dAtA[i] = 0x12
 		}
-		if len(x.Creator) > 0 {
-			i -= len(x.Creator)
-			copy(dAtA[i:], x.Creator)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -29695,7 +32657,7 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeMint)
+		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperation)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -29727,15 +32689,15 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMint: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperation: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMint: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperation: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -29763,11 +32725,11 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Creator = string(dAtA[iNdEx:postIndex])
+				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -29795,11 +32757,11 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Amount = string(dAtA[iNdEx:postIndex])
+				x.RequestId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OverrideRecipient", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -29827,11 +32789,11 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.DestinationAddress = string(dAtA[iNdEx:postIndex])
+				x.OverrideRecipient = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 4:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OverrideWrappedContract", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -29859,11 +32821,11 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ChainId = string(dAtA[iNdEx:postIndex])
+				x.OverrideWrappedContract = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 5:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DestinationBridgeAddress", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -29891,7 +32853,7 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.DestinationBridgeAddress = string(dAtA[iNdEx:postIndex])
+				x.Reason = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -29929,30 +32891,24 @@ func (x *fastReflection_MsgRequestBridgeMint) ProtoMethods() *protoiface.Methods
 }
 
 var (
-	md_MsgRequestBridgeMintResponse                protoreflect.MessageDescriptor
-	fd_MsgRequestBridgeMintResponse_request_id     protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeMintResponse_epoch_index    protoreflect.FieldDescriptor
-	fd_MsgRequestBridgeMintResponse_bls_request_id protoreflect.FieldDescriptor
+	md_MsgGovernanceCancelBridgeOperationResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRequestBridgeMintResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRequestBridgeMintResponse")
-	fd_MsgRequestBridgeMintResponse_request_id = md_MsgRequestBridgeMintResponse.Fields().ByName("request_id")
-	fd_MsgRequestBridgeMintResponse_epoch_index = md_MsgRequestBridgeMintResponse.Fields().ByName("epoch_index")
-	fd_MsgRequestBridgeMintResponse_bls_request_id = md_MsgRequestBridgeMintResponse.Fields().ByName("bls_request_id")
+	md_MsgGovernanceCancelBridgeOperationResponse = File_inference_inference_tx_proto.Messages().ByName("MsgGovernanceCancelBridgeOperationResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRequestBridgeMintResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgGovernanceCancelBridgeOperationResponse)(nil)
 
-type fastReflection_MsgRequestBridgeMintResponse MsgRequestBridgeMintResponse
+type fastReflection_MsgGovernanceCancelBridgeOperationResponse MsgGovernanceCancelBridgeOperationResponse
 
-func (x *MsgRequestBridgeMintResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeMintResponse)(x)
+func (x *MsgGovernanceCancelBridgeOperationResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgGovernanceCancelBridgeOperationResponse)(x)
 }
 
-func (x *MsgRequestBridgeMintResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[55]
+func (x *MsgGovernanceCancelBridgeOperationResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[61]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -29963,43 +32919,43 @@ func (x *MsgRequestBridgeMintResponse) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRequestBridgeMintResponse_messageType fastReflection_MsgRequestBridgeMintResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRequestBridgeMintResponse_messageType{}
+var _fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType{}
 
-type fastReflection_MsgRequestBridgeMintResponse_messageType struct{}
+type fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType struct{}
 
-func (x fastReflection_MsgRequestBridgeMintResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRequestBridgeMintResponse)(nil)
+func (x fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgGovernanceCancelBridgeOperationResponse)(nil)
 }
-func (x fastReflection_MsgRequestBridgeMintResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeMintResponse)
+func (x fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgGovernanceCancelBridgeOperationResponse)
 }
-func (x fastReflection_MsgRequestBridgeMintResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeMintResponse
+func (x fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgGovernanceCancelBridgeOperationResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRequestBridgeMintResponse
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgGovernanceCancelBridgeOperationResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRequestBridgeMintResponse_messageType
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRequestBridgeMintResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRequestBridgeMintResponse)
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgGovernanceCancelBridgeOperationResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRequestBridgeMintResponse)(x)
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgGovernanceCancelBridgeOperationResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -30007,25 +32963,7 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.RequestId != "" {
-		value := protoreflect.ValueOfString(x.RequestId)
-		if !f(fd_MsgRequestBridgeMintResponse_request_id, value) {
-			return
-		}
-	}
-	if x.EpochIndex != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EpochIndex)
-		if !f(fd_MsgRequestBridgeMintResponse_epoch_index, value) {
-			return
-		}
-	}
-	if x.BlsRequestId != "" {
-		value := protoreflect.ValueOfString(x.BlsRequestId)
-		if !f(fd_MsgRequestBridgeMintResponse_bls_request_id, value) {
-			return
-		}
-	}
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -30039,19 +32977,13 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
-		return x.RequestId != ""
-	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
-		return x.EpochIndex != uint64(0)
-	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
-		return x.BlsRequestId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30061,19 +32993,13 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
-		x.RequestId = ""
-	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
-		x.EpochIndex = uint64(0)
-	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
-		x.BlsRequestId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30083,22 +33009,13 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
-		value := x.RequestId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
-		value := x.EpochIndex
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
-		value := x.BlsRequestId
-		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -30112,19 +33029,13 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
-		x.RequestId = value.Interface().(string)
-	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
-		x.EpochIndex = value.Uint()
-	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
-		x.BlsRequestId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30138,48 +33049,36 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMintResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
-		panic(fmt.Errorf("field request_id of message inference.inference.MsgRequestBridgeMintResponse is not mutable"))
-	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
-		panic(fmt.Errorf("field epoch_index of message inference.inference.MsgRequestBridgeMintResponse is not mutable"))
-	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
-		panic(fmt.Errorf("field bls_request_id of message inference.inference.MsgRequestBridgeMintResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRequestBridgeMintResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRequestBridgeMintResponse.request_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRequestBridgeMintResponse.epoch_index":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgRequestBridgeMintResponse.bls_request_id":
-		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRequestBridgeMintResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRequestBridgeMintResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRequestBridgeMintResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRequestBridgeMintResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgGovernanceCancelBridgeOperationResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -30187,7 +33086,7 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRequestBridgeMintResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -30198,7 +33097,7 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRequestBridgeMintResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -30210,7 +33109,7 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRequestBridgeMintResponse) IsValid() bool {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -30220,9 +33119,9 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRequestBridgeMintResponse)
+		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperationResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30234,17 +33133,6 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface
 		var n int
 		var l int
 		_ = l
-		l = len(x.RequestId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.EpochIndex != 0 {
-			n += 1 + runtime.Sov(uint64(x.EpochIndex))
-		}
-		l = len(x.BlsRequestId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -30255,7 +33143,7 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeMintResponse)
+		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperationResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30274,25 +33162,6 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.BlsRequestId) > 0 {
-			i -= len(x.BlsRequestId)
-			copy(dAtA[i:], x.BlsRequestId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BlsRequestId)))
-			i--
-			dAtA[i] = 0x1a
-		}
-		if x.EpochIndex != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EpochIndex))
-			i--
-			dAtA[i] = 0x10
-		}
-		if len(x.RequestId) > 0 {
-			i -= len(x.RequestId)
-			copy(dAtA[i:], x.RequestId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
-			i--
-			dAtA[i] = 0xa
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -30304,7 +33173,7 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRequestBridgeMintResponse)
+		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperationResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30336,95 +33205,12 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMintResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperationResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRequestBridgeMintResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RequestId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-				}
-				x.EpochIndex = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EpochIndex |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BlsRequestId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.BlsRequestId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -30461,28 +33247,28 @@ func (x *fastReflection_MsgRequestBridgeMintResponse) ProtoMethods() *protoiface
 }
 
 var (
-	md_MsgCancelBridgeOperation            protoreflect.MessageDescriptor
-	fd_MsgCancelBridgeOperation_creator    protoreflect.FieldDescriptor
-	fd_MsgCancelBridgeOperation_request_id protoreflect.FieldDescriptor
+	md_MsgRegisterWrappedTokenContract           protoreflect.MessageDescriptor
+	fd_MsgRegisterWrappedTokenContract_authority protoreflect.FieldDescriptor
+	fd_MsgRegisterWrappedTokenContract_code_id   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgCancelBridgeOperation = File_inference_inference_tx_proto.Messages().ByName("MsgCancelBridgeOperation")
-	fd_MsgCancelBridgeOperation_creator = md_MsgCancelBridgeOperation.Fields().ByName("creator")
-	fd_MsgCancelBridgeOperation_request_id = md_MsgCancelBridgeOperation.Fields().ByName("request_id")
+	md_MsgRegisterWrappedTokenContract = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterWrappedTokenContract")
+	fd_MsgRegisterWrappedTokenContract_authority = md_MsgRegisterWrappedTokenContract.Fields().ByName("authority")
+	fd_MsgRegisterWrappedTokenContract_code_id = md_MsgRegisterWrappedTokenContract.Fields().ByName("code_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgCancelBridgeOperation)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterWrappedTokenContract)(nil)
 
-type fastReflection_MsgCancelBridgeOperation MsgCancelBridgeOperation
+type fastReflection_MsgRegisterWrappedTokenContract MsgRegisterWrappedTokenContract
 
-func (x *MsgCancelBridgeOperation) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgCancelBridgeOperation)(x)
+func (x *MsgRegisterWrappedTokenContract) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterWrappedTokenContract)(x)
 }
 
-func (x *MsgCancelBridgeOperation) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[56]
+func (x *MsgRegisterWrappedTokenContract) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[62]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -30493,43 +33279,43 @@ func (x *MsgCancelBridgeOperation) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgCancelBridgeOperation_messageType fastReflection_MsgCancelBridgeOperation_messageType
-var _ protoreflect.MessageType = fastReflection_MsgCancelBridgeOperation_messageType{}
+var _fastReflection_MsgRegisterWrappedTokenContract_messageType fastReflection_MsgRegisterWrappedTokenContract_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterWrappedTokenContract_messageType{}
 
-type fastReflection_MsgCancelBridgeOperation_messageType struct{}
+type fastReflection_MsgRegisterWrappedTokenContract_messageType struct{}
 
-func (x fastReflection_MsgCancelBridgeOperation_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgCancelBridgeOperation)(nil)
+func (x fastReflection_MsgRegisterWrappedTokenContract_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterWrappedTokenContract)(nil)
 }
-func (x fastReflection_MsgCancelBridgeOperation_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgCancelBridgeOperation)
+func (x fastReflection_MsgRegisterWrappedTokenContract_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterWrappedTokenContract)
 }
-func (x fastReflection_MsgCancelBridgeOperation_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCancelBridgeOperation
+func (x fastReflection_MsgRegisterWrappedTokenContract_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterWrappedTokenContract
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgCancelBridgeOperation) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCancelBridgeOperation
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterWrappedTokenContract
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgCancelBridgeOperation) Type() protoreflect.MessageType {
-	return _fastReflection_MsgCancelBridgeOperation_messageType
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterWrappedTokenContract_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgCancelBridgeOperation) New() protoreflect.Message {
-	return new(fastReflection_MsgCancelBridgeOperation)
+func (x *fastReflection_MsgRegisterWrappedTokenContract) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterWrappedTokenContract)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgCancelBridgeOperation) Interface() protoreflect.ProtoMessage {
-	return (*MsgCancelBridgeOperation)(x)
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterWrappedTokenContract)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -30537,16 +33323,16 @@ func (x *fastReflection_MsgCancelBridgeOperation) Interface() protoreflect.Proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgCancelBridgeOperation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Creator != "" {
-		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgCancelBridgeOperation_creator, value) {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgRegisterWrappedTokenContract_authority, value) {
 			return
 		}
 	}
-	if x.RequestId != "" {
-		value := protoreflect.ValueOfString(x.RequestId)
-		if !f(fd_MsgCancelBridgeOperation_request_id, value) {
+	if x.CodeId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.CodeId)
+		if !f(fd_MsgRegisterWrappedTokenContract_code_id, value) {
 			return
 		}
 	}
@@ -30563,17 +33349,17 @@ func (x *fastReflection_MsgCancelBridgeOperation) Range(f func(protoreflect.Fiel
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgCancelBridgeOperation) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgCancelBridgeOperation.creator":
-		return x.Creator != ""
-	case "inference.inference.MsgCancelBridgeOperation.request_id":
-		return x.RequestId != ""
+	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
+		return x.CodeId != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30583,17 +33369,17 @@ func (x *fastReflection_MsgCancelBridgeOperation) Has(fd protoreflect.FieldDescr
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperation) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCancelBridgeOperation.creator":
-		x.Creator = ""
-	case "inference.inference.MsgCancelBridgeOperation.request_id":
-		x.RequestId = ""
+	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+		x.Authority = ""
+	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
+		x.CodeId = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30603,19 +33389,19 @@ func (x *fastReflection_MsgCancelBridgeOperation) Clear(fd protoreflect.FieldDes
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgCancelBridgeOperation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgCancelBridgeOperation.creator":
-		value := x.Creator
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgCancelBridgeOperation.request_id":
-		value := x.RequestId
+	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+		value := x.Authority
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
+		value := x.CodeId
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -30629,17 +33415,17 @@ func (x *fastReflection_MsgCancelBridgeOperation) Get(descriptor protoreflect.Fi
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCancelBridgeOperation.creator":
-		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgCancelBridgeOperation.request_id":
-		x.RequestId = value.Interface().(string)
+	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
+		x.CodeId = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -30653,44 +33439,44 @@ func (x *fastReflection_MsgCancelBridgeOperation) Set(fd protoreflect.FieldDescr
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCancelBridgeOperation.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgCancelBridgeOperation is not mutable"))
-	case "inference.inference.MsgCancelBridgeOperation.request_id":
-		panic(fmt.Errorf("field request_id of message inference.inference.MsgCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterWrappedTokenContract is not mutable"))
+	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
+		panic(fmt.Errorf("field code_id of message inference.inference.MsgRegisterWrappedTokenContract is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgCancelBridgeOperation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCancelBridgeOperation.creator":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgCancelBridgeOperation.request_id":
+	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgCancelBridgeOperation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCancelBridgeOperation", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterWrappedTokenContract", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -30698,7 +33484,7 @@ func (x *fastReflection_MsgCancelBridgeOperation) WhichOneof(d protoreflect.Oneo
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgCancelBridgeOperation) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -30709,7 +33495,7 @@ func (x *fastReflection_MsgCancelBridgeOperation) GetUnknown() protoreflect.RawF
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperation) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -30721,7 +33507,7 @@ func (x *fastReflection_MsgCancelBridgeOperation) SetUnknown(fields protoreflect
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgCancelBridgeOperation) IsValid() bool {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) IsValid() bool {
 	return x != nil
 }
 
@@ -30731,9 +33517,9 @@ func (x *fastReflection_MsgCancelBridgeOperation) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgCancelBridgeOperation)
+		x := input.Message.Interface().(*MsgRegisterWrappedTokenContract)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30745,13 +33531,12 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 		var n int
 		var l int
 		_ = l
-		l = len(x.Creator)
+		l = len(x.Authority)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.RequestId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.CodeId != 0 {
+			n += 1 + runtime.Sov(uint64(x.CodeId))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -30763,7 +33548,7 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCancelBridgeOperation)
+		x := input.Message.Interface().(*MsgRegisterWrappedTokenContract)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30782,17 +33567,15 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.RequestId) > 0 {
-			i -= len(x.RequestId)
-			copy(dAtA[i:], x.RequestId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
+		if x.CodeId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.CodeId))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if len(x.Creator) > 0 {
-			i -= len(x.Creator)
-			copy(dAtA[i:], x.Creator)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -30807,7 +33590,7 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCancelBridgeOperation)
+		x := input.Message.Interface().(*MsgRegisterWrappedTokenContract)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -30839,15 +33622,15 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperation: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContract: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperation: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContract: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -30875,13 +33658,13 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Creator = string(dAtA[iNdEx:postIndex])
+				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
 				}
-				var stringLen uint64
+				x.CodeId = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -30891,24 +33674,11 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.CodeId |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RequestId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -30945,24 +33715,24 @@ func (x *fastReflection_MsgCancelBridgeOperation) ProtoMethods() *protoiface.Met
 }
 
 var (
-	md_MsgCancelBridgeOperationResponse protoreflect.MessageDescriptor
+	md_MsgRegisterWrappedTokenContractResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgCancelBridgeOperationResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCancelBridgeOperationResponse")
+	md_MsgRegisterWrappedTokenContractResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterWrappedTokenContractResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgCancelBridgeOperationResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterWrappedTokenContractResponse)(nil)
 
-type fastReflection_MsgCancelBridgeOperationResponse MsgCancelBridgeOperationResponse
+type fastReflection_MsgRegisterWrappedTokenContractResponse MsgRegisterWrappedTokenContractResponse
 
-func (x *MsgCancelBridgeOperationResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgCancelBridgeOperationResponse)(x)
+func (x *MsgRegisterWrappedTokenContractResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterWrappedTokenContractResponse)(x)
 }
 
-func (x *MsgCancelBridgeOperationResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[57]
+func (x *MsgRegisterWrappedTokenContractResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[63]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -30973,43 +33743,43 @@ func (x *MsgCancelBridgeOperationResponse) slowProtoReflect() protoreflect.Messa
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgCancelBridgeOperationResponse_messageType fastReflection_MsgCancelBridgeOperationResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgCancelBridgeOperationResponse_messageType{}
+var _fastReflection_MsgRegisterWrappedTokenContractResponse_messageType fastReflection_MsgRegisterWrappedTokenContractResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterWrappedTokenContractResponse_messageType{}
 
-type fastReflection_MsgCancelBridgeOperationResponse_messageType struct{}
+type fastReflection_MsgRegisterWrappedTokenContractResponse_messageType struct{}
 
-func (x fastReflection_MsgCancelBridgeOperationResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgCancelBridgeOperationResponse)(nil)
+func (x fastReflection_MsgRegisterWrappedTokenContractResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterWrappedTokenContractResponse)(nil)
 }
-func (x fastReflection_MsgCancelBridgeOperationResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgCancelBridgeOperationResponse)
+func (x fastReflection_MsgRegisterWrappedTokenContractResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterWrappedTokenContractResponse)
 }
-func (x fastReflection_MsgCancelBridgeOperationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCancelBridgeOperationResponse
+func (x fastReflection_MsgRegisterWrappedTokenContractResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterWrappedTokenContractResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCancelBridgeOperationResponse
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterWrappedTokenContractResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgCancelBridgeOperationResponse_messageType
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterWrappedTokenContractResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgCancelBridgeOperationResponse)
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterWrappedTokenContractResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgCancelBridgeOperationResponse)(x)
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterWrappedTokenContractResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -31017,7 +33787,7 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) Interface() protorefle
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -31031,13 +33801,13 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) Range(f func(protorefl
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31047,13 +33817,13 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) Has(fd protoreflect.Fi
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31063,13 +33833,13 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) Clear(fd protoreflect.
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -31083,13 +33853,13 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) Get(descriptor protore
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31103,36 +33873,36 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) Set(fd protoreflect.Fi
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCancelBridgeOperationResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterWrappedTokenContractResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -31140,7 +33910,7 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) WhichOneof(d protorefl
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -31151,7 +33921,7 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) GetUnknown() protorefl
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -31163,7 +33933,7 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) SetUnknown(fields prot
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) IsValid() bool {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -31173,9 +33943,9 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgCancelBridgeOperationResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgCancelBridgeOperationResponse)
+		x := input.Message.Interface().(*MsgRegisterWrappedTokenContractResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31197,7 +33967,7 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) ProtoMethods() *protoi
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCancelBridgeOperationResponse)
+		x := input.Message.Interface().(*MsgRegisterWrappedTokenContractResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31227,7 +33997,7 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) ProtoMethods() *protoi
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCancelBridgeOperationResponse)
+		x := input.Message.Interface().(*MsgRegisterWrappedTokenContractResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31259,10 +34029,10 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) ProtoMethods() *protoi
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperationResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContractResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelBridgeOperationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContractResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -31301,34 +34071,32 @@ func (x *fastReflection_MsgCancelBridgeOperationResponse) ProtoMethods() *protoi
 }
 
 var (
-	md_MsgGovernanceCancelBridgeOperation                           protoreflect.MessageDescriptor
-	fd_MsgGovernanceCancelBridgeOperation_authority                 protoreflect.FieldDescriptor
-	fd_MsgGovernanceCancelBridgeOperation_request_id                protoreflect.FieldDescriptor
-	fd_MsgGovernanceCancelBridgeOperation_override_recipient        protoreflect.FieldDescriptor
-	fd_MsgGovernanceCancelBridgeOperation_override_wrapped_contract protoreflect.FieldDescriptor
-	fd_MsgGovernanceCancelBridgeOperation_reason                    protoreflect.FieldDescriptor
+	md_MsgMigrateAllWrappedTokens                  protoreflect.MessageDescriptor
+	fd_MsgMigrateAllWrappedTokens_authority        protoreflect.FieldDescriptor
+	fd_MsgMigrateAllWrappedTokens_new_code_id      protoreflect.FieldDescriptor
+	fd_MsgMigrateAllWrappedTokens_migrate_msg_json protoreflect.FieldDescriptor
+	fd_MsgMigrateAllWrappedTokens_limit            protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgGovernanceCancelBridgeOperation = File_inference_inference_tx_proto.Messages().ByName("MsgGovernanceCancelBridgeOperation")
-	fd_MsgGovernanceCancelBridgeOperation_authority = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("authority")
-	fd_MsgGovernanceCancelBridgeOperation_request_id = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("request_id")
-	fd_MsgGovernanceCancelBridgeOperation_override_recipient = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("override_recipient")
-	fd_MsgGovernanceCancelBridgeOperation_override_wrapped_contract = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("override_wrapped_contract")
-	fd_MsgGovernanceCancelBridgeOperation_reason = md_MsgGovernanceCancelBridgeOperation.Fields().ByName("reason")
+	md_MsgMigrateAllWrappedTokens = File_inference_inference_tx_proto.Messages().ByName("MsgMigrateAllWrappedTokens")
+	fd_MsgMigrateAllWrappedTokens_authority = md_MsgMigrateAllWrappedTokens.Fields().ByName("authority")
+	fd_MsgMigrateAllWrappedTokens_new_code_id = md_MsgMigrateAllWrappedTokens.Fields().ByName("new_code_id")
+	fd_MsgMigrateAllWrappedTokens_migrate_msg_json = md_MsgMigrateAllWrappedTokens.Fields().ByName("migrate_msg_json")
+	fd_MsgMigrateAllWrappedTokens_limit = md_MsgMigrateAllWrappedTokens.Fields().ByName("limit")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgGovernanceCancelBridgeOperation)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgMigrateAllWrappedTokens)(nil)
 
-type fastReflection_MsgGovernanceCancelBridgeOperation MsgGovernanceCancelBridgeOperation
+type fastReflection_MsgMigrateAllWrappedTokens MsgMigrateAllWrappedTokens
 
-func (x *MsgGovernanceCancelBridgeOperation) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgGovernanceCancelBridgeOperation)(x)
+func (x *MsgMigrateAllWrappedTokens) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgMigrateAllWrappedTokens)(x)
 }
 
-func (x *MsgGovernanceCancelBridgeOperation) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[58]
+func (x *MsgMigrateAllWrappedTokens) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[64]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -31339,43 +34107,43 @@ func (x *MsgGovernanceCancelBridgeOperation) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgGovernanceCancelBridgeOperation_messageType fastReflection_MsgGovernanceCancelBridgeOperation_messageType
-var _ protoreflect.MessageType = fastReflection_MsgGovernanceCancelBridgeOperation_messageType{}
+var _fastReflection_MsgMigrateAllWrappedTokens_messageType fastReflection_MsgMigrateAllWrappedTokens_messageType
+var _ protoreflect.MessageType = fastReflection_MsgMigrateAllWrappedTokens_messageType{}
 
-type fastReflection_MsgGovernanceCancelBridgeOperation_messageType struct{}
+type fastReflection_MsgMigrateAllWrappedTokens_messageType struct{}
 
-func (x fastReflection_MsgGovernanceCancelBridgeOperation_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgGovernanceCancelBridgeOperation)(nil)
+func (x fastReflection_MsgMigrateAllWrappedTokens_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgMigrateAllWrappedTokens)(nil)
 }
-func (x fastReflection_MsgGovernanceCancelBridgeOperation_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgGovernanceCancelBridgeOperation)
+func (x fastReflection_MsgMigrateAllWrappedTokens_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgMigrateAllWrappedTokens)
 }
-func (x fastReflection_MsgGovernanceCancelBridgeOperation_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgGovernanceCancelBridgeOperation
+func (x fastReflection_MsgMigrateAllWrappedTokens_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMigrateAllWrappedTokens
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgGovernanceCancelBridgeOperation
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMigrateAllWrappedTokens
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Type() protoreflect.MessageType {
-	return _fastReflection_MsgGovernanceCancelBridgeOperation_messageType
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Type() protoreflect.MessageType {
+	return _fastReflection_MsgMigrateAllWrappedTokens_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) New() protoreflect.Message {
-	return new(fastReflection_MsgGovernanceCancelBridgeOperation)
+func (x *fastReflection_MsgMigrateAllWrappedTokens) New() protoreflect.Message {
+	return new(fastReflection_MsgMigrateAllWrappedTokens)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Interface() protoreflect.ProtoMessage {
-	return (*MsgGovernanceCancelBridgeOperation)(x)
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Interface() protoreflect.ProtoMessage {
+	return (*MsgMigrateAllWrappedTokens)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -31383,34 +34151,28 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgGovernanceCancelBridgeOperation_authority, value) {
-			return
-		}
-	}
-	if x.RequestId != "" {
-		value := protoreflect.ValueOfString(x.RequestId)
-		if !f(fd_MsgGovernanceCancelBridgeOperation_request_id, value) {
+		if !f(fd_MsgMigrateAllWrappedTokens_authority, value) {
 			return
 		}
 	}
-	if x.OverrideRecipient != "" {
-		value := protoreflect.ValueOfString(x.OverrideRecipient)
-		if !f(fd_MsgGovernanceCancelBridgeOperation_override_recipient, value) {
+	if x.NewCodeId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.NewCodeId)
+		if !f(fd_MsgMigrateAllWrappedTokens_new_code_id, value) {
 			return
 		}
 	}
-	if x.OverrideWrappedContract != "" {
-		value := protoreflect.ValueOfString(x.OverrideWrappedContract)
-		if !f(fd_MsgGovernanceCancelBridgeOperation_override_wrapped_contract, value) {
+	if x.MigrateMsgJson != "" {
+		value := protoreflect.ValueOfString(x.MigrateMsgJson)
+		if !f(fd_MsgMigrateAllWrappedTokens_migrate_msg_json, value) {
 			return
 		}
 	}
-	if x.Reason != "" {
-		value := protoreflect.ValueOfString(x.Reason)
-		if !f(fd_MsgGovernanceCancelBridgeOperation_reason, value) {
+	if x.Limit != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Limit)
+		if !f(fd_MsgMigrateAllWrappedTokens_limit, value) {
 			return
 		}
 	}
@@ -31427,23 +34189,21 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
-		return x.RequestId != ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
-		return x.OverrideRecipient != ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
-		return x.OverrideWrappedContract != ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
-		return x.Reason != ""
+	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
+		return x.NewCodeId != uint64(0)
+	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
+		return x.MigrateMsgJson != ""
+	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+		return x.Limit != uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31453,23 +34213,21 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
 		x.Authority = ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
-		x.RequestId = ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
-		x.OverrideRecipient = ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
-		x.OverrideWrappedContract = ""
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
-		x.Reason = ""
+	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
+		x.NewCodeId = uint64(0)
+	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
+		x.MigrateMsgJson = ""
+	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+		x.Limit = uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31479,28 +34237,25 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
-		value := x.RequestId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
-		value := x.OverrideRecipient
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
-		value := x.OverrideWrappedContract
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
-		value := x.Reason
+	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
+		value := x.NewCodeId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
+		value := x.MigrateMsgJson
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+		value := x.Limit
+		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -31514,23 +34269,21 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
+	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
-		x.RequestId = value.Interface().(string)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
-		x.OverrideRecipient = value.Interface().(string)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
-		x.OverrideWrappedContract = value.Interface().(string)
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
-		x.Reason = value.Interface().(string)
+	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
+		x.NewCodeId = value.Uint()
+	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
+		x.MigrateMsgJson = value.Interface().(string)
+	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+		x.Limit = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -31544,56 +34297,52 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
-		panic(fmt.Errorf("field request_id of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
-		panic(fmt.Errorf("field override_recipient of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
-		panic(fmt.Errorf("field override_wrapped_contract of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
-		panic(fmt.Errorf("field reason of message inference.inference.MsgGovernanceCancelBridgeOperation is not mutable"))
+	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
+	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
+		panic(fmt.Errorf("field new_code_id of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
+	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
+		panic(fmt.Errorf("field migrate_msg_json of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
+	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+		panic(fmt.Errorf("field limit of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.authority":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.request_id":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_recipient":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.override_wrapped_contract":
+	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgGovernanceCancelBridgeOperation.reason":
+	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperation"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperation does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgGovernanceCancelBridgeOperation", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMigrateAllWrappedTokens", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -31601,7 +34350,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -31612,7 +34361,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -31624,7 +34373,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) IsValid() bool {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) IsValid() bool {
 	return x != nil
 }
 
@@ -31634,9 +34383,9 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperation)
+		x := input.Message.Interface().(*MsgMigrateAllWrappedTokens)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31652,21 +34401,15 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.RequestId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.OverrideRecipient)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.NewCodeId != 0 {
+			n += 1 + runtime.Sov(uint64(x.NewCodeId))
 		}
-		l = len(x.OverrideWrappedContract)
+		l = len(x.MigrateMsgJson)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Reason)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Limit != 0 {
+			n += 1 + runtime.Sov(uint64(x.Limit))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -31678,7 +34421,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperation)
+		x := input.Message.Interface().(*MsgMigrateAllWrappedTokens)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31697,33 +34440,22 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.Reason) > 0 {
-			i -= len(x.Reason)
-			copy(dAtA[i:], x.Reason)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Reason)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if len(x.OverrideWrappedContract) > 0 {
-			i -= len(x.OverrideWrappedContract)
-			copy(dAtA[i:], x.OverrideWrappedContract)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OverrideWrappedContract)))
+		if x.Limit != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Limit))
 			i--
-			dAtA[i] = 0x22
+			dAtA[i] = 0x20
 		}
-		if len(x.OverrideRecipient) > 0 {
-			i -= len(x.OverrideRecipient)
-			copy(dAtA[i:], x.OverrideRecipient)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.OverrideRecipient)))
+		if len(x.MigrateMsgJson) > 0 {
+			i -= len(x.MigrateMsgJson)
+			copy(dAtA[i:], x.MigrateMsgJson)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MigrateMsgJson)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.RequestId) > 0 {
-			i -= len(x.RequestId)
-			copy(dAtA[i:], x.RequestId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RequestId)))
+		if x.NewCodeId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.NewCodeId))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
 		if len(x.Authority) > 0 {
 			i -= len(x.Authority)
@@ -31743,7 +34475,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperation)
+		x := input.Message.Interface().(*MsgMigrateAllWrappedTokens)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -31775,10 +34507,10 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperation: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokens: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperation: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokens: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -31814,42 +34546,10 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
-				}
-				var stringLen uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RequestId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OverrideRecipient", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewCodeId", wireType)
 				}
-				var stringLen uint64
+				x.NewCodeId = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -31859,27 +34559,14 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.NewCodeId |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.OverrideRecipient = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
-			case 4:
+			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field OverrideWrappedContract", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MigrateMsgJson", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -31907,13 +34594,13 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.OverrideWrappedContract = string(dAtA[iNdEx:postIndex])
+				x.MigrateMsgJson = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
+			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
 				}
-				var stringLen uint64
+				x.Limit = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -31923,24 +34610,11 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.Limit |= uint32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Reason = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -31977,24 +34651,26 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperation) ProtoMethods() *prot
 }
 
 var (
-	md_MsgGovernanceCancelBridgeOperationResponse protoreflect.MessageDescriptor
+	md_MsgMigrateAllWrappedTokensResponse           protoreflect.MessageDescriptor
+	fd_MsgMigrateAllWrappedTokensResponse_attempted protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgGovernanceCancelBridgeOperationResponse = File_inference_inference_tx_proto.Messages().ByName("MsgGovernanceCancelBridgeOperationResponse")
+	md_MsgMigrateAllWrappedTokensResponse = File_inference_inference_tx_proto.Messages().ByName("MsgMigrateAllWrappedTokensResponse")
+	fd_MsgMigrateAllWrappedTokensResponse_attempted = md_MsgMigrateAllWrappedTokensResponse.Fields().ByName("attempted")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgGovernanceCancelBridgeOperationResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgMigrateAllWrappedTokensResponse)(nil)
 
-type fastReflection_MsgGovernanceCancelBridgeOperationResponse MsgGovernanceCancelBridgeOperationResponse
+type fastReflection_MsgMigrateAllWrappedTokensResponse MsgMigrateAllWrappedTokensResponse
 
-func (x *MsgGovernanceCancelBridgeOperationResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgGovernanceCancelBridgeOperationResponse)(x)
+func (x *MsgMigrateAllWrappedTokensResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgMigrateAllWrappedTokensResponse)(x)
 }
 
-func (x *MsgGovernanceCancelBridgeOperationResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[59]
+func (x *MsgMigrateAllWrappedTokensResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[65]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -32005,43 +34681,43 @@ func (x *MsgGovernanceCancelBridgeOperationResponse) slowProtoReflect() protoref
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType{}
+var _fastReflection_MsgMigrateAllWrappedTokensResponse_messageType fastReflection_MsgMigrateAllWrappedTokensResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgMigrateAllWrappedTokensResponse_messageType{}
 
-type fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType struct{}
+type fastReflection_MsgMigrateAllWrappedTokensResponse_messageType struct{}
 
-func (x fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgGovernanceCancelBridgeOperationResponse)(nil)
+func (x fastReflection_MsgMigrateAllWrappedTokensResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgMigrateAllWrappedTokensResponse)(nil)
 }
-func (x fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgGovernanceCancelBridgeOperationResponse)
+func (x fastReflection_MsgMigrateAllWrappedTokensResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgMigrateAllWrappedTokensResponse)
 }
-func (x fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgGovernanceCancelBridgeOperationResponse
+func (x fastReflection_MsgMigrateAllWrappedTokensResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMigrateAllWrappedTokensResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgGovernanceCancelBridgeOperationResponse
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgMigrateAllWrappedTokensResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgGovernanceCancelBridgeOperationResponse_messageType
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgMigrateAllWrappedTokensResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgGovernanceCancelBridgeOperationResponse)
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgMigrateAllWrappedTokensResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgGovernanceCancelBridgeOperationResponse)(x)
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgMigrateAllWrappedTokensResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -32049,7 +34725,13 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Interface()
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Attempted != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Attempted)
+		if !f(fd_MsgMigrateAllWrappedTokensResponse_attempted, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -32063,13 +34745,15 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Range(f func
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
+		return x.Attempted != uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32079,13 +34763,15 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Has(fd proto
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
+		x.Attempted = uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32095,13 +34781,16 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Clear(fd pro
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
+		value := x.Attempted
+		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -32115,13 +34804,15 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Get(descript
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
+		x.Attempted = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32135,36 +34826,40 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Set(fd proto
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
+		panic(fmt.Errorf("field attempted of message inference.inference.MsgMigrateAllWrappedTokensResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
+		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgGovernanceCancelBridgeOperationResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgGovernanceCancelBridgeOperationResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgGovernanceCancelBridgeOperationResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMigrateAllWrappedTokensResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -32172,7 +34867,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) WhichOneof(d
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -32183,7 +34878,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) GetUnknown()
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -32195,7 +34890,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) SetUnknown(f
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) IsValid() bool {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -32205,9 +34900,9 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) IsValid() bo
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperationResponse)
+		x := input.Message.Interface().(*MsgMigrateAllWrappedTokensResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32219,6 +34914,9 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods
 		var n int
 		var l int
 		_ = l
+		if x.Attempted != 0 {
+			n += 1 + runtime.Sov(uint64(x.Attempted))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -32229,7 +34927,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperationResponse)
+		x := input.Message.Interface().(*MsgMigrateAllWrappedTokensResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32248,6 +34946,11 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.Attempted != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Attempted))
+			i--
+			dAtA[i] = 0x8
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -32259,7 +34962,7 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgGovernanceCancelBridgeOperationResponse)
+		x := input.Message.Interface().(*MsgMigrateAllWrappedTokensResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32291,12 +34994,31 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperationResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokensResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgGovernanceCancelBridgeOperationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokensResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Attempted", wireType)
+				}
+				x.Attempted = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Attempted |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -32333,28 +35055,30 @@ func (x *fastReflection_MsgGovernanceCancelBridgeOperationResponse) ProtoMethods
 }
 
 var (
-	md_MsgRegisterWrappedTokenContract           protoreflect.MessageDescriptor
-	fd_MsgRegisterWrappedTokenContract_authority protoreflect.FieldDescriptor
-	fd_MsgRegisterWrappedTokenContract_code_id   protoreflect.FieldDescriptor
+	md_MsgApproveIbcTokenForTrading           protoreflect.MessageDescriptor
+	fd_MsgApproveIbcTokenForTrading_authority protoreflect.FieldDescriptor
+	fd_MsgApproveIbcTokenForTrading_chainId   protoreflect.FieldDescriptor
+	fd_MsgApproveIbcTokenForTrading_ibcDenom  protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterWrappedTokenContract = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterWrappedTokenContract")
-	fd_MsgRegisterWrappedTokenContract_authority = md_MsgRegisterWrappedTokenContract.Fields().ByName("authority")
-	fd_MsgRegisterWrappedTokenContract_code_id = md_MsgRegisterWrappedTokenContract.Fields().ByName("code_id")
+	md_MsgApproveIbcTokenForTrading = File_inference_inference_tx_proto.Messages().ByName("MsgApproveIbcTokenForTrading")
+	fd_MsgApproveIbcTokenForTrading_authority = md_MsgApproveIbcTokenForTrading.Fields().ByName("authority")
+	fd_MsgApproveIbcTokenForTrading_chainId = md_MsgApproveIbcTokenForTrading.Fields().ByName("chainId")
+	fd_MsgApproveIbcTokenForTrading_ibcDenom = md_MsgApproveIbcTokenForTrading.Fields().ByName("ibcDenom")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterWrappedTokenContract)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgApproveIbcTokenForTrading)(nil)
 
-type fastReflection_MsgRegisterWrappedTokenContract MsgRegisterWrappedTokenContract
+type fastReflection_MsgApproveIbcTokenForTrading MsgApproveIbcTokenForTrading
 
-func (x *MsgRegisterWrappedTokenContract) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterWrappedTokenContract)(x)
+func (x *MsgApproveIbcTokenForTrading) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgApproveIbcTokenForTrading)(x)
 }
 
-func (x *MsgRegisterWrappedTokenContract) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[60]
+func (x *MsgApproveIbcTokenForTrading) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[66]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -32365,43 +35089,43 @@ func (x *MsgRegisterWrappedTokenContract) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterWrappedTokenContract_messageType fastReflection_MsgRegisterWrappedTokenContract_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterWrappedTokenContract_messageType{}
+var _fastReflection_MsgApproveIbcTokenForTrading_messageType fastReflection_MsgApproveIbcTokenForTrading_messageType
+var _ protoreflect.MessageType = fastReflection_MsgApproveIbcTokenForTrading_messageType{}
 
-type fastReflection_MsgRegisterWrappedTokenContract_messageType struct{}
+type fastReflection_MsgApproveIbcTokenForTrading_messageType struct{}
 
-func (x fastReflection_MsgRegisterWrappedTokenContract_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterWrappedTokenContract)(nil)
+func (x fastReflection_MsgApproveIbcTokenForTrading_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgApproveIbcTokenForTrading)(nil)
 }
-func (x fastReflection_MsgRegisterWrappedTokenContract_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterWrappedTokenContract)
+func (x fastReflection_MsgApproveIbcTokenForTrading_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveIbcTokenForTrading)
 }
-func (x fastReflection_MsgRegisterWrappedTokenContract_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterWrappedTokenContract
+func (x fastReflection_MsgApproveIbcTokenForTrading_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveIbcTokenForTrading
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterWrappedTokenContract
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveIbcTokenForTrading
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterWrappedTokenContract_messageType
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Type() protoreflect.MessageType {
+	return _fastReflection_MsgApproveIbcTokenForTrading_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterWrappedTokenContract)
+func (x *fastReflection_MsgApproveIbcTokenForTrading) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveIbcTokenForTrading)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterWrappedTokenContract)(x)
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Interface() protoreflect.ProtoMessage {
+	return (*MsgApproveIbcTokenForTrading)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -32409,16 +35133,22 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRegisterWrappedTokenContract_authority, value) {
+		if !f(fd_MsgApproveIbcTokenForTrading_authority, value) {
 			return
 		}
 	}
-	if x.CodeId != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.CodeId)
-		if !f(fd_MsgRegisterWrappedTokenContract_code_id, value) {
+	if x.ChainId != "" {
+		value := protoreflect.ValueOfString(x.ChainId)
+		if !f(fd_MsgApproveIbcTokenForTrading_chainId, value) {
+			return
+		}
+	}
+	if x.IbcDenom != "" {
+		value := protoreflect.ValueOfString(x.IbcDenom)
+		if !f(fd_MsgApproveIbcTokenForTrading_ibcDenom, value) {
 			return
 		}
 	}
@@ -32435,17 +35165,19 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
-		return x.CodeId != uint64(0)
+	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+		return x.ChainId != ""
+	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
+		return x.IbcDenom != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32455,17 +35187,19 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
 		x.Authority = ""
-	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
-		x.CodeId = uint64(0)
+	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+		x.ChainId = ""
+	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
+		x.IbcDenom = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32475,19 +35209,22 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
-		value := x.CodeId
-		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+		value := x.ChainId
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
+		value := x.IbcDenom
+		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -32501,17 +35238,19 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
-		x.CodeId = value.Uint()
+	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+		x.ChainId = value.Interface().(string)
+	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
+		x.IbcDenom = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32525,44 +35264,48 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterWrappedTokenContract is not mutable"))
-	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
-		panic(fmt.Errorf("field code_id of message inference.inference.MsgRegisterWrappedTokenContract is not mutable"))
+	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgApproveIbcTokenForTrading is not mutable"))
+	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+		panic(fmt.Errorf("field chainId of message inference.inference.MsgApproveIbcTokenForTrading is not mutable"))
+	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
+		panic(fmt.Errorf("field ibcDenom of message inference.inference.MsgApproveIbcTokenForTrading is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterWrappedTokenContract.authority":
+	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterWrappedTokenContract.code_id":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContract"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContract does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterWrappedTokenContract", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveIbcTokenForTrading", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -32570,7 +35313,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -32581,7 +35324,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -32593,7 +35336,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) IsValid() bool {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) IsValid() bool {
 	return x != nil
 }
 
@@ -32603,9 +35346,9 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterWrappedTokenContract)
+		x := input.Message.Interface().(*MsgApproveIbcTokenForTrading)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32621,8 +35364,13 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.CodeId != 0 {
-			n += 1 + runtime.Sov(uint64(x.CodeId))
+		l = len(x.ChainId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.IbcDenom)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -32634,7 +35382,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterWrappedTokenContract)
+		x := input.Message.Interface().(*MsgApproveIbcTokenForTrading)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32653,10 +35401,19 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.CodeId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.CodeId))
+		if len(x.IbcDenom) > 0 {
+			i -= len(x.IbcDenom)
+			copy(dAtA[i:], x.IbcDenom)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.IbcDenom)))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x1a
+		}
+		if len(x.ChainId) > 0 {
+			i -= len(x.ChainId)
+			copy(dAtA[i:], x.ChainId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+			i--
+			dAtA[i] = 0x12
 		}
 		if len(x.Authority) > 0 {
 			i -= len(x.Authority)
@@ -32676,7 +35433,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterWrappedTokenContract)
+		x := input.Message.Interface().(*MsgApproveIbcTokenForTrading)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -32708,10 +35465,10 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContract: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTrading: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContract: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTrading: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -32747,10 +35504,10 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 				}
-				x.CodeId = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -32760,11 +35517,56 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.CodeId |= uint64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ChainId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 3:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.IbcDenom = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -32801,24 +35603,24 @@ func (x *fastReflection_MsgRegisterWrappedTokenContract) ProtoMethods() *protoif
 }
 
 var (
-	md_MsgRegisterWrappedTokenContractResponse protoreflect.MessageDescriptor
+	md_MsgApproveIbcTokenForTradingResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterWrappedTokenContractResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterWrappedTokenContractResponse")
+	md_MsgApproveIbcTokenForTradingResponse = File_inference_inference_tx_proto.Messages().ByName("MsgApproveIbcTokenForTradingResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterWrappedTokenContractResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgApproveIbcTokenForTradingResponse)(nil)
 
-type fastReflection_MsgRegisterWrappedTokenContractResponse MsgRegisterWrappedTokenContractResponse
+type fastReflection_MsgApproveIbcTokenForTradingResponse MsgApproveIbcTokenForTradingResponse
 
-func (x *MsgRegisterWrappedTokenContractResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterWrappedTokenContractResponse)(x)
+func (x *MsgApproveIbcTokenForTradingResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgApproveIbcTokenForTradingResponse)(x)
 }
 
-func (x *MsgRegisterWrappedTokenContractResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[61]
+func (x *MsgApproveIbcTokenForTradingResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[67]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -32829,43 +35631,43 @@ func (x *MsgRegisterWrappedTokenContractResponse) slowProtoReflect() protoreflec
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterWrappedTokenContractResponse_messageType fastReflection_MsgRegisterWrappedTokenContractResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterWrappedTokenContractResponse_messageType{}
+var _fastReflection_MsgApproveIbcTokenForTradingResponse_messageType fastReflection_MsgApproveIbcTokenForTradingResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgApproveIbcTokenForTradingResponse_messageType{}
 
-type fastReflection_MsgRegisterWrappedTokenContractResponse_messageType struct{}
+type fastReflection_MsgApproveIbcTokenForTradingResponse_messageType struct{}
 
-func (x fastReflection_MsgRegisterWrappedTokenContractResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterWrappedTokenContractResponse)(nil)
+func (x fastReflection_MsgApproveIbcTokenForTradingResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgApproveIbcTokenForTradingResponse)(nil)
 }
-func (x fastReflection_MsgRegisterWrappedTokenContractResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterWrappedTokenContractResponse)
+func (x fastReflection_MsgApproveIbcTokenForTradingResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveIbcTokenForTradingResponse)
 }
-func (x fastReflection_MsgRegisterWrappedTokenContractResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterWrappedTokenContractResponse
+func (x fastReflection_MsgApproveIbcTokenForTradingResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveIbcTokenForTradingResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterWrappedTokenContractResponse
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgApproveIbcTokenForTradingResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterWrappedTokenContractResponse_messageType
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgApproveIbcTokenForTradingResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterWrappedTokenContractResponse)
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgApproveIbcTokenForTradingResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterWrappedTokenContractResponse)(x)
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgApproveIbcTokenForTradingResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -32873,7 +35675,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Interface() pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -32887,13 +35689,13 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Range(f func(pr
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32903,13 +35705,13 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Has(fd protoref
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32919,13 +35721,13 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Clear(fd protor
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -32939,13 +35741,13 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Get(descriptor
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -32959,36 +35761,36 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Set(fd protoref
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterWrappedTokenContractResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterWrappedTokenContractResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterWrappedTokenContractResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveIbcTokenForTradingResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -32996,7 +35798,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) WhichOneof(d pr
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -33007,7 +35809,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) GetUnknown() pr
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -33019,7 +35821,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) SetUnknown(fiel
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) IsValid() bool {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -33029,9 +35831,9 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) IsValid() bool
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterWrappedTokenContractResponse)
+		x := input.Message.Interface().(*MsgApproveIbcTokenForTradingResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33053,7 +35855,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) ProtoMethods()
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterWrappedTokenContractResponse)
+		x := input.Message.Interface().(*MsgApproveIbcTokenForTradingResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33083,7 +35885,7 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) ProtoMethods()
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterWrappedTokenContractResponse)
+		x := input.Message.Interface().(*MsgApproveIbcTokenForTradingResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33115,10 +35917,10 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) ProtoMethods()
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContractResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTradingResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterWrappedTokenContractResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTradingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -33157,32 +35959,38 @@ func (x *fastReflection_MsgRegisterWrappedTokenContractResponse) ProtoMethods()
 }
 
 var (
-	md_MsgMigrateAllWrappedTokens                  protoreflect.MessageDescriptor
-	fd_MsgMigrateAllWrappedTokens_authority        protoreflect.FieldDescriptor
-	fd_MsgMigrateAllWrappedTokens_new_code_id      protoreflect.FieldDescriptor
-	fd_MsgMigrateAllWrappedTokens_migrate_msg_json protoreflect.FieldDescriptor
-	fd_MsgMigrateAllWrappedTokens_limit            protoreflect.FieldDescriptor
+	md_MsgRegisterIbcTokenMetadata           protoreflect.MessageDescriptor
+	fd_MsgRegisterIbcTokenMetadata_authority protoreflect.FieldDescriptor
+	fd_MsgRegisterIbcTokenMetadata_chainId   protoreflect.FieldDescriptor
+	fd_MsgRegisterIbcTokenMetadata_ibcDenom  protoreflect.FieldDescriptor
+	fd_MsgRegisterIbcTokenMetadata_name      protoreflect.FieldDescriptor
+	fd_MsgRegisterIbcTokenMetadata_symbol    protoreflect.FieldDescriptor
+	fd_MsgRegisterIbcTokenMetadata_decimals  protoreflect.FieldDescriptor
+	fd_MsgRegisterIbcTokenMetadata_overwrite protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgMigrateAllWrappedTokens = File_inference_inference_tx_proto.Messages().ByName("MsgMigrateAllWrappedTokens")
-	fd_MsgMigrateAllWrappedTokens_authority = md_MsgMigrateAllWrappedTokens.Fields().ByName("authority")
-	fd_MsgMigrateAllWrappedTokens_new_code_id = md_MsgMigrateAllWrappedTokens.Fields().ByName("new_code_id")
-	fd_MsgMigrateAllWrappedTokens_migrate_msg_json = md_MsgMigrateAllWrappedTokens.Fields().ByName("migrate_msg_json")
-	fd_MsgMigrateAllWrappedTokens_limit = md_MsgMigrateAllWrappedTokens.Fields().ByName("limit")
+	md_MsgRegisterIbcTokenMetadata = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterIbcTokenMetadata")
+	fd_MsgRegisterIbcTokenMetadata_authority = md_MsgRegisterIbcTokenMetadata.Fields().ByName("authority")
+	fd_MsgRegisterIbcTokenMetadata_chainId = md_MsgRegisterIbcTokenMetadata.Fields().ByName("chainId")
+	fd_MsgRegisterIbcTokenMetadata_ibcDenom = md_MsgRegisterIbcTokenMetadata.Fields().ByName("ibcDenom")
+	fd_MsgRegisterIbcTokenMetadata_name = md_MsgRegisterIbcTokenMetadata.Fields().ByName("name")
+	fd_MsgRegisterIbcTokenMetadata_symbol = md_MsgRegisterIbcTokenMetadata.Fields().ByName("symbol")
+	fd_MsgRegisterIbcTokenMetadata_decimals = md_MsgRegisterIbcTokenMetadata.Fields().ByName("decimals")
+	fd_MsgRegisterIbcTokenMetadata_overwrite = md_MsgRegisterIbcTokenMetadata.Fields().ByName("overwrite")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgMigrateAllWrappedTokens)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterIbcTokenMetadata)(nil)
 
-type fastReflection_MsgMigrateAllWrappedTokens MsgMigrateAllWrappedTokens
+type fastReflection_MsgRegisterIbcTokenMetadata MsgRegisterIbcTokenMetadata
 
-func (x *MsgMigrateAllWrappedTokens) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgMigrateAllWrappedTokens)(x)
+func (x *MsgRegisterIbcTokenMetadata) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterIbcTokenMetadata)(x)
 }
 
-func (x *MsgMigrateAllWrappedTokens) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[62]
+func (x *MsgRegisterIbcTokenMetadata) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[68]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -33193,43 +36001,43 @@ func (x *MsgMigrateAllWrappedTokens) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgMigrateAllWrappedTokens_messageType fastReflection_MsgMigrateAllWrappedTokens_messageType
-var _ protoreflect.MessageType = fastReflection_MsgMigrateAllWrappedTokens_messageType{}
+var _fastReflection_MsgRegisterIbcTokenMetadata_messageType fastReflection_MsgRegisterIbcTokenMetadata_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterIbcTokenMetadata_messageType{}
 
-type fastReflection_MsgMigrateAllWrappedTokens_messageType struct{}
+type fastReflection_MsgRegisterIbcTokenMetadata_messageType struct{}
 
-func (x fastReflection_MsgMigrateAllWrappedTokens_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgMigrateAllWrappedTokens)(nil)
+func (x fastReflection_MsgRegisterIbcTokenMetadata_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterIbcTokenMetadata)(nil)
 }
-func (x fastReflection_MsgMigrateAllWrappedTokens_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgMigrateAllWrappedTokens)
+func (x fastReflection_MsgRegisterIbcTokenMetadata_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterIbcTokenMetadata)
 }
-func (x fastReflection_MsgMigrateAllWrappedTokens_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMigrateAllWrappedTokens
+func (x fastReflection_MsgRegisterIbcTokenMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterIbcTokenMetadata
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMigrateAllWrappedTokens
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterIbcTokenMetadata
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Type() protoreflect.MessageType {
-	return _fastReflection_MsgMigrateAllWrappedTokens_messageType
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterIbcTokenMetadata_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) New() protoreflect.Message {
-	return new(fastReflection_MsgMigrateAllWrappedTokens)
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterIbcTokenMetadata)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Interface() protoreflect.ProtoMessage {
-	return (*MsgMigrateAllWrappedTokens)(x)
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterIbcTokenMetadata)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -33237,28 +36045,46 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) Interface() protoreflect.Pro
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 	if x.Authority != "" {
 		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgMigrateAllWrappedTokens_authority, value) {
+		if !f(fd_MsgRegisterIbcTokenMetadata_authority, value) {
 			return
 		}
 	}
-	if x.NewCodeId != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.NewCodeId)
-		if !f(fd_MsgMigrateAllWrappedTokens_new_code_id, value) {
+	if x.ChainId != "" {
+		value := protoreflect.ValueOfString(x.ChainId)
+		if !f(fd_MsgRegisterIbcTokenMetadata_chainId, value) {
 			return
 		}
 	}
-	if x.MigrateMsgJson != "" {
-		value := protoreflect.ValueOfString(x.MigrateMsgJson)
-		if !f(fd_MsgMigrateAllWrappedTokens_migrate_msg_json, value) {
+	if x.IbcDenom != "" {
+		value := protoreflect.ValueOfString(x.IbcDenom)
+		if !f(fd_MsgRegisterIbcTokenMetadata_ibcDenom, value) {
 			return
 		}
 	}
-	if x.Limit != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Limit)
-		if !f(fd_MsgMigrateAllWrappedTokens_limit, value) {
+	if x.Name != "" {
+		value := protoreflect.ValueOfString(x.Name)
+		if !f(fd_MsgRegisterIbcTokenMetadata_name, value) {
+			return
+		}
+	}
+	if x.Symbol != "" {
+		value := protoreflect.ValueOfString(x.Symbol)
+		if !f(fd_MsgRegisterIbcTokenMetadata_symbol, value) {
+			return
+		}
+	}
+	if x.Decimals != uint32(0) {
+		value := protoreflect.ValueOfUint32(x.Decimals)
+		if !f(fd_MsgRegisterIbcTokenMetadata_decimals, value) {
+			return
+		}
+	}
+	if x.Overwrite != false {
+		value := protoreflect.ValueOfBool(x.Overwrite)
+		if !f(fd_MsgRegisterIbcTokenMetadata_overwrite, value) {
 			return
 		}
 	}
@@ -33275,21 +36101,27 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) Range(f func(protoreflect.Fi
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
 		return x.Authority != ""
-	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
-		return x.NewCodeId != uint64(0)
-	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
-		return x.MigrateMsgJson != ""
-	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
-		return x.Limit != uint32(0)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
+		return x.ChainId != ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
+		return x.IbcDenom != ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+		return x.Name != ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+		return x.Symbol != ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
+		return x.Decimals != uint32(0)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
+		return x.Overwrite != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33299,21 +36131,27 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) Has(fd protoreflect.FieldDes
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
 		x.Authority = ""
-	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
-		x.NewCodeId = uint64(0)
-	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
-		x.MigrateMsgJson = ""
-	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
-		x.Limit = uint32(0)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
+		x.ChainId = ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
+		x.IbcDenom = ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+		x.Name = ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+		x.Symbol = ""
+	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
+		x.Decimals = uint32(0)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
+		x.Overwrite = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33323,25 +36161,34 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) Clear(fd protoreflect.FieldD
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
 		value := x.Authority
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
-		value := x.NewCodeId
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
-		value := x.MigrateMsgJson
+	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
+		value := x.ChainId
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
-		value := x.Limit
+	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
+		value := x.IbcDenom
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+		value := x.Name
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+		value := x.Symbol
+		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
+		value := x.Decimals
 		return protoreflect.ValueOfUint32(value)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
+		value := x.Overwrite
+		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -33355,21 +36202,27 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) Get(descriptor protoreflect.
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
 		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
-		x.NewCodeId = value.Uint()
-	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
-		x.MigrateMsgJson = value.Interface().(string)
-	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
-		x.Limit = uint32(value.Uint())
+	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
+		x.ChainId = value.Interface().(string)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
+		x.IbcDenom = value.Interface().(string)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+		x.Name = value.Interface().(string)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+		x.Symbol = value.Interface().(string)
+	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
+		x.Decimals = uint32(value.Uint())
+	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
+		x.Overwrite = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33383,52 +36236,64 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) Set(fd protoreflect.FieldDes
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
-	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
-		panic(fmt.Errorf("field new_code_id of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
-	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
-		panic(fmt.Errorf("field migrate_msg_json of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
-	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
-		panic(fmt.Errorf("field limit of message inference.inference.MsgMigrateAllWrappedTokens is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
+		panic(fmt.Errorf("field chainId of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
+		panic(fmt.Errorf("field ibcDenom of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+		panic(fmt.Errorf("field name of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+		panic(fmt.Errorf("field symbol of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
+		panic(fmt.Errorf("field decimals of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
+		panic(fmt.Errorf("field overwrite of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokens.authority":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgMigrateAllWrappedTokens.new_code_id":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgMigrateAllWrappedTokens.migrate_msg_json":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgMigrateAllWrappedTokens.limit":
+	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
 		return protoreflect.ValueOfUint32(uint32(0))
+	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
+		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokens"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokens does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMigrateAllWrappedTokens", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterIbcTokenMetadata", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -33436,7 +36301,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) WhichOneof(d protoreflect.On
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -33447,7 +36312,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) GetUnknown() protoreflect.Ra
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -33459,7 +36324,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) SetUnknown(fields protorefle
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) IsValid() bool {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) IsValid() bool {
 	return x != nil
 }
 
@@ -33469,9 +36334,9 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgMigrateAllWrappedTokens)
+		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadata)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33487,15 +36352,27 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.NewCodeId != 0 {
-			n += 1 + runtime.Sov(uint64(x.NewCodeId))
+		l = len(x.ChainId)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.MigrateMsgJson)
+		l = len(x.IbcDenom)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Limit != 0 {
-			n += 1 + runtime.Sov(uint64(x.Limit))
+		l = len(x.Name)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		l = len(x.Symbol)
+		if l > 0 {
+			n += 1 + l + runtime.Sov(uint64(l))
+		}
+		if x.Decimals != 0 {
+			n += 1 + runtime.Sov(uint64(x.Decimals))
+		}
+		if x.Overwrite {
+			n += 2
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -33507,7 +36384,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMigrateAllWrappedTokens)
+		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadata)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33526,22 +36403,48 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Limit != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Limit))
+		if x.Overwrite {
 			i--
-			dAtA[i] = 0x20
+			if x.Overwrite {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
+			i--
+			dAtA[i] = 0x38
 		}
-		if len(x.MigrateMsgJson) > 0 {
-			i -= len(x.MigrateMsgJson)
-			copy(dAtA[i:], x.MigrateMsgJson)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.MigrateMsgJson)))
+		if x.Decimals != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
+			i--
+			dAtA[i] = 0x30
+		}
+		if len(x.Symbol) > 0 {
+			i -= len(x.Symbol)
+			copy(dAtA[i:], x.Symbol)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Symbol)))
+			i--
+			dAtA[i] = 0x2a
+		}
+		if len(x.Name) > 0 {
+			i -= len(x.Name)
+			copy(dAtA[i:], x.Name)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
+			i--
+			dAtA[i] = 0x22
+		}
+		if len(x.IbcDenom) > 0 {
+			i -= len(x.IbcDenom)
+			copy(dAtA[i:], x.IbcDenom)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.IbcDenom)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if x.NewCodeId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.NewCodeId))
+		if len(x.ChainId) > 0 {
+			i -= len(x.ChainId)
+			copy(dAtA[i:], x.ChainId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x12
 		}
 		if len(x.Authority) > 0 {
 			i -= len(x.Authority)
@@ -33561,7 +36464,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMigrateAllWrappedTokens)
+		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadata)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -33593,10 +36496,10 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokens: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadata: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokens: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
@@ -33632,10 +36535,10 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewCodeId", wireType)
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 				}
-				x.NewCodeId = 0
+				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -33645,14 +36548,91 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.NewCodeId |= uint64(b&0x7F) << shift
+					stringLen |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.ChainId = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field MigrateMsgJson", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.IbcDenom = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 4:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+				}
+				var stringLen uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					stringLen |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				intStringLen := int(stringLen)
+				if intStringLen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + intStringLen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Name = string(dAtA[iNdEx:postIndex])
+				iNdEx = postIndex
+			case 5:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -33680,13 +36660,13 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.MigrateMsgJson = string(dAtA[iNdEx:postIndex])
+				x.Symbol = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
-			case 4:
+			case 6:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
 				}
-				x.Limit = 0
+				x.Decimals = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -33696,11 +36676,31 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Limit |= uint32(b&0x7F) << shift
+					x.Decimals |= uint32(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
+			case 7:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Overwrite", wireType)
+				}
+				var v int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				x.Overwrite = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -33737,26 +36737,24 @@ func (x *fastReflection_MsgMigrateAllWrappedTokens) ProtoMethods() *protoiface.M
 }
 
 var (
-	md_MsgMigrateAllWrappedTokensResponse           protoreflect.MessageDescriptor
-	fd_MsgMigrateAllWrappedTokensResponse_attempted protoreflect.FieldDescriptor
+	md_MsgRegisterIbcTokenMetadataResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgMigrateAllWrappedTokensResponse = File_inference_inference_tx_proto.Messages().ByName("MsgMigrateAllWrappedTokensResponse")
-	fd_MsgMigrateAllWrappedTokensResponse_attempted = md_MsgMigrateAllWrappedTokensResponse.Fields().ByName("attempted")
+	md_MsgRegisterIbcTokenMetadataResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterIbcTokenMetadataResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgMigrateAllWrappedTokensResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgRegisterIbcTokenMetadataResponse)(nil)
 
-type fastReflection_MsgMigrateAllWrappedTokensResponse MsgMigrateAllWrappedTokensResponse
+type fastReflection_MsgRegisterIbcTokenMetadataResponse MsgRegisterIbcTokenMetadataResponse
 
-func (x *MsgMigrateAllWrappedTokensResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgMigrateAllWrappedTokensResponse)(x)
+func (x *MsgRegisterIbcTokenMetadataResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgRegisterIbcTokenMetadataResponse)(x)
 }
 
-func (x *MsgMigrateAllWrappedTokensResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[63]
+func (x *MsgRegisterIbcTokenMetadataResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[69]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -33767,43 +36765,43 @@ func (x *MsgMigrateAllWrappedTokensResponse) slowProtoReflect() protoreflect.Mes
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgMigrateAllWrappedTokensResponse_messageType fastReflection_MsgMigrateAllWrappedTokensResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgMigrateAllWrappedTokensResponse_messageType{}
+var _fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType{}
 
-type fastReflection_MsgMigrateAllWrappedTokensResponse_messageType struct{}
+type fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType struct{}
 
-func (x fastReflection_MsgMigrateAllWrappedTokensResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgMigrateAllWrappedTokensResponse)(nil)
+func (x fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgRegisterIbcTokenMetadataResponse)(nil)
 }
-func (x fastReflection_MsgMigrateAllWrappedTokensResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgMigrateAllWrappedTokensResponse)
+func (x fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterIbcTokenMetadataResponse)
 }
-func (x fastReflection_MsgMigrateAllWrappedTokensResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMigrateAllWrappedTokensResponse
+func (x fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterIbcTokenMetadataResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgMigrateAllWrappedTokensResponse
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgRegisterIbcTokenMetadataResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgMigrateAllWrappedTokensResponse_messageType
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgMigrateAllWrappedTokensResponse)
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgRegisterIbcTokenMetadataResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgMigrateAllWrappedTokensResponse)(x)
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgRegisterIbcTokenMetadataResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -33811,13 +36809,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Interface() protoref
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Attempted != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Attempted)
-		if !f(fd_MsgMigrateAllWrappedTokensResponse_attempted, value) {
-			return
-		}
-	}
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -33831,15 +36823,13 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Range(f func(protore
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
-		return x.Attempted != uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33849,15 +36839,13 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Has(fd protoreflect.
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
-		x.Attempted = uint32(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33867,16 +36855,13 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Clear(fd protoreflec
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
-		value := x.Attempted
-		return protoreflect.ValueOfUint32(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -33890,15 +36875,13 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Get(descriptor proto
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
-		x.Attempted = uint32(value.Uint())
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -33912,40 +36895,36 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Set(fd protoreflect.
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
-		panic(fmt.Errorf("field attempted of message inference.inference.MsgMigrateAllWrappedTokensResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgMigrateAllWrappedTokensResponse.attempted":
-		return protoreflect.ValueOfUint32(uint32(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgMigrateAllWrappedTokensResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgMigrateAllWrappedTokensResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgMigrateAllWrappedTokensResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterIbcTokenMetadataResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -33953,7 +36932,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) WhichOneof(d protore
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -33964,7 +36943,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) GetUnknown() protore
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -33976,7 +36955,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) SetUnknown(fields pr
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) IsValid() bool {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -33986,9 +36965,9 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgMigrateAllWrappedTokensResponse)
+		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadataResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34000,9 +36979,6 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *prot
 		var n int
 		var l int
 		_ = l
-		if x.Attempted != 0 {
-			n += 1 + runtime.Sov(uint64(x.Attempted))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -34013,7 +36989,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *prot
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMigrateAllWrappedTokensResponse)
+		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadataResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34032,11 +37008,6 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *prot
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Attempted != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Attempted))
-			i--
-			dAtA[i] = 0x8
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -34048,7 +37019,7 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *prot
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgMigrateAllWrappedTokensResponse)
+		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadataResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34080,31 +37051,12 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *prot
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokensResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadataResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgMigrateAllWrappedTokensResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Attempted", wireType)
-				}
-				x.Attempted = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Attempted |= uint32(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -34141,30 +37093,30 @@ func (x *fastReflection_MsgMigrateAllWrappedTokensResponse) ProtoMethods() *prot
 }
 
 var (
-	md_MsgApproveIbcTokenForTrading           protoreflect.MessageDescriptor
-	fd_MsgApproveIbcTokenForTrading_authority protoreflect.FieldDescriptor
-	fd_MsgApproveIbcTokenForTrading_chainId   protoreflect.FieldDescriptor
-	fd_MsgApproveIbcTokenForTrading_ibcDenom  protoreflect.FieldDescriptor
+	md_MsgCreateDevshardEscrow          protoreflect.MessageDescriptor
+	fd_MsgCreateDevshardEscrow_creator  protoreflect.FieldDescriptor
+	fd_MsgCreateDevshardEscrow_amount   protoreflect.FieldDescriptor
+	fd_MsgCreateDevshardEscrow_model_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgApproveIbcTokenForTrading = File_inference_inference_tx_proto.Messages().ByName("MsgApproveIbcTokenForTrading")
-	fd_MsgApproveIbcTokenForTrading_authority = md_MsgApproveIbcTokenForTrading.Fields().ByName("authority")
-	fd_MsgApproveIbcTokenForTrading_chainId = md_MsgApproveIbcTokenForTrading.Fields().ByName("chainId")
-	fd_MsgApproveIbcTokenForTrading_ibcDenom = md_MsgApproveIbcTokenForTrading.Fields().ByName("ibcDenom")
+	md_MsgCreateDevshardEscrow = File_inference_inference_tx_proto.Messages().ByName("MsgCreateDevshardEscrow")
+	fd_MsgCreateDevshardEscrow_creator = md_MsgCreateDevshardEscrow.Fields().ByName("creator")
+	fd_MsgCreateDevshardEscrow_amount = md_MsgCreateDevshardEscrow.Fields().ByName("amount")
+	fd_MsgCreateDevshardEscrow_model_id = md_MsgCreateDevshardEscrow.Fields().ByName("model_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgApproveIbcTokenForTrading)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCreateDevshardEscrow)(nil)
 
-type fastReflection_MsgApproveIbcTokenForTrading MsgApproveIbcTokenForTrading
+type fastReflection_MsgCreateDevshardEscrow MsgCreateDevshardEscrow
 
-func (x *MsgApproveIbcTokenForTrading) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgApproveIbcTokenForTrading)(x)
+func (x *MsgCreateDevshardEscrow) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCreateDevshardEscrow)(x)
 }
 
-func (x *MsgApproveIbcTokenForTrading) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[64]
+func (x *MsgCreateDevshardEscrow) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[70]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -34175,43 +37127,43 @@ func (x *MsgApproveIbcTokenForTrading) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgApproveIbcTokenForTrading_messageType fastReflection_MsgApproveIbcTokenForTrading_messageType
-var _ protoreflect.MessageType = fastReflection_MsgApproveIbcTokenForTrading_messageType{}
+var _fastReflection_MsgCreateDevshardEscrow_messageType fastReflection_MsgCreateDevshardEscrow_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCreateDevshardEscrow_messageType{}
 
-type fastReflection_MsgApproveIbcTokenForTrading_messageType struct{}
+type fastReflection_MsgCreateDevshardEscrow_messageType struct{}
 
-func (x fastReflection_MsgApproveIbcTokenForTrading_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgApproveIbcTokenForTrading)(nil)
+func (x fastReflection_MsgCreateDevshardEscrow_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCreateDevshardEscrow)(nil)
 }
-func (x fastReflection_MsgApproveIbcTokenForTrading_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveIbcTokenForTrading)
+func (x fastReflection_MsgCreateDevshardEscrow_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateDevshardEscrow)
 }
-func (x fastReflection_MsgApproveIbcTokenForTrading_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveIbcTokenForTrading
+func (x fastReflection_MsgCreateDevshardEscrow_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateDevshardEscrow
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveIbcTokenForTrading
+func (x *fastReflection_MsgCreateDevshardEscrow) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateDevshardEscrow
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Type() protoreflect.MessageType {
-	return _fastReflection_MsgApproveIbcTokenForTrading_messageType
+func (x *fastReflection_MsgCreateDevshardEscrow) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCreateDevshardEscrow_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveIbcTokenForTrading)
+func (x *fastReflection_MsgCreateDevshardEscrow) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateDevshardEscrow)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Interface() protoreflect.ProtoMessage {
-	return (*MsgApproveIbcTokenForTrading)(x)
+func (x *fastReflection_MsgCreateDevshardEscrow) Interface() protoreflect.ProtoMessage {
+	return (*MsgCreateDevshardEscrow)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -34219,22 +37171,22 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) Interface() protoreflect.P
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgApproveIbcTokenForTrading_authority, value) {
+func (x *fastReflection_MsgCreateDevshardEscrow) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgCreateDevshardEscrow_creator, value) {
 			return
 		}
 	}
-	if x.ChainId != "" {
-		value := protoreflect.ValueOfString(x.ChainId)
-		if !f(fd_MsgApproveIbcTokenForTrading_chainId, value) {
+	if x.Amount != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Amount)
+		if !f(fd_MsgCreateDevshardEscrow_amount, value) {
 			return
 		}
 	}
-	if x.IbcDenom != "" {
-		value := protoreflect.ValueOfString(x.IbcDenom)
-		if !f(fd_MsgApproveIbcTokenForTrading_ibcDenom, value) {
+	if x.ModelId != "" {
+		value := protoreflect.ValueOfString(x.ModelId)
+		if !f(fd_MsgCreateDevshardEscrow_model_id, value) {
 			return
 		}
 	}
@@ -34251,19 +37203,19 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) Range(f func(protoreflect.
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCreateDevshardEscrow) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
-		return x.ChainId != ""
-	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
-		return x.IbcDenom != ""
+	case "inference.inference.MsgCreateDevshardEscrow.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgCreateDevshardEscrow.amount":
+		return x.Amount != uint64(0)
+	case "inference.inference.MsgCreateDevshardEscrow.model_id":
+		return x.ModelId != ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34273,19 +37225,19 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) Has(fd protoreflect.FieldD
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCreateDevshardEscrow) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
-		x.Authority = ""
-	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
-		x.ChainId = ""
-	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
-		x.IbcDenom = ""
+	case "inference.inference.MsgCreateDevshardEscrow.creator":
+		x.Creator = ""
+	case "inference.inference.MsgCreateDevshardEscrow.amount":
+		x.Amount = uint64(0)
+	case "inference.inference.MsgCreateDevshardEscrow.model_id":
+		x.ModelId = ""
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34295,22 +37247,22 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) Clear(fd protoreflect.Fiel
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreateDevshardEscrow) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
-		value := x.Authority
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
-		value := x.ChainId
+	case "inference.inference.MsgCreateDevshardEscrow.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
-		value := x.IbcDenom
+	case "inference.inference.MsgCreateDevshardEscrow.amount":
+		value := x.Amount
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgCreateDevshardEscrow.model_id":
+		value := x.ModelId
 		return protoreflect.ValueOfString(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -34324,19 +37276,19 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) Get(descriptor protoreflec
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCreateDevshardEscrow) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
-		x.ChainId = value.Interface().(string)
-	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
-		x.IbcDenom = value.Interface().(string)
+	case "inference.inference.MsgCreateDevshardEscrow.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgCreateDevshardEscrow.amount":
+		x.Amount = value.Uint()
+	case "inference.inference.MsgCreateDevshardEscrow.model_id":
+		x.ModelId = value.Interface().(string)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34350,48 +37302,48 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) Set(fd protoreflect.FieldD
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreateDevshardEscrow) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgApproveIbcTokenForTrading is not mutable"))
-	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
-		panic(fmt.Errorf("field chainId of message inference.inference.MsgApproveIbcTokenForTrading is not mutable"))
-	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
-		panic(fmt.Errorf("field ibcDenom of message inference.inference.MsgApproveIbcTokenForTrading is not mutable"))
+	case "inference.inference.MsgCreateDevshardEscrow.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgCreateDevshardEscrow is not mutable"))
+	case "inference.inference.MsgCreateDevshardEscrow.amount":
+		panic(fmt.Errorf("field amount of message inference.inference.MsgCreateDevshardEscrow is not mutable"))
+	case "inference.inference.MsgCreateDevshardEscrow.model_id":
+		panic(fmt.Errorf("field model_id of message inference.inference.MsgCreateDevshardEscrow is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreateDevshardEscrow) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgApproveIbcTokenForTrading.authority":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgApproveIbcTokenForTrading.chainId":
+	case "inference.inference.MsgCreateDevshardEscrow.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgApproveIbcTokenForTrading.ibcDenom":
+	case "inference.inference.MsgCreateDevshardEscrow.amount":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgCreateDevshardEscrow.model_id":
 		return protoreflect.ValueOfString("")
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTrading"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTrading does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCreateDevshardEscrow) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveIbcTokenForTrading", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreateDevshardEscrow", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -34399,7 +37351,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) WhichOneof(d protoreflect.
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCreateDevshardEscrow) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -34410,7 +37362,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) GetUnknown() protoreflect.
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCreateDevshardEscrow) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -34422,7 +37374,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) SetUnknown(fields protoref
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) IsValid() bool {
+func (x *fastReflection_MsgCreateDevshardEscrow) IsValid() bool {
 	return x != nil
 }
 
@@ -34432,9 +37384,9 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgApproveIbcTokenForTrading)
+		x := input.Message.Interface().(*MsgCreateDevshardEscrow)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34446,15 +37398,14 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ChainId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Amount != 0 {
+			n += 1 + runtime.Sov(uint64(x.Amount))
 		}
-		l = len(x.IbcDenom)
+		l = len(x.ModelId)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
@@ -34468,7 +37419,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveIbcTokenForTrading)
+		x := input.Message.Interface().(*MsgCreateDevshardEscrow)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34487,24 +37438,22 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.IbcDenom) > 0 {
-			i -= len(x.IbcDenom)
-			copy(dAtA[i:], x.IbcDenom)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.IbcDenom)))
+		if len(x.ModelId) > 0 {
+			i -= len(x.ModelId)
+			copy(dAtA[i:], x.ModelId)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.ChainId) > 0 {
-			i -= len(x.ChainId)
-			copy(dAtA[i:], x.ChainId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+		if x.Amount != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -34519,7 +37468,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveIbcTokenForTrading)
+		x := input.Message.Interface().(*MsgCreateDevshardEscrow)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34551,15 +37500,15 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTrading: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrow: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTrading: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrow: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -34587,13 +37536,13 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
 				}
-				var stringLen uint64
+				x.Amount = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -34603,27 +37552,14 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					x.Amount |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ChainId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -34651,7 +37587,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.IbcDenom = string(dAtA[iNdEx:postIndex])
+				x.ModelId = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			default:
 				iNdEx = preIndex
@@ -34689,24 +37625,26 @@ func (x *fastReflection_MsgApproveIbcTokenForTrading) ProtoMethods() *protoiface
 }
 
 var (
-	md_MsgApproveIbcTokenForTradingResponse protoreflect.MessageDescriptor
+	md_MsgCreateDevshardEscrowResponse           protoreflect.MessageDescriptor
+	fd_MsgCreateDevshardEscrowResponse_escrow_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgApproveIbcTokenForTradingResponse = File_inference_inference_tx_proto.Messages().ByName("MsgApproveIbcTokenForTradingResponse")
+	md_MsgCreateDevshardEscrowResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCreateDevshardEscrowResponse")
+	fd_MsgCreateDevshardEscrowResponse_escrow_id = md_MsgCreateDevshardEscrowResponse.Fields().ByName("escrow_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgApproveIbcTokenForTradingResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCreateDevshardEscrowResponse)(nil)
 
-type fastReflection_MsgApproveIbcTokenForTradingResponse MsgApproveIbcTokenForTradingResponse
+type fastReflection_MsgCreateDevshardEscrowResponse MsgCreateDevshardEscrowResponse
 
-func (x *MsgApproveIbcTokenForTradingResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgApproveIbcTokenForTradingResponse)(x)
+func (x *MsgCreateDevshardEscrowResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCreateDevshardEscrowResponse)(x)
 }
 
-func (x *MsgApproveIbcTokenForTradingResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[65]
+func (x *MsgCreateDevshardEscrowResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[71]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -34717,43 +37655,43 @@ func (x *MsgApproveIbcTokenForTradingResponse) slowProtoReflect() protoreflect.M
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgApproveIbcTokenForTradingResponse_messageType fastReflection_MsgApproveIbcTokenForTradingResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgApproveIbcTokenForTradingResponse_messageType{}
+var _fastReflection_MsgCreateDevshardEscrowResponse_messageType fastReflection_MsgCreateDevshardEscrowResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCreateDevshardEscrowResponse_messageType{}
 
-type fastReflection_MsgApproveIbcTokenForTradingResponse_messageType struct{}
+type fastReflection_MsgCreateDevshardEscrowResponse_messageType struct{}
 
-func (x fastReflection_MsgApproveIbcTokenForTradingResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgApproveIbcTokenForTradingResponse)(nil)
+func (x fastReflection_MsgCreateDevshardEscrowResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCreateDevshardEscrowResponse)(nil)
 }
-func (x fastReflection_MsgApproveIbcTokenForTradingResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveIbcTokenForTradingResponse)
+func (x fastReflection_MsgCreateDevshardEscrowResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateDevshardEscrowResponse)
 }
-func (x fastReflection_MsgApproveIbcTokenForTradingResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveIbcTokenForTradingResponse
+func (x fastReflection_MsgCreateDevshardEscrowResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateDevshardEscrowResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgApproveIbcTokenForTradingResponse
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCreateDevshardEscrowResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgApproveIbcTokenForTradingResponse_messageType
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCreateDevshardEscrowResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgApproveIbcTokenForTradingResponse)
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgCreateDevshardEscrowResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgApproveIbcTokenForTradingResponse)(x)
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgCreateDevshardEscrowResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -34761,7 +37699,13 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Interface() protor
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.EscrowId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EscrowId)
+		if !f(fd_MsgCreateDevshardEscrowResponse_escrow_id, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -34775,13 +37719,15 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Range(f func(proto
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
+		return x.EscrowId != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34791,13 +37737,15 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Has(fd protoreflec
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
+		x.EscrowId = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34807,13 +37755,16 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Clear(fd protorefl
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
+		value := x.EscrowId
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -34827,13 +37778,15 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Get(descriptor pro
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
+		x.EscrowId = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -34847,36 +37800,40 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Set(fd protoreflec
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
+		panic(fmt.Errorf("field escrow_id of message inference.inference.MsgCreateDevshardEscrowResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgApproveIbcTokenForTradingResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgApproveIbcTokenForTradingResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgApproveIbcTokenForTradingResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreateDevshardEscrowResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -34884,7 +37841,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) WhichOneof(d proto
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -34895,7 +37852,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) GetUnknown() proto
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -34907,7 +37864,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) IsValid() bool {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -34917,9 +37874,9 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgApproveIbcTokenForTradingResponse)
+		x := input.Message.Interface().(*MsgCreateDevshardEscrowResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34931,6 +37888,9 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *pr
 		var n int
 		var l int
 		_ = l
+		if x.EscrowId != 0 {
+			n += 1 + runtime.Sov(uint64(x.EscrowId))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -34941,7 +37901,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *pr
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveIbcTokenForTradingResponse)
+		x := input.Message.Interface().(*MsgCreateDevshardEscrowResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -34960,6 +37920,11 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *pr
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.EscrowId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EscrowId))
+			i--
+			dAtA[i] = 0x8
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -34971,7 +37936,7 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *pr
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgApproveIbcTokenForTradingResponse)
+		x := input.Message.Interface().(*MsgCreateDevshardEscrowResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35003,12 +37968,31 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *pr
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTradingResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrowResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgApproveIbcTokenForTradingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
+				}
+				x.EscrowId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EscrowId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -35044,39 +38028,145 @@ func (x *fastReflection_MsgApproveIbcTokenForTradingResponse) ProtoMethods() *pr
 	}
 }
 
+var _ protoreflect.List = (*_MsgSettleDevshardEscrow_6_list)(nil)
+
+type _MsgSettleDevshardEscrow_6_list struct {
+	list *[]*DevshardSettlementHostStats
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DevshardSettlementHostStats)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DevshardSettlementHostStats)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) AppendMutable() protoreflect.Value {
+	v := new(DevshardSettlementHostStats)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) NewElement() protoreflect.Value {
+	v := new(DevshardSettlementHostStats)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSettleDevshardEscrow_6_list) IsValid() bool {
+	return x.list != nil
+}
+
+var _ protoreflect.List = (*_MsgSettleDevshardEscrow_7_list)(nil)
+
+type _MsgSettleDevshardEscrow_7_list struct {
+	list *[]*DevshardSlotSignature
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) Len() int {
+	if x.list == nil {
+		return 0
+	}
+	return len(*x.list)
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) Get(i int) protoreflect.Value {
+	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) Set(i int, value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DevshardSlotSignature)
+	(*x.list)[i] = concreteValue
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) Append(value protoreflect.Value) {
+	valueUnwrapped := value.Message()
+	concreteValue := valueUnwrapped.Interface().(*DevshardSlotSignature)
+	*x.list = append(*x.list, concreteValue)
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) AppendMutable() protoreflect.Value {
+	v := new(DevshardSlotSignature)
+	*x.list = append(*x.list, v)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) Truncate(n int) {
+	for i := n; i < len(*x.list); i++ {
+		(*x.list)[i] = nil
+	}
+	*x.list = (*x.list)[:n]
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) NewElement() protoreflect.Value {
+	v := new(DevshardSlotSignature)
+	return protoreflect.ValueOfMessage(v.ProtoReflect())
+}
+
+func (x *_MsgSettleDevshardEscrow_7_list) IsValid() bool {
+	return x.list != nil
+}
+
 var (
-	md_MsgRegisterIbcTokenMetadata           protoreflect.MessageDescriptor
-	fd_MsgRegisterIbcTokenMetadata_authority protoreflect.FieldDescriptor
-	fd_MsgRegisterIbcTokenMetadata_chainId   protoreflect.FieldDescriptor
-	fd_MsgRegisterIbcTokenMetadata_ibcDenom  protoreflect.FieldDescriptor
-	fd_MsgRegisterIbcTokenMetadata_name      protoreflect.FieldDescriptor
-	fd_MsgRegisterIbcTokenMetadata_symbol    protoreflect.FieldDescriptor
-	fd_MsgRegisterIbcTokenMetadata_decimals  protoreflect.FieldDescriptor
-	fd_MsgRegisterIbcTokenMetadata_overwrite protoreflect.FieldDescriptor
+	md_MsgSettleDevshardEscrow                                 protoreflect.MessageDescriptor
+	fd_MsgSettleDevshardEscrow_settler                         protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_escrow_id                       protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_state_root_and_protocol_version protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_state_root                      protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_nonce                           protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_rest_hash                       protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_host_stats                      protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_signatures                      protoreflect.FieldDescriptor
+	fd_MsgSettleDevshardEscrow_fees                            protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterIbcTokenMetadata = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterIbcTokenMetadata")
-	fd_MsgRegisterIbcTokenMetadata_authority = md_MsgRegisterIbcTokenMetadata.Fields().ByName("authority")
-	fd_MsgRegisterIbcTokenMetadata_chainId = md_MsgRegisterIbcTokenMetadata.Fields().ByName("chainId")
-	fd_MsgRegisterIbcTokenMetadata_ibcDenom = md_MsgRegisterIbcTokenMetadata.Fields().ByName("ibcDenom")
-	fd_MsgRegisterIbcTokenMetadata_name = md_MsgRegisterIbcTokenMetadata.Fields().ByName("name")
-	fd_MsgRegisterIbcTokenMetadata_symbol = md_MsgRegisterIbcTokenMetadata.Fields().ByName("symbol")
-	fd_MsgRegisterIbcTokenMetadata_decimals = md_MsgRegisterIbcTokenMetadata.Fields().ByName("decimals")
-	fd_MsgRegisterIbcTokenMetadata_overwrite = md_MsgRegisterIbcTokenMetadata.Fields().ByName("overwrite")
+	md_MsgSettleDevshardEscrow = File_inference_inference_tx_proto.Messages().ByName("MsgSettleDevshardEscrow")
+	fd_MsgSettleDevshardEscrow_settler = md_MsgSettleDevshardEscrow.Fields().ByName("settler")
+	fd_MsgSettleDevshardEscrow_escrow_id = md_MsgSettleDevshardEscrow.Fields().ByName("escrow_id")
+	fd_MsgSettleDevshardEscrow_state_root_and_protocol_version = md_MsgSettleDevshardEscrow.Fields().ByName("state_root_and_protocol_version")
+	fd_MsgSettleDevshardEscrow_state_root = md_MsgSettleDevshardEscrow.Fields().ByName("state_root")
+	fd_MsgSettleDevshardEscrow_nonce = md_MsgSettleDevshardEscrow.Fields().ByName("nonce")
+	fd_MsgSettleDevshardEscrow_rest_hash = md_MsgSettleDevshardEscrow.Fields().ByName("rest_hash")
+	fd_MsgSettleDevshardEscrow_host_stats = md_MsgSettleDevshardEscrow.Fields().ByName("host_stats")
+	fd_MsgSettleDevshardEscrow_signatures = md_MsgSettleDevshardEscrow.Fields().ByName("signatures")
+	fd_MsgSettleDevshardEscrow_fees = md_MsgSettleDevshardEscrow.Fields().ByName("fees")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterIbcTokenMetadata)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSettleDevshardEscrow)(nil)
 
-type fastReflection_MsgRegisterIbcTokenMetadata MsgRegisterIbcTokenMetadata
+type fastReflection_MsgSettleDevshardEscrow MsgSettleDevshardEscrow
 
-func (x *MsgRegisterIbcTokenMetadata) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterIbcTokenMetadata)(x)
+func (x *MsgSettleDevshardEscrow) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSettleDevshardEscrow)(x)
 }
 
-func (x *MsgRegisterIbcTokenMetadata) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[66]
+func (x *MsgSettleDevshardEscrow) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[72]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -35087,43 +38177,43 @@ func (x *MsgRegisterIbcTokenMetadata) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterIbcTokenMetadata_messageType fastReflection_MsgRegisterIbcTokenMetadata_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterIbcTokenMetadata_messageType{}
+var _fastReflection_MsgSettleDevshardEscrow_messageType fastReflection_MsgSettleDevshardEscrow_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSettleDevshardEscrow_messageType{}
 
-type fastReflection_MsgRegisterIbcTokenMetadata_messageType struct{}
+type fastReflection_MsgSettleDevshardEscrow_messageType struct{}
 
-func (x fastReflection_MsgRegisterIbcTokenMetadata_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterIbcTokenMetadata)(nil)
+func (x fastReflection_MsgSettleDevshardEscrow_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSettleDevshardEscrow)(nil)
 }
-func (x fastReflection_MsgRegisterIbcTokenMetadata_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterIbcTokenMetadata)
+func (x fastReflection_MsgSettleDevshardEscrow_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSettleDevshardEscrow)
 }
-func (x fastReflection_MsgRegisterIbcTokenMetadata_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterIbcTokenMetadata
+func (x fastReflection_MsgSettleDevshardEscrow_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSettleDevshardEscrow
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterIbcTokenMetadata
+func (x *fastReflection_MsgSettleDevshardEscrow) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSettleDevshardEscrow
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterIbcTokenMetadata_messageType
+func (x *fastReflection_MsgSettleDevshardEscrow) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSettleDevshardEscrow_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterIbcTokenMetadata)
+func (x *fastReflection_MsgSettleDevshardEscrow) New() protoreflect.Message {
+	return new(fastReflection_MsgSettleDevshardEscrow)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterIbcTokenMetadata)(x)
+func (x *fastReflection_MsgSettleDevshardEscrow) Interface() protoreflect.ProtoMessage {
+	return (*MsgSettleDevshardEscrow)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -35131,46 +38221,58 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) Interface() protoreflect.Pr
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgRegisterIbcTokenMetadata_authority, value) {
+func (x *fastReflection_MsgSettleDevshardEscrow) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Settler != "" {
+		value := protoreflect.ValueOfString(x.Settler)
+		if !f(fd_MsgSettleDevshardEscrow_settler, value) {
 			return
 		}
 	}
-	if x.ChainId != "" {
-		value := protoreflect.ValueOfString(x.ChainId)
-		if !f(fd_MsgRegisterIbcTokenMetadata_chainId, value) {
+	if x.EscrowId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.EscrowId)
+		if !f(fd_MsgSettleDevshardEscrow_escrow_id, value) {
 			return
 		}
 	}
-	if x.IbcDenom != "" {
-		value := protoreflect.ValueOfString(x.IbcDenom)
-		if !f(fd_MsgRegisterIbcTokenMetadata_ibcDenom, value) {
+	if x.StateRootAndProtocolVersion != "" {
+		value := protoreflect.ValueOfString(x.StateRootAndProtocolVersion)
+		if !f(fd_MsgSettleDevshardEscrow_state_root_and_protocol_version, value) {
 			return
 		}
 	}
-	if x.Name != "" {
-		value := protoreflect.ValueOfString(x.Name)
-		if !f(fd_MsgRegisterIbcTokenMetadata_name, value) {
+	if len(x.StateRoot) != 0 {
+		value := protoreflect.ValueOfBytes(x.StateRoot)
+		if !f(fd_MsgSettleDevshardEscrow_state_root, value) {
 			return
 		}
 	}
-	if x.Symbol != "" {
-		value := protoreflect.ValueOfString(x.Symbol)
-		if !f(fd_MsgRegisterIbcTokenMetadata_symbol, value) {
+	if x.Nonce != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Nonce)
+		if !f(fd_MsgSettleDevshardEscrow_nonce, value) {
 			return
 		}
 	}
-	if x.Decimals != uint32(0) {
-		value := protoreflect.ValueOfUint32(x.Decimals)
-		if !f(fd_MsgRegisterIbcTokenMetadata_decimals, value) {
+	if len(x.RestHash) != 0 {
+		value := protoreflect.ValueOfBytes(x.RestHash)
+		if !f(fd_MsgSettleDevshardEscrow_rest_hash, value) {
 			return
 		}
 	}
-	if x.Overwrite != false {
-		value := protoreflect.ValueOfBool(x.Overwrite)
-		if !f(fd_MsgRegisterIbcTokenMetadata_overwrite, value) {
+	if len(x.HostStats) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_6_list{list: &x.HostStats})
+		if !f(fd_MsgSettleDevshardEscrow_host_stats, value) {
+			return
+		}
+	}
+	if len(x.Signatures) != 0 {
+		value := protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_7_list{list: &x.Signatures})
+		if !f(fd_MsgSettleDevshardEscrow_signatures, value) {
+			return
+		}
+	}
+	if x.Fees != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.Fees)
+		if !f(fd_MsgSettleDevshardEscrow_fees, value) {
 			return
 		}
 	}
@@ -35187,27 +38289,31 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) Range(f func(protoreflect.F
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSettleDevshardEscrow) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
-		return x.ChainId != ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
-		return x.IbcDenom != ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
-		return x.Name != ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
-		return x.Symbol != ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
-		return x.Decimals != uint32(0)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
-		return x.Overwrite != false
+	case "inference.inference.MsgSettleDevshardEscrow.settler":
+		return x.Settler != ""
+	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
+		return x.EscrowId != uint64(0)
+	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
+		return x.StateRootAndProtocolVersion != ""
+	case "inference.inference.MsgSettleDevshardEscrow.state_root":
+		return len(x.StateRoot) != 0
+	case "inference.inference.MsgSettleDevshardEscrow.nonce":
+		return x.Nonce != uint64(0)
+	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
+		return len(x.RestHash) != 0
+	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
+		return len(x.HostStats) != 0
+	case "inference.inference.MsgSettleDevshardEscrow.signatures":
+		return len(x.Signatures) != 0
+	case "inference.inference.MsgSettleDevshardEscrow.fees":
+		return x.Fees != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35217,27 +38323,31 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) Has(fd protoreflect.FieldDe
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSettleDevshardEscrow) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
-		x.Authority = ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
-		x.ChainId = ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
-		x.IbcDenom = ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
-		x.Name = ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
-		x.Symbol = ""
-	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
-		x.Decimals = uint32(0)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
-		x.Overwrite = false
+	case "inference.inference.MsgSettleDevshardEscrow.settler":
+		x.Settler = ""
+	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
+		x.EscrowId = uint64(0)
+	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
+		x.StateRootAndProtocolVersion = ""
+	case "inference.inference.MsgSettleDevshardEscrow.state_root":
+		x.StateRoot = nil
+	case "inference.inference.MsgSettleDevshardEscrow.nonce":
+		x.Nonce = uint64(0)
+	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
+		x.RestHash = nil
+	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
+		x.HostStats = nil
+	case "inference.inference.MsgSettleDevshardEscrow.signatures":
+		x.Signatures = nil
+	case "inference.inference.MsgSettleDevshardEscrow.fees":
+		x.Fees = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35247,34 +38357,46 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) Clear(fd protoreflect.Field
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSettleDevshardEscrow) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
-		value := x.Authority
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
-		value := x.ChainId
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
-		value := x.IbcDenom
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
-		value := x.Name
+	case "inference.inference.MsgSettleDevshardEscrow.settler":
+		value := x.Settler
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
-		value := x.Symbol
+	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
+		value := x.EscrowId
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
+		value := x.StateRootAndProtocolVersion
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
-		value := x.Decimals
-		return protoreflect.ValueOfUint32(value)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
-		value := x.Overwrite
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.MsgSettleDevshardEscrow.state_root":
+		value := x.StateRoot
+		return protoreflect.ValueOfBytes(value)
+	case "inference.inference.MsgSettleDevshardEscrow.nonce":
+		value := x.Nonce
+		return protoreflect.ValueOfUint64(value)
+	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
+		value := x.RestHash
+		return protoreflect.ValueOfBytes(value)
+	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
+		if len(x.HostStats) == 0 {
+			return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_6_list{})
+		}
+		listValue := &_MsgSettleDevshardEscrow_6_list{list: &x.HostStats}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgSettleDevshardEscrow.signatures":
+		if len(x.Signatures) == 0 {
+			return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_7_list{})
+		}
+		listValue := &_MsgSettleDevshardEscrow_7_list{list: &x.Signatures}
+		return protoreflect.ValueOfList(listValue)
+	case "inference.inference.MsgSettleDevshardEscrow.fees":
+		value := x.Fees
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -35288,27 +38410,35 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) Get(descriptor protoreflect
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSettleDevshardEscrow) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
-		x.ChainId = value.Interface().(string)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
-		x.IbcDenom = value.Interface().(string)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
-		x.Name = value.Interface().(string)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
-		x.Symbol = value.Interface().(string)
-	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
-		x.Decimals = uint32(value.Uint())
-	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
-		x.Overwrite = value.Bool()
+	case "inference.inference.MsgSettleDevshardEscrow.settler":
+		x.Settler = value.Interface().(string)
+	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
+		x.EscrowId = value.Uint()
+	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
+		x.StateRootAndProtocolVersion = value.Interface().(string)
+	case "inference.inference.MsgSettleDevshardEscrow.state_root":
+		x.StateRoot = value.Bytes()
+	case "inference.inference.MsgSettleDevshardEscrow.nonce":
+		x.Nonce = value.Uint()
+	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
+		x.RestHash = value.Bytes()
+	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
+		lv := value.List()
+		clv := lv.(*_MsgSettleDevshardEscrow_6_list)
+		x.HostStats = *clv.list
+	case "inference.inference.MsgSettleDevshardEscrow.signatures":
+		lv := value.List()
+		clv := lv.(*_MsgSettleDevshardEscrow_7_list)
+		x.Signatures = *clv.list
+	case "inference.inference.MsgSettleDevshardEscrow.fees":
+		x.Fees = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35322,64 +38452,82 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) Set(fd protoreflect.FieldDe
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSettleDevshardEscrow) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
-		panic(fmt.Errorf("field chainId of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
-		panic(fmt.Errorf("field ibcDenom of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
-		panic(fmt.Errorf("field name of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
-		panic(fmt.Errorf("field symbol of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
-		panic(fmt.Errorf("field decimals of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
-		panic(fmt.Errorf("field overwrite of message inference.inference.MsgRegisterIbcTokenMetadata is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
+		if x.HostStats == nil {
+			x.HostStats = []*DevshardSettlementHostStats{}
+		}
+		value := &_MsgSettleDevshardEscrow_6_list{list: &x.HostStats}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgSettleDevshardEscrow.signatures":
+		if x.Signatures == nil {
+			x.Signatures = []*DevshardSlotSignature{}
+		}
+		value := &_MsgSettleDevshardEscrow_7_list{list: &x.Signatures}
+		return protoreflect.ValueOfList(value)
+	case "inference.inference.MsgSettleDevshardEscrow.settler":
+		panic(fmt.Errorf("field settler of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
+		panic(fmt.Errorf("field escrow_id of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
+		panic(fmt.Errorf("field state_root_and_protocol_version of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.state_root":
+		panic(fmt.Errorf("field state_root of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.nonce":
+		panic(fmt.Errorf("field nonce of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
+		panic(fmt.Errorf("field rest_hash of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSettleDevshardEscrow.fees":
+		panic(fmt.Errorf("field fees of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSettleDevshardEscrow) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgRegisterIbcTokenMetadata.authority":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterIbcTokenMetadata.chainId":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterIbcTokenMetadata.ibcDenom":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterIbcTokenMetadata.name":
+	case "inference.inference.MsgSettleDevshardEscrow.settler":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterIbcTokenMetadata.symbol":
+	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgRegisterIbcTokenMetadata.decimals":
-		return protoreflect.ValueOfUint32(uint32(0))
-	case "inference.inference.MsgRegisterIbcTokenMetadata.overwrite":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.MsgSettleDevshardEscrow.state_root":
+		return protoreflect.ValueOfBytes(nil)
+	case "inference.inference.MsgSettleDevshardEscrow.nonce":
+		return protoreflect.ValueOfUint64(uint64(0))
+	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
+		return protoreflect.ValueOfBytes(nil)
+	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
+		list := []*DevshardSettlementHostStats{}
+		return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_6_list{list: &list})
+	case "inference.inference.MsgSettleDevshardEscrow.signatures":
+		list := []*DevshardSlotSignature{}
+		return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_7_list{list: &list})
+	case "inference.inference.MsgSettleDevshardEscrow.fees":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadata"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadata does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSettleDevshardEscrow) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterIbcTokenMetadata", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSettleDevshardEscrow", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -35387,7 +38535,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) WhichOneof(d protoreflect.O
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSettleDevshardEscrow) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -35398,7 +38546,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) GetUnknown() protoreflect.R
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSettleDevshardEscrow) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -35410,7 +38558,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) SetUnknown(fields protorefl
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) IsValid() bool {
+func (x *fastReflection_MsgSettleDevshardEscrow) IsValid() bool {
 	return x != nil
 }
 
@@ -35420,9 +38568,9 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadata)
+		x := input.Message.Interface().(*MsgSettleDevshardEscrow)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35434,31 +38582,42 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
+		l = len(x.Settler)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.ChainId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.EscrowId != 0 {
+			n += 1 + runtime.Sov(uint64(x.EscrowId))
 		}
-		l = len(x.IbcDenom)
+		l = len(x.StateRootAndProtocolVersion)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Name)
+		l = len(x.StateRoot)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		l = len(x.Symbol)
+		if x.Nonce != 0 {
+			n += 1 + runtime.Sov(uint64(x.Nonce))
+		}
+		l = len(x.RestHash)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Decimals != 0 {
-			n += 1 + runtime.Sov(uint64(x.Decimals))
+		if len(x.HostStats) > 0 {
+			for _, e := range x.HostStats {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
 		}
-		if x.Overwrite {
-			n += 2
+		if len(x.Signatures) > 0 {
+			for _, e := range x.Signatures {
+				l = options.Size(e)
+				n += 1 + l + runtime.Sov(uint64(l))
+			}
+		}
+		if x.Fees != 0 {
+			n += 1 + runtime.Sov(uint64(x.Fees))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -35470,7 +38629,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadata)
+		x := input.Message.Interface().(*MsgSettleDevshardEscrow)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35489,53 +38648,78 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Overwrite {
-			i--
-			if x.Overwrite {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
-			}
+		if len(x.StateRootAndProtocolVersion) > 0 {
+			i -= len(x.StateRootAndProtocolVersion)
+			copy(dAtA[i:], x.StateRootAndProtocolVersion)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.StateRootAndProtocolVersion)))
 			i--
-			dAtA[i] = 0x38
+			dAtA[i] = 0x4a
 		}
-		if x.Decimals != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Decimals))
+		if x.Fees != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Fees))
 			i--
-			dAtA[i] = 0x30
+			dAtA[i] = 0x40
 		}
-		if len(x.Symbol) > 0 {
-			i -= len(x.Symbol)
-			copy(dAtA[i:], x.Symbol)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Symbol)))
+		if len(x.Signatures) > 0 {
+			for iNdEx := len(x.Signatures) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.Signatures[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x3a
+			}
+		}
+		if len(x.HostStats) > 0 {
+			for iNdEx := len(x.HostStats) - 1; iNdEx >= 0; iNdEx-- {
+				encoded, err := options.Marshal(x.HostStats[iNdEx])
+				if err != nil {
+					return protoiface.MarshalOutput{
+						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
+						Buf:               input.Buf,
+					}, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
+				i--
+				dAtA[i] = 0x32
+			}
+		}
+		if len(x.RestHash) > 0 {
+			i -= len(x.RestHash)
+			copy(dAtA[i:], x.RestHash)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RestHash)))
 			i--
 			dAtA[i] = 0x2a
 		}
-		if len(x.Name) > 0 {
-			i -= len(x.Name)
-			copy(dAtA[i:], x.Name)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
+		if x.Nonce != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.Nonce))
 			i--
-			dAtA[i] = 0x22
+			dAtA[i] = 0x20
 		}
-		if len(x.IbcDenom) > 0 {
-			i -= len(x.IbcDenom)
-			copy(dAtA[i:], x.IbcDenom)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.IbcDenom)))
+		if len(x.StateRoot) > 0 {
+			i -= len(x.StateRoot)
+			copy(dAtA[i:], x.StateRoot)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.StateRoot)))
 			i--
 			dAtA[i] = 0x1a
 		}
-		if len(x.ChainId) > 0 {
-			i -= len(x.ChainId)
-			copy(dAtA[i:], x.ChainId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChainId)))
+		if x.EscrowId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.EscrowId))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x10
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Settler) > 0 {
+			i -= len(x.Settler)
+			copy(dAtA[i:], x.Settler)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Settler)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -35550,7 +38734,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadata)
+		x := input.Message.Interface().(*MsgSettleDevshardEscrow)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -35582,15 +38766,15 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadata: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrow: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrow: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Settler", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -35618,11 +38802,30 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Settler = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
+				}
+				x.EscrowId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.EscrowId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 9:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StateRootAndProtocolVersion", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -35650,13 +38853,13 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.ChainId = string(dAtA[iNdEx:postIndex])
+				x.StateRootAndProtocolVersion = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType)
 				}
-				var stringLen uint64
+				var byteLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -35666,29 +38869,50 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					byteLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if byteLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + byteLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.IbcDenom = string(dAtA[iNdEx:postIndex])
+				x.StateRoot = append(x.StateRoot[:0], dAtA[iNdEx:postIndex]...)
+				if x.StateRoot == nil {
+					x.StateRoot = []byte{}
+				}
 				iNdEx = postIndex
 			case 4:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
+				}
+				x.Nonce = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.Nonce |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+			case 5:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RestHash", wireType)
 				}
-				var stringLen uint64
+				var byteLen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -35698,29 +38922,31 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					byteLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if byteLen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + byteLen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Name = string(dAtA[iNdEx:postIndex])
+				x.RestHash = append(x.RestHash[:0], dAtA[iNdEx:postIndex]...)
+				if x.RestHash == nil {
+					x.RestHash = []byte{}
+				}
 				iNdEx = postIndex
-			case 5:
+			case 6:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HostStats", wireType)
 				}
-				var stringLen uint64
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -35730,29 +38956,31 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
+				if msglen < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
-				postIndex := iNdEx + intStringLen
+				postIndex := iNdEx + msglen
 				if postIndex < 0 {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
 				}
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Symbol = string(dAtA[iNdEx:postIndex])
+				x.HostStats = append(x.HostStats, &DevshardSettlementHostStats{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.HostStats[len(x.HostStats)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
 				iNdEx = postIndex
-			case 6:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
+			case 7:
+				if wireType != 2 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
 				}
-				x.Decimals = 0
+				var msglen int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -35762,16 +38990,31 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Decimals |= uint32(b&0x7F) << shift
+					msglen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-			case 7:
+				if msglen < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				postIndex := iNdEx + msglen
+				if postIndex < 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
+				}
+				if postIndex > l {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+				}
+				x.Signatures = append(x.Signatures, &DevshardSlotSignature{})
+				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Signatures[len(x.Signatures)-1]); err != nil {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
+				}
+				iNdEx = postIndex
+			case 8:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Overwrite", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fees", wireType)
 				}
-				var v int
+				x.Fees = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -35781,12 +39024,11 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					x.Fees |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.Overwrite = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -35823,24 +39065,24 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadata) ProtoMethods() *protoiface.
 }
 
 var (
-	md_MsgRegisterIbcTokenMetadataResponse protoreflect.MessageDescriptor
+	md_MsgSettleDevshardEscrowResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgRegisterIbcTokenMetadataResponse = File_inference_inference_tx_proto.Messages().ByName("MsgRegisterIbcTokenMetadataResponse")
+	md_MsgSettleDevshardEscrowResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSettleDevshardEscrowResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgRegisterIbcTokenMetadataResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSettleDevshardEscrowResponse)(nil)
 
-type fastReflection_MsgRegisterIbcTokenMetadataResponse MsgRegisterIbcTokenMetadataResponse
+type fastReflection_MsgSettleDevshardEscrowResponse MsgSettleDevshardEscrowResponse
 
-func (x *MsgRegisterIbcTokenMetadataResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgRegisterIbcTokenMetadataResponse)(x)
+func (x *MsgSettleDevshardEscrowResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSettleDevshardEscrowResponse)(x)
 }
 
-func (x *MsgRegisterIbcTokenMetadataResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[67]
+func (x *MsgSettleDevshardEscrowResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[73]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -35851,43 +39093,43 @@ func (x *MsgRegisterIbcTokenMetadataResponse) slowProtoReflect() protoreflect.Me
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType{}
+var _fastReflection_MsgSettleDevshardEscrowResponse_messageType fastReflection_MsgSettleDevshardEscrowResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSettleDevshardEscrowResponse_messageType{}
 
-type fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType struct{}
+type fastReflection_MsgSettleDevshardEscrowResponse_messageType struct{}
 
-func (x fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgRegisterIbcTokenMetadataResponse)(nil)
+func (x fastReflection_MsgSettleDevshardEscrowResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSettleDevshardEscrowResponse)(nil)
 }
-func (x fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterIbcTokenMetadataResponse)
+func (x fastReflection_MsgSettleDevshardEscrowResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSettleDevshardEscrowResponse)
 }
-func (x fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterIbcTokenMetadataResponse
+func (x fastReflection_MsgSettleDevshardEscrowResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSettleDevshardEscrowResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgRegisterIbcTokenMetadataResponse
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSettleDevshardEscrowResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgRegisterIbcTokenMetadataResponse_messageType
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSettleDevshardEscrowResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgRegisterIbcTokenMetadataResponse)
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSettleDevshardEscrowResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgRegisterIbcTokenMetadataResponse)(x)
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSettleDevshardEscrowResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -35895,7 +39137,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Interface() protore
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -35909,13 +39151,13 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Range(f func(protor
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35925,13 +39167,13 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Has(fd protoreflect
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35941,13 +39183,13 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Clear(fd protorefle
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -35961,13 +39203,13 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Get(descriptor prot
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -35981,36 +39223,36 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Set(fd protoreflect
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgRegisterIbcTokenMetadataResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgRegisterIbcTokenMetadataResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgRegisterIbcTokenMetadataResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSettleDevshardEscrowResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -36018,7 +39260,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) WhichOneof(d protor
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -36029,7 +39271,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) GetUnknown() protor
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -36041,7 +39283,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) SetUnknown(fields p
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) IsValid() bool {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -36051,9 +39293,9 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadataResponse)
+		x := input.Message.Interface().(*MsgSettleDevshardEscrowResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36075,7 +39317,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) ProtoMethods() *pro
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadataResponse)
+		x := input.Message.Interface().(*MsgSettleDevshardEscrowResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36105,7 +39347,7 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) ProtoMethods() *pro
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgRegisterIbcTokenMetadataResponse)
+		x := input.Message.Interface().(*MsgSettleDevshardEscrowResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36137,10 +39379,10 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) ProtoMethods() *pro
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadataResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrowResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgRegisterIbcTokenMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -36179,30 +39421,28 @@ func (x *fastReflection_MsgRegisterIbcTokenMetadataResponse) ProtoMethods() *pro
 }
 
 var (
-	md_MsgCreateDevshardEscrow          protoreflect.MessageDescriptor
-	fd_MsgCreateDevshardEscrow_creator  protoreflect.FieldDescriptor
-	fd_MsgCreateDevshardEscrow_amount   protoreflect.FieldDescriptor
-	fd_MsgCreateDevshardEscrow_model_id protoreflect.FieldDescriptor
+	md_MsgSetDevshardRequestsEnabled           protoreflect.MessageDescriptor
+	fd_MsgSetDevshardRequestsEnabled_authority protoreflect.FieldDescriptor
+	fd_MsgSetDevshardRequestsEnabled_enabled   protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgCreateDevshardEscrow = File_inference_inference_tx_proto.Messages().ByName("MsgCreateDevshardEscrow")
-	fd_MsgCreateDevshardEscrow_creator = md_MsgCreateDevshardEscrow.Fields().ByName("creator")
-	fd_MsgCreateDevshardEscrow_amount = md_MsgCreateDevshardEscrow.Fields().ByName("amount")
-	fd_MsgCreateDevshardEscrow_model_id = md_MsgCreateDevshardEscrow.Fields().ByName("model_id")
+	md_MsgSetDevshardRequestsEnabled = File_inference_inference_tx_proto.Messages().ByName("MsgSetDevshardRequestsEnabled")
+	fd_MsgSetDevshardRequestsEnabled_authority = md_MsgSetDevshardRequestsEnabled.Fields().ByName("authority")
+	fd_MsgSetDevshardRequestsEnabled_enabled = md_MsgSetDevshardRequestsEnabled.Fields().ByName("enabled")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgCreateDevshardEscrow)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSetDevshardRequestsEnabled)(nil)
 
-type fastReflection_MsgCreateDevshardEscrow MsgCreateDevshardEscrow
+type fastReflection_MsgSetDevshardRequestsEnabled MsgSetDevshardRequestsEnabled
 
-func (x *MsgCreateDevshardEscrow) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgCreateDevshardEscrow)(x)
+func (x *MsgSetDevshardRequestsEnabled) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSetDevshardRequestsEnabled)(x)
 }
 
-func (x *MsgCreateDevshardEscrow) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[68]
+func (x *MsgSetDevshardRequestsEnabled) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[74]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -36213,43 +39453,43 @@ func (x *MsgCreateDevshardEscrow) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgCreateDevshardEscrow_messageType fastReflection_MsgCreateDevshardEscrow_messageType
-var _ protoreflect.MessageType = fastReflection_MsgCreateDevshardEscrow_messageType{}
+var _fastReflection_MsgSetDevshardRequestsEnabled_messageType fastReflection_MsgSetDevshardRequestsEnabled_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSetDevshardRequestsEnabled_messageType{}
 
-type fastReflection_MsgCreateDevshardEscrow_messageType struct{}
+type fastReflection_MsgSetDevshardRequestsEnabled_messageType struct{}
 
-func (x fastReflection_MsgCreateDevshardEscrow_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgCreateDevshardEscrow)(nil)
+func (x fastReflection_MsgSetDevshardRequestsEnabled_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSetDevshardRequestsEnabled)(nil)
 }
-func (x fastReflection_MsgCreateDevshardEscrow_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgCreateDevshardEscrow)
+func (x fastReflection_MsgSetDevshardRequestsEnabled_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSetDevshardRequestsEnabled)
 }
-func (x fastReflection_MsgCreateDevshardEscrow_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreateDevshardEscrow
+func (x fastReflection_MsgSetDevshardRequestsEnabled_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetDevshardRequestsEnabled
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgCreateDevshardEscrow) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreateDevshardEscrow
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetDevshardRequestsEnabled
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgCreateDevshardEscrow) Type() protoreflect.MessageType {
-	return _fastReflection_MsgCreateDevshardEscrow_messageType
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSetDevshardRequestsEnabled_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgCreateDevshardEscrow) New() protoreflect.Message {
-	return new(fastReflection_MsgCreateDevshardEscrow)
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) New() protoreflect.Message {
+	return new(fastReflection_MsgSetDevshardRequestsEnabled)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgCreateDevshardEscrow) Interface() protoreflect.ProtoMessage {
-	return (*MsgCreateDevshardEscrow)(x)
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Interface() protoreflect.ProtoMessage {
+	return (*MsgSetDevshardRequestsEnabled)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -36257,22 +39497,16 @@ func (x *fastReflection_MsgCreateDevshardEscrow) Interface() protoreflect.ProtoM
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgCreateDevshardEscrow) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Creator != "" {
-		value := protoreflect.ValueOfString(x.Creator)
-		if !f(fd_MsgCreateDevshardEscrow_creator, value) {
-			return
-		}
-	}
-	if x.Amount != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Amount)
-		if !f(fd_MsgCreateDevshardEscrow_amount, value) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Authority != "" {
+		value := protoreflect.ValueOfString(x.Authority)
+		if !f(fd_MsgSetDevshardRequestsEnabled_authority, value) {
 			return
 		}
 	}
-	if x.ModelId != "" {
-		value := protoreflect.ValueOfString(x.ModelId)
-		if !f(fd_MsgCreateDevshardEscrow_model_id, value) {
+	if x.Enabled != false {
+		value := protoreflect.ValueOfBool(x.Enabled)
+		if !f(fd_MsgSetDevshardRequestsEnabled_enabled, value) {
 			return
 		}
 	}
@@ -36289,19 +39523,17 @@ func (x *fastReflection_MsgCreateDevshardEscrow) Range(f func(protoreflect.Field
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgCreateDevshardEscrow) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrow.creator":
-		return x.Creator != ""
-	case "inference.inference.MsgCreateDevshardEscrow.amount":
-		return x.Amount != uint64(0)
-	case "inference.inference.MsgCreateDevshardEscrow.model_id":
-		return x.ModelId != ""
+	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
+		return x.Authority != ""
+	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
+		return x.Enabled != false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36311,19 +39543,17 @@ func (x *fastReflection_MsgCreateDevshardEscrow) Has(fd protoreflect.FieldDescri
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrow) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrow.creator":
-		x.Creator = ""
-	case "inference.inference.MsgCreateDevshardEscrow.amount":
-		x.Amount = uint64(0)
-	case "inference.inference.MsgCreateDevshardEscrow.model_id":
-		x.ModelId = ""
+	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
+		x.Authority = ""
+	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
+		x.Enabled = false
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36333,22 +39563,19 @@ func (x *fastReflection_MsgCreateDevshardEscrow) Clear(fd protoreflect.FieldDesc
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgCreateDevshardEscrow) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrow.creator":
-		value := x.Creator
-		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgCreateDevshardEscrow.amount":
-		value := x.Amount
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgCreateDevshardEscrow.model_id":
-		value := x.ModelId
+	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
+		value := x.Authority
 		return protoreflect.ValueOfString(value)
+	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
+		value := x.Enabled
+		return protoreflect.ValueOfBool(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -36362,19 +39589,17 @@ func (x *fastReflection_MsgCreateDevshardEscrow) Get(descriptor protoreflect.Fie
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrow) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrow.creator":
-		x.Creator = value.Interface().(string)
-	case "inference.inference.MsgCreateDevshardEscrow.amount":
-		x.Amount = value.Uint()
-	case "inference.inference.MsgCreateDevshardEscrow.model_id":
-		x.ModelId = value.Interface().(string)
+	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
+		x.Authority = value.Interface().(string)
+	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
+		x.Enabled = value.Bool()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36388,48 +39613,44 @@ func (x *fastReflection_MsgCreateDevshardEscrow) Set(fd protoreflect.FieldDescri
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrow) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrow.creator":
-		panic(fmt.Errorf("field creator of message inference.inference.MsgCreateDevshardEscrow is not mutable"))
-	case "inference.inference.MsgCreateDevshardEscrow.amount":
-		panic(fmt.Errorf("field amount of message inference.inference.MsgCreateDevshardEscrow is not mutable"))
-	case "inference.inference.MsgCreateDevshardEscrow.model_id":
-		panic(fmt.Errorf("field model_id of message inference.inference.MsgCreateDevshardEscrow is not mutable"))
+	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
+		panic(fmt.Errorf("field authority of message inference.inference.MsgSetDevshardRequestsEnabled is not mutable"))
+	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
+		panic(fmt.Errorf("field enabled of message inference.inference.MsgSetDevshardRequestsEnabled is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgCreateDevshardEscrow) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrow.creator":
-		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgCreateDevshardEscrow.amount":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgCreateDevshardEscrow.model_id":
+	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
 		return protoreflect.ValueOfString("")
+	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
+		return protoreflect.ValueOfBool(false)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgCreateDevshardEscrow) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreateDevshardEscrow", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSetDevshardRequestsEnabled", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -36437,7 +39658,7 @@ func (x *fastReflection_MsgCreateDevshardEscrow) WhichOneof(d protoreflect.Oneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgCreateDevshardEscrow) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -36448,7 +39669,7 @@ func (x *fastReflection_MsgCreateDevshardEscrow) GetUnknown() protoreflect.RawFi
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrow) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -36460,7 +39681,7 @@ func (x *fastReflection_MsgCreateDevshardEscrow) SetUnknown(fields protoreflect.
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgCreateDevshardEscrow) IsValid() bool {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) IsValid() bool {
 	return x != nil
 }
 
@@ -36470,9 +39691,9 @@ func (x *fastReflection_MsgCreateDevshardEscrow) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgCreateDevshardEscrow)
+		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabled)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36484,16 +39705,12 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 		var n int
 		var l int
 		_ = l
-		l = len(x.Creator)
+		l = len(x.Authority)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Amount != 0 {
-			n += 1 + runtime.Sov(uint64(x.Amount))
-		}
-		l = len(x.ModelId)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
+		if x.Enabled {
+			n += 2
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -36505,7 +39722,7 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreateDevshardEscrow)
+		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabled)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36524,22 +39741,20 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.ModelId) > 0 {
-			i -= len(x.ModelId)
-			copy(dAtA[i:], x.ModelId)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ModelId)))
+		if x.Enabled {
 			i--
-			dAtA[i] = 0x1a
-		}
-		if x.Amount != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount))
+			if x.Enabled {
+				dAtA[i] = 1
+			} else {
+				dAtA[i] = 0
+			}
 			i--
 			dAtA[i] = 0x10
 		}
-		if len(x.Creator) > 0 {
-			i -= len(x.Creator)
-			copy(dAtA[i:], x.Creator)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
+		if len(x.Authority) > 0 {
+			i -= len(x.Authority)
+			copy(dAtA[i:], x.Authority)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -36554,7 +39769,7 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreateDevshardEscrow)
+		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabled)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36586,15 +39801,15 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrow: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabled: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrow: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabled: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -36622,32 +39837,13 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Creator = string(dAtA[iNdEx:postIndex])
+				x.Authority = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
-				}
-				x.Amount = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Amount |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
 				}
-				var stringLen uint64
+				var v int
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -36657,24 +39853,12 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					stringLen |= uint64(b&0x7F) << shift
+					v |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				intStringLen := int(stringLen)
-				if intStringLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + intStringLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.ModelId = string(dAtA[iNdEx:postIndex])
-				iNdEx = postIndex
+				x.Enabled = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -36711,26 +39895,24 @@ func (x *fastReflection_MsgCreateDevshardEscrow) ProtoMethods() *protoiface.Meth
 }
 
 var (
-	md_MsgCreateDevshardEscrowResponse           protoreflect.MessageDescriptor
-	fd_MsgCreateDevshardEscrowResponse_escrow_id protoreflect.FieldDescriptor
+	md_MsgSetDevshardRequestsEnabledResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgCreateDevshardEscrowResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCreateDevshardEscrowResponse")
-	fd_MsgCreateDevshardEscrowResponse_escrow_id = md_MsgCreateDevshardEscrowResponse.Fields().ByName("escrow_id")
+	md_MsgSetDevshardRequestsEnabledResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSetDevshardRequestsEnabledResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgCreateDevshardEscrowResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgSetDevshardRequestsEnabledResponse)(nil)
 
-type fastReflection_MsgCreateDevshardEscrowResponse MsgCreateDevshardEscrowResponse
+type fastReflection_MsgSetDevshardRequestsEnabledResponse MsgSetDevshardRequestsEnabledResponse
 
-func (x *MsgCreateDevshardEscrowResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgCreateDevshardEscrowResponse)(x)
+func (x *MsgSetDevshardRequestsEnabledResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgSetDevshardRequestsEnabledResponse)(x)
 }
 
-func (x *MsgCreateDevshardEscrowResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[69]
+func (x *MsgSetDevshardRequestsEnabledResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[75]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -36741,43 +39923,43 @@ func (x *MsgCreateDevshardEscrowResponse) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgCreateDevshardEscrowResponse_messageType fastReflection_MsgCreateDevshardEscrowResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgCreateDevshardEscrowResponse_messageType{}
+var _fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType{}
 
-type fastReflection_MsgCreateDevshardEscrowResponse_messageType struct{}
+type fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType struct{}
 
-func (x fastReflection_MsgCreateDevshardEscrowResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgCreateDevshardEscrowResponse)(nil)
+func (x fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgSetDevshardRequestsEnabledResponse)(nil)
 }
-func (x fastReflection_MsgCreateDevshardEscrowResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgCreateDevshardEscrowResponse)
+func (x fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgSetDevshardRequestsEnabledResponse)
 }
-func (x fastReflection_MsgCreateDevshardEscrowResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreateDevshardEscrowResponse
+func (x fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetDevshardRequestsEnabledResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgCreateDevshardEscrowResponse
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgSetDevshardRequestsEnabledResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgCreateDevshardEscrowResponse_messageType
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgCreateDevshardEscrowResponse)
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgSetDevshardRequestsEnabledResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgCreateDevshardEscrowResponse)(x)
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgSetDevshardRequestsEnabledResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -36785,13 +39967,7 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.EscrowId != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EscrowId)
-		if !f(fd_MsgCreateDevshardEscrowResponse_escrow_id, value) {
-			return
-		}
-	}
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -36805,15 +39981,13 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
-		return x.EscrowId != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36823,15 +39997,13 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
-		x.EscrowId = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36841,16 +40013,13 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
-		value := x.EscrowId
-		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -36864,15 +40033,13 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
-		x.EscrowId = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -36886,40 +40053,36 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
-		panic(fmt.Errorf("field escrow_id of message inference.inference.MsgCreateDevshardEscrowResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgCreateDevshardEscrowResponse.escrow_id":
-		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCreateDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgCreateDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCreateDevshardEscrowResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSetDevshardRequestsEnabledResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -36927,7 +40090,7 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -36938,7 +40101,7 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -36950,7 +40113,7 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) IsValid() bool {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -36960,9 +40123,9 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgCreateDevshardEscrowResponse)
+		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabledResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -36974,9 +40137,6 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoif
 		var n int
 		var l int
 		_ = l
-		if x.EscrowId != 0 {
-			n += 1 + runtime.Sov(uint64(x.EscrowId))
-		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -36987,7 +40147,7 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreateDevshardEscrowResponse)
+		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabledResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37006,11 +40166,6 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.EscrowId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EscrowId))
-			i--
-			dAtA[i] = 0x8
-		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -37022,7 +40177,7 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgCreateDevshardEscrowResponse)
+		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabledResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37054,31 +40209,12 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrowResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabledResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCreateDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabledResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
-			case 1:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
-				}
-				x.EscrowId = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EscrowId |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -37114,145 +40250,33 @@ func (x *fastReflection_MsgCreateDevshardEscrowResponse) ProtoMethods() *protoif
 	}
 }
 
-var _ protoreflect.List = (*_MsgSettleDevshardEscrow_6_list)(nil)
-
-type _MsgSettleDevshardEscrow_6_list struct {
-	list *[]*DevshardSettlementHostStats
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DevshardSettlementHostStats)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DevshardSettlementHostStats)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) AppendMutable() protoreflect.Value {
-	v := new(DevshardSettlementHostStats)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) NewElement() protoreflect.Value {
-	v := new(DevshardSettlementHostStats)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSettleDevshardEscrow_6_list) IsValid() bool {
-	return x.list != nil
-}
-
-var _ protoreflect.List = (*_MsgSettleDevshardEscrow_7_list)(nil)
-
-type _MsgSettleDevshardEscrow_7_list struct {
-	list *[]*DevshardSlotSignature
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) Len() int {
-	if x.list == nil {
-		return 0
-	}
-	return len(*x.list)
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) Get(i int) protoreflect.Value {
-	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) Set(i int, value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DevshardSlotSignature)
-	(*x.list)[i] = concreteValue
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) Append(value protoreflect.Value) {
-	valueUnwrapped := value.Message()
-	concreteValue := valueUnwrapped.Interface().(*DevshardSlotSignature)
-	*x.list = append(*x.list, concreteValue)
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) AppendMutable() protoreflect.Value {
-	v := new(DevshardSlotSignature)
-	*x.list = append(*x.list, v)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) Truncate(n int) {
-	for i := n; i < len(*x.list); i++ {
-		(*x.list)[i] = nil
-	}
-	*x.list = (*x.list)[:n]
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) NewElement() protoreflect.Value {
-	v := new(DevshardSlotSignature)
-	return protoreflect.ValueOfMessage(v.ProtoReflect())
-}
-
-func (x *_MsgSettleDevshardEscrow_7_list) IsValid() bool {
-	return x.list != nil
-}
-
 var (
-	md_MsgSettleDevshardEscrow                                 protoreflect.MessageDescriptor
-	fd_MsgSettleDevshardEscrow_settler                         protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_escrow_id                       protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_state_root_and_protocol_version protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_state_root                      protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_nonce                           protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_rest_hash                       protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_host_stats                      protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_signatures                      protoreflect.FieldDescriptor
-	fd_MsgSettleDevshardEscrow_fees                            protoreflect.FieldDescriptor
+	md_MsgScheduleMaintenance                 protoreflect.MessageDescriptor
+	fd_MsgScheduleMaintenance_creator         protoreflect.FieldDescriptor
+	fd_MsgScheduleMaintenance_participant     protoreflect.FieldDescriptor
+	fd_MsgScheduleMaintenance_start_height    protoreflect.FieldDescriptor
+	fd_MsgScheduleMaintenance_duration_blocks protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSettleDevshardEscrow = File_inference_inference_tx_proto.Messages().ByName("MsgSettleDevshardEscrow")
-	fd_MsgSettleDevshardEscrow_settler = md_MsgSettleDevshardEscrow.Fields().ByName("settler")
-	fd_MsgSettleDevshardEscrow_escrow_id = md_MsgSettleDevshardEscrow.Fields().ByName("escrow_id")
-	fd_MsgSettleDevshardEscrow_state_root_and_protocol_version = md_MsgSettleDevshardEscrow.Fields().ByName("state_root_and_protocol_version")
-	fd_MsgSettleDevshardEscrow_state_root = md_MsgSettleDevshardEscrow.Fields().ByName("state_root")
-	fd_MsgSettleDevshardEscrow_nonce = md_MsgSettleDevshardEscrow.Fields().ByName("nonce")
-	fd_MsgSettleDevshardEscrow_rest_hash = md_MsgSettleDevshardEscrow.Fields().ByName("rest_hash")
-	fd_MsgSettleDevshardEscrow_host_stats = md_MsgSettleDevshardEscrow.Fields().ByName("host_stats")
-	fd_MsgSettleDevshardEscrow_signatures = md_MsgSettleDevshardEscrow.Fields().ByName("signatures")
-	fd_MsgSettleDevshardEscrow_fees = md_MsgSettleDevshardEscrow.Fields().ByName("fees")
+	md_MsgScheduleMaintenance = File_inference_inference_tx_proto.Messages().ByName("MsgScheduleMaintenance")
+	fd_MsgScheduleMaintenance_creator = md_MsgScheduleMaintenance.Fields().ByName("creator")
+	fd_MsgScheduleMaintenance_participant = md_MsgScheduleMaintenance.Fields().ByName("participant")
+	fd_MsgScheduleMaintenance_start_height = md_MsgScheduleMaintenance.Fields().ByName("start_height")
+	fd_MsgScheduleMaintenance_duration_blocks = md_MsgScheduleMaintenance.Fields().ByName("duration_blocks")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSettleDevshardEscrow)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgScheduleMaintenance)(nil)
 
-type fastReflection_MsgSettleDevshardEscrow MsgSettleDevshardEscrow
+type fastReflection_MsgScheduleMaintenance MsgScheduleMaintenance
 
-func (x *MsgSettleDevshardEscrow) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSettleDevshardEscrow)(x)
+func (x *MsgScheduleMaintenance) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgScheduleMaintenance)(x)
 }
 
-func (x *MsgSettleDevshardEscrow) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[70]
+func (x *MsgScheduleMaintenance) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[76]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -37263,43 +40287,43 @@ func (x *MsgSettleDevshardEscrow) slowProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSettleDevshardEscrow_messageType fastReflection_MsgSettleDevshardEscrow_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSettleDevshardEscrow_messageType{}
+var _fastReflection_MsgScheduleMaintenance_messageType fastReflection_MsgScheduleMaintenance_messageType
+var _ protoreflect.MessageType = fastReflection_MsgScheduleMaintenance_messageType{}
 
-type fastReflection_MsgSettleDevshardEscrow_messageType struct{}
+type fastReflection_MsgScheduleMaintenance_messageType struct{}
 
-func (x fastReflection_MsgSettleDevshardEscrow_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSettleDevshardEscrow)(nil)
+func (x fastReflection_MsgScheduleMaintenance_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgScheduleMaintenance)(nil)
 }
-func (x fastReflection_MsgSettleDevshardEscrow_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSettleDevshardEscrow)
+func (x fastReflection_MsgScheduleMaintenance_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgScheduleMaintenance)
 }
-func (x fastReflection_MsgSettleDevshardEscrow_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSettleDevshardEscrow
+func (x fastReflection_MsgScheduleMaintenance_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgScheduleMaintenance
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSettleDevshardEscrow) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSettleDevshardEscrow
+func (x *fastReflection_MsgScheduleMaintenance) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgScheduleMaintenance
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSettleDevshardEscrow) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSettleDevshardEscrow_messageType
+func (x *fastReflection_MsgScheduleMaintenance) Type() protoreflect.MessageType {
+	return _fastReflection_MsgScheduleMaintenance_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSettleDevshardEscrow) New() protoreflect.Message {
-	return new(fastReflection_MsgSettleDevshardEscrow)
+func (x *fastReflection_MsgScheduleMaintenance) New() protoreflect.Message {
+	return new(fastReflection_MsgScheduleMaintenance)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSettleDevshardEscrow) Interface() protoreflect.ProtoMessage {
-	return (*MsgSettleDevshardEscrow)(x)
+func (x *fastReflection_MsgScheduleMaintenance) Interface() protoreflect.ProtoMessage {
+	return (*MsgScheduleMaintenance)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -37307,99 +40331,59 @@ func (x *fastReflection_MsgSettleDevshardEscrow) Interface() protoreflect.ProtoM
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSettleDevshardEscrow) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Settler != "" {
-		value := protoreflect.ValueOfString(x.Settler)
-		if !f(fd_MsgSettleDevshardEscrow_settler, value) {
-			return
-		}
-	}
-	if x.EscrowId != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.EscrowId)
-		if !f(fd_MsgSettleDevshardEscrow_escrow_id, value) {
-			return
-		}
-	}
-	if x.StateRootAndProtocolVersion != "" {
-		value := protoreflect.ValueOfString(x.StateRootAndProtocolVersion)
-		if !f(fd_MsgSettleDevshardEscrow_state_root_and_protocol_version, value) {
-			return
-		}
-	}
-	if len(x.StateRoot) != 0 {
-		value := protoreflect.ValueOfBytes(x.StateRoot)
-		if !f(fd_MsgSettleDevshardEscrow_state_root, value) {
-			return
-		}
-	}
-	if x.Nonce != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Nonce)
-		if !f(fd_MsgSettleDevshardEscrow_nonce, value) {
-			return
-		}
-	}
-	if len(x.RestHash) != 0 {
-		value := protoreflect.ValueOfBytes(x.RestHash)
-		if !f(fd_MsgSettleDevshardEscrow_rest_hash, value) {
+func (x *fastReflection_MsgScheduleMaintenance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgScheduleMaintenance_creator, value) {
 			return
 		}
 	}
-	if len(x.HostStats) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_6_list{list: &x.HostStats})
-		if !f(fd_MsgSettleDevshardEscrow_host_stats, value) {
+	if x.Participant != "" {
+		value := protoreflect.ValueOfString(x.Participant)
+		if !f(fd_MsgScheduleMaintenance_participant, value) {
 			return
 		}
 	}
-	if len(x.Signatures) != 0 {
-		value := protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_7_list{list: &x.Signatures})
-		if !f(fd_MsgSettleDevshardEscrow_signatures, value) {
+	if x.StartHeight != int64(0) {
+		value := protoreflect.ValueOfInt64(x.StartHeight)
+		if !f(fd_MsgScheduleMaintenance_start_height, value) {
 			return
 		}
 	}
-	if x.Fees != uint64(0) {
-		value := protoreflect.ValueOfUint64(x.Fees)
-		if !f(fd_MsgSettleDevshardEscrow_fees, value) {
+	if x.DurationBlocks != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.DurationBlocks)
+		if !f(fd_MsgScheduleMaintenance_duration_blocks, value) {
 			return
 		}
-	}
-}
-
-// Has reports whether a field is populated.
-//
-// Some fields have the property of nullability where it is possible to
-// distinguish between the default value of a field and whether the field
-// was explicitly populated with the default value. Singular message fields,
-// member fields of a oneof, and proto2 scalar fields are nullable. Such
-// fields are populated only if explicitly set.
-//
-// In other cases (aside from the nullable cases above),
-// a proto3 scalar field is populated if it contains a non-zero value, and
-// a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSettleDevshardEscrow) Has(fd protoreflect.FieldDescriptor) bool {
-	switch fd.FullName() {
-	case "inference.inference.MsgSettleDevshardEscrow.settler":
-		return x.Settler != ""
-	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
-		return x.EscrowId != uint64(0)
-	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
-		return x.StateRootAndProtocolVersion != ""
-	case "inference.inference.MsgSettleDevshardEscrow.state_root":
-		return len(x.StateRoot) != 0
-	case "inference.inference.MsgSettleDevshardEscrow.nonce":
-		return x.Nonce != uint64(0)
-	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
-		return len(x.RestHash) != 0
-	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
-		return len(x.HostStats) != 0
-	case "inference.inference.MsgSettleDevshardEscrow.signatures":
-		return len(x.Signatures) != 0
-	case "inference.inference.MsgSettleDevshardEscrow.fees":
-		return x.Fees != uint64(0)
+	}
+}
+
+// Has reports whether a field is populated.
+//
+// Some fields have the property of nullability where it is possible to
+// distinguish between the default value of a field and whether the field
+// was explicitly populated with the default value. Singular message fields,
+// member fields of a oneof, and proto2 scalar fields are nullable. Such
+// fields are populated only if explicitly set.
+//
+// In other cases (aside from the nullable cases above),
+// a proto3 scalar field is populated if it contains a non-zero value, and
+// a repeated field is populated if it is non-empty.
+func (x *fastReflection_MsgScheduleMaintenance) Has(fd protoreflect.FieldDescriptor) bool {
+	switch fd.FullName() {
+	case "inference.inference.MsgScheduleMaintenance.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgScheduleMaintenance.participant":
+		return x.Participant != ""
+	case "inference.inference.MsgScheduleMaintenance.start_height":
+		return x.StartHeight != int64(0)
+	case "inference.inference.MsgScheduleMaintenance.duration_blocks":
+		return x.DurationBlocks != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37409,31 +40393,21 @@ func (x *fastReflection_MsgSettleDevshardEscrow) Has(fd protoreflect.FieldDescri
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrow) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgScheduleMaintenance) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSettleDevshardEscrow.settler":
-		x.Settler = ""
-	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
-		x.EscrowId = uint64(0)
-	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
-		x.StateRootAndProtocolVersion = ""
-	case "inference.inference.MsgSettleDevshardEscrow.state_root":
-		x.StateRoot = nil
-	case "inference.inference.MsgSettleDevshardEscrow.nonce":
-		x.Nonce = uint64(0)
-	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
-		x.RestHash = nil
-	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
-		x.HostStats = nil
-	case "inference.inference.MsgSettleDevshardEscrow.signatures":
-		x.Signatures = nil
-	case "inference.inference.MsgSettleDevshardEscrow.fees":
-		x.Fees = uint64(0)
+	case "inference.inference.MsgScheduleMaintenance.creator":
+		x.Creator = ""
+	case "inference.inference.MsgScheduleMaintenance.participant":
+		x.Participant = ""
+	case "inference.inference.MsgScheduleMaintenance.start_height":
+		x.StartHeight = int64(0)
+	case "inference.inference.MsgScheduleMaintenance.duration_blocks":
+		x.DurationBlocks = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37443,46 +40417,25 @@ func (x *fastReflection_MsgSettleDevshardEscrow) Clear(fd protoreflect.FieldDesc
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSettleDevshardEscrow) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgScheduleMaintenance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSettleDevshardEscrow.settler":
-		value := x.Settler
+	case "inference.inference.MsgScheduleMaintenance.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
-		value := x.EscrowId
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
-		value := x.StateRootAndProtocolVersion
+	case "inference.inference.MsgScheduleMaintenance.participant":
+		value := x.Participant
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSettleDevshardEscrow.state_root":
-		value := x.StateRoot
-		return protoreflect.ValueOfBytes(value)
-	case "inference.inference.MsgSettleDevshardEscrow.nonce":
-		value := x.Nonce
-		return protoreflect.ValueOfUint64(value)
-	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
-		value := x.RestHash
-		return protoreflect.ValueOfBytes(value)
-	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
-		if len(x.HostStats) == 0 {
-			return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_6_list{})
-		}
-		listValue := &_MsgSettleDevshardEscrow_6_list{list: &x.HostStats}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgSettleDevshardEscrow.signatures":
-		if len(x.Signatures) == 0 {
-			return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_7_list{})
-		}
-		listValue := &_MsgSettleDevshardEscrow_7_list{list: &x.Signatures}
-		return protoreflect.ValueOfList(listValue)
-	case "inference.inference.MsgSettleDevshardEscrow.fees":
-		value := x.Fees
+	case "inference.inference.MsgScheduleMaintenance.start_height":
+		value := x.StartHeight
+		return protoreflect.ValueOfInt64(value)
+	case "inference.inference.MsgScheduleMaintenance.duration_blocks":
+		value := x.DurationBlocks
 		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenance does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -37496,35 +40449,21 @@ func (x *fastReflection_MsgSettleDevshardEscrow) Get(descriptor protoreflect.Fie
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrow) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgScheduleMaintenance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSettleDevshardEscrow.settler":
-		x.Settler = value.Interface().(string)
-	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
-		x.EscrowId = value.Uint()
-	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
-		x.StateRootAndProtocolVersion = value.Interface().(string)
-	case "inference.inference.MsgSettleDevshardEscrow.state_root":
-		x.StateRoot = value.Bytes()
-	case "inference.inference.MsgSettleDevshardEscrow.nonce":
-		x.Nonce = value.Uint()
-	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
-		x.RestHash = value.Bytes()
-	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
-		lv := value.List()
-		clv := lv.(*_MsgSettleDevshardEscrow_6_list)
-		x.HostStats = *clv.list
-	case "inference.inference.MsgSettleDevshardEscrow.signatures":
-		lv := value.List()
-		clv := lv.(*_MsgSettleDevshardEscrow_7_list)
-		x.Signatures = *clv.list
-	case "inference.inference.MsgSettleDevshardEscrow.fees":
-		x.Fees = value.Uint()
+	case "inference.inference.MsgScheduleMaintenance.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgScheduleMaintenance.participant":
+		x.Participant = value.Interface().(string)
+	case "inference.inference.MsgScheduleMaintenance.start_height":
+		x.StartHeight = value.Int()
+	case "inference.inference.MsgScheduleMaintenance.duration_blocks":
+		x.DurationBlocks = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -37538,82 +40477,52 @@ func (x *fastReflection_MsgSettleDevshardEscrow) Set(fd protoreflect.FieldDescri
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrow) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgScheduleMaintenance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
-		if x.HostStats == nil {
-			x.HostStats = []*DevshardSettlementHostStats{}
-		}
-		value := &_MsgSettleDevshardEscrow_6_list{list: &x.HostStats}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSettleDevshardEscrow.signatures":
-		if x.Signatures == nil {
-			x.Signatures = []*DevshardSlotSignature{}
-		}
-		value := &_MsgSettleDevshardEscrow_7_list{list: &x.Signatures}
-		return protoreflect.ValueOfList(value)
-	case "inference.inference.MsgSettleDevshardEscrow.settler":
-		panic(fmt.Errorf("field settler of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
-	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
-		panic(fmt.Errorf("field escrow_id of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
-	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
-		panic(fmt.Errorf("field state_root_and_protocol_version of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
-	case "inference.inference.MsgSettleDevshardEscrow.state_root":
-		panic(fmt.Errorf("field state_root of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
-	case "inference.inference.MsgSettleDevshardEscrow.nonce":
-		panic(fmt.Errorf("field nonce of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
-	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
-		panic(fmt.Errorf("field rest_hash of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
-	case "inference.inference.MsgSettleDevshardEscrow.fees":
-		panic(fmt.Errorf("field fees of message inference.inference.MsgSettleDevshardEscrow is not mutable"))
+	case "inference.inference.MsgScheduleMaintenance.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgScheduleMaintenance is not mutable"))
+	case "inference.inference.MsgScheduleMaintenance.participant":
+		panic(fmt.Errorf("field participant of message inference.inference.MsgScheduleMaintenance is not mutable"))
+	case "inference.inference.MsgScheduleMaintenance.start_height":
+		panic(fmt.Errorf("field start_height of message inference.inference.MsgScheduleMaintenance is not mutable"))
+	case "inference.inference.MsgScheduleMaintenance.duration_blocks":
+		panic(fmt.Errorf("field duration_blocks of message inference.inference.MsgScheduleMaintenance is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSettleDevshardEscrow) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgScheduleMaintenance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSettleDevshardEscrow.settler":
+	case "inference.inference.MsgScheduleMaintenance.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSettleDevshardEscrow.escrow_id":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgSettleDevshardEscrow.state_root_and_protocol_version":
+	case "inference.inference.MsgScheduleMaintenance.participant":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSettleDevshardEscrow.state_root":
-		return protoreflect.ValueOfBytes(nil)
-	case "inference.inference.MsgSettleDevshardEscrow.nonce":
-		return protoreflect.ValueOfUint64(uint64(0))
-	case "inference.inference.MsgSettleDevshardEscrow.rest_hash":
-		return protoreflect.ValueOfBytes(nil)
-	case "inference.inference.MsgSettleDevshardEscrow.host_stats":
-		list := []*DevshardSettlementHostStats{}
-		return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_6_list{list: &list})
-	case "inference.inference.MsgSettleDevshardEscrow.signatures":
-		list := []*DevshardSlotSignature{}
-		return protoreflect.ValueOfList(&_MsgSettleDevshardEscrow_7_list{list: &list})
-	case "inference.inference.MsgSettleDevshardEscrow.fees":
+	case "inference.inference.MsgScheduleMaintenance.start_height":
+		return protoreflect.ValueOfInt64(int64(0))
+	case "inference.inference.MsgScheduleMaintenance.duration_blocks":
 		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrow"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrow does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSettleDevshardEscrow) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgScheduleMaintenance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSettleDevshardEscrow", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgScheduleMaintenance", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -37621,7 +40530,7 @@ func (x *fastReflection_MsgSettleDevshardEscrow) WhichOneof(d protoreflect.Oneof
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSettleDevshardEscrow) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgScheduleMaintenance) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -37632,7 +40541,7 @@ func (x *fastReflection_MsgSettleDevshardEscrow) GetUnknown() protoreflect.RawFi
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrow) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgScheduleMaintenance) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -37644,7 +40553,7 @@ func (x *fastReflection_MsgSettleDevshardEscrow) SetUnknown(fields protoreflect.
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSettleDevshardEscrow) IsValid() bool {
+func (x *fastReflection_MsgScheduleMaintenance) IsValid() bool {
 	return x != nil
 }
 
@@ -37654,9 +40563,9 @@ func (x *fastReflection_MsgSettleDevshardEscrow) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgScheduleMaintenance) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSettleDevshardEscrow)
+		x := input.Message.Interface().(*MsgScheduleMaintenance)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37668,42 +40577,19 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 		var n int
 		var l int
 		_ = l
-		l = len(x.Settler)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		if x.EscrowId != 0 {
-			n += 1 + runtime.Sov(uint64(x.EscrowId))
-		}
-		l = len(x.StateRootAndProtocolVersion)
-		if l > 0 {
-			n += 1 + l + runtime.Sov(uint64(l))
-		}
-		l = len(x.StateRoot)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Nonce != 0 {
-			n += 1 + runtime.Sov(uint64(x.Nonce))
-		}
-		l = len(x.RestHash)
+		l = len(x.Participant)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if len(x.HostStats) > 0 {
-			for _, e := range x.HostStats {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
-		}
-		if len(x.Signatures) > 0 {
-			for _, e := range x.Signatures {
-				l = options.Size(e)
-				n += 1 + l + runtime.Sov(uint64(l))
-			}
+		if x.StartHeight != 0 {
+			n += 1 + runtime.Sov(uint64(x.StartHeight))
 		}
-		if x.Fees != 0 {
-			n += 1 + runtime.Sov(uint64(x.Fees))
+		if x.DurationBlocks != 0 {
+			n += 1 + runtime.Sov(uint64(x.DurationBlocks))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -37715,7 +40601,7 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSettleDevshardEscrow)
+		x := input.Message.Interface().(*MsgScheduleMaintenance)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37734,78 +40620,27 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if len(x.StateRootAndProtocolVersion) > 0 {
-			i -= len(x.StateRootAndProtocolVersion)
-			copy(dAtA[i:], x.StateRootAndProtocolVersion)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.StateRootAndProtocolVersion)))
-			i--
-			dAtA[i] = 0x4a
-		}
-		if x.Fees != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Fees))
-			i--
-			dAtA[i] = 0x40
-		}
-		if len(x.Signatures) > 0 {
-			for iNdEx := len(x.Signatures) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.Signatures[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x3a
-			}
-		}
-		if len(x.HostStats) > 0 {
-			for iNdEx := len(x.HostStats) - 1; iNdEx >= 0; iNdEx-- {
-				encoded, err := options.Marshal(x.HostStats[iNdEx])
-				if err != nil {
-					return protoiface.MarshalOutput{
-						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
-						Buf:               input.Buf,
-					}, err
-				}
-				i -= len(encoded)
-				copy(dAtA[i:], encoded)
-				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
-				i--
-				dAtA[i] = 0x32
-			}
-		}
-		if len(x.RestHash) > 0 {
-			i -= len(x.RestHash)
-			copy(dAtA[i:], x.RestHash)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.RestHash)))
-			i--
-			dAtA[i] = 0x2a
-		}
-		if x.Nonce != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.Nonce))
+		if x.DurationBlocks != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.DurationBlocks))
 			i--
 			dAtA[i] = 0x20
 		}
-		if len(x.StateRoot) > 0 {
-			i -= len(x.StateRoot)
-			copy(dAtA[i:], x.StateRoot)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.StateRoot)))
+		if x.StartHeight != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.StartHeight))
 			i--
-			dAtA[i] = 0x1a
+			dAtA[i] = 0x18
 		}
-		if x.EscrowId != 0 {
-			i = runtime.EncodeVarint(dAtA, i, uint64(x.EscrowId))
+		if len(x.Participant) > 0 {
+			i -= len(x.Participant)
+			copy(dAtA[i:], x.Participant)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Participant)))
 			i--
-			dAtA[i] = 0x10
+			dAtA[i] = 0x12
 		}
-		if len(x.Settler) > 0 {
-			i -= len(x.Settler)
-			copy(dAtA[i:], x.Settler)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Settler)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -37820,7 +40655,7 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSettleDevshardEscrow)
+		x := input.Message.Interface().(*MsgScheduleMaintenance)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -37852,15 +40687,15 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrow: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgScheduleMaintenance: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrow: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgScheduleMaintenance: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Settler", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -37888,30 +40723,11 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Settler = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
-				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
-				}
-				x.EscrowId = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.EscrowId |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 9:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StateRootAndProtocolVersion", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -37939,134 +40755,13 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.StateRootAndProtocolVersion = string(dAtA[iNdEx:postIndex])
+				x.Participant = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 3:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StateRoot", wireType)
-				}
-				var byteLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					byteLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if byteLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + byteLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.StateRoot = append(x.StateRoot[:0], dAtA[iNdEx:postIndex]...)
-				if x.StateRoot == nil {
-					x.StateRoot = []byte{}
-				}
-				iNdEx = postIndex
-			case 4:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
-				}
-				x.Nonce = 0
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					x.Nonce |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-			case 5:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field RestHash", wireType)
-				}
-				var byteLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					byteLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if byteLen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + byteLen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.RestHash = append(x.RestHash[:0], dAtA[iNdEx:postIndex]...)
-				if x.RestHash == nil {
-					x.RestHash = []byte{}
-				}
-				iNdEx = postIndex
-			case 6:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field HostStats", wireType)
-				}
-				var msglen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					msglen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.HostStats = append(x.HostStats, &DevshardSettlementHostStats{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.HostStats[len(x.HostStats)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 7:
-				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
 				}
-				var msglen int
+				x.StartHeight = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -38076,31 +40771,16 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					msglen |= int(b&0x7F) << shift
+					x.StartHeight |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				if msglen < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				postIndex := iNdEx + msglen
-				if postIndex < 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
-				}
-				if postIndex > l {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
-				}
-				x.Signatures = append(x.Signatures, &DevshardSlotSignature{})
-				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Signatures[len(x.Signatures)-1]); err != nil {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
-				}
-				iNdEx = postIndex
-			case 8:
+			case 4:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fees", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field DurationBlocks", wireType)
 				}
-				x.Fees = 0
+				x.DurationBlocks = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -38110,7 +40790,7 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					x.Fees |= uint64(b&0x7F) << shift
+					x.DurationBlocks |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -38151,24 +40831,26 @@ func (x *fastReflection_MsgSettleDevshardEscrow) ProtoMethods() *protoiface.Meth
 }
 
 var (
-	md_MsgSettleDevshardEscrowResponse protoreflect.MessageDescriptor
+	md_MsgScheduleMaintenanceResponse                protoreflect.MessageDescriptor
+	fd_MsgScheduleMaintenanceResponse_reservation_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSettleDevshardEscrowResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSettleDevshardEscrowResponse")
+	md_MsgScheduleMaintenanceResponse = File_inference_inference_tx_proto.Messages().ByName("MsgScheduleMaintenanceResponse")
+	fd_MsgScheduleMaintenanceResponse_reservation_id = md_MsgScheduleMaintenanceResponse.Fields().ByName("reservation_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSettleDevshardEscrowResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgScheduleMaintenanceResponse)(nil)
 
-type fastReflection_MsgSettleDevshardEscrowResponse MsgSettleDevshardEscrowResponse
+type fastReflection_MsgScheduleMaintenanceResponse MsgScheduleMaintenanceResponse
 
-func (x *MsgSettleDevshardEscrowResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSettleDevshardEscrowResponse)(x)
+func (x *MsgScheduleMaintenanceResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgScheduleMaintenanceResponse)(x)
 }
 
-func (x *MsgSettleDevshardEscrowResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[71]
+func (x *MsgScheduleMaintenanceResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[77]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -38179,43 +40861,43 @@ func (x *MsgSettleDevshardEscrowResponse) slowProtoReflect() protoreflect.Messag
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSettleDevshardEscrowResponse_messageType fastReflection_MsgSettleDevshardEscrowResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSettleDevshardEscrowResponse_messageType{}
+var _fastReflection_MsgScheduleMaintenanceResponse_messageType fastReflection_MsgScheduleMaintenanceResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgScheduleMaintenanceResponse_messageType{}
 
-type fastReflection_MsgSettleDevshardEscrowResponse_messageType struct{}
+type fastReflection_MsgScheduleMaintenanceResponse_messageType struct{}
 
-func (x fastReflection_MsgSettleDevshardEscrowResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSettleDevshardEscrowResponse)(nil)
+func (x fastReflection_MsgScheduleMaintenanceResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgScheduleMaintenanceResponse)(nil)
 }
-func (x fastReflection_MsgSettleDevshardEscrowResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSettleDevshardEscrowResponse)
+func (x fastReflection_MsgScheduleMaintenanceResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgScheduleMaintenanceResponse)
 }
-func (x fastReflection_MsgSettleDevshardEscrowResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSettleDevshardEscrowResponse
+func (x fastReflection_MsgScheduleMaintenanceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgScheduleMaintenanceResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSettleDevshardEscrowResponse
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgScheduleMaintenanceResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSettleDevshardEscrowResponse_messageType
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgScheduleMaintenanceResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgSettleDevshardEscrowResponse)
+func (x *fastReflection_MsgScheduleMaintenanceResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgScheduleMaintenanceResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgSettleDevshardEscrowResponse)(x)
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgScheduleMaintenanceResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -38223,7 +40905,13 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) Interface() protoreflec
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.ReservationId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ReservationId)
+		if !f(fd_MsgScheduleMaintenanceResponse_reservation_id, value) {
+			return
+		}
+	}
 }
 
 // Has reports whether a field is populated.
@@ -38237,13 +40925,15 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) Range(f func(protorefle
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
+	case "inference.inference.MsgScheduleMaintenanceResponse.reservation_id":
+		return x.ReservationId != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38253,13 +40943,15 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) Has(fd protoreflect.Fie
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
+	case "inference.inference.MsgScheduleMaintenanceResponse.reservation_id":
+		x.ReservationId = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38269,13 +40961,16 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) Clear(fd protoreflect.F
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
+	case "inference.inference.MsgScheduleMaintenanceResponse.reservation_id":
+		value := x.ReservationId
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenanceResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -38289,13 +40984,15 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) Get(descriptor protoref
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
+	case "inference.inference.MsgScheduleMaintenanceResponse.reservation_id":
+		x.ReservationId = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38309,36 +41006,40 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) Set(fd protoreflect.Fie
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgScheduleMaintenanceResponse.reservation_id":
+		panic(fmt.Errorf("field reservation_id of message inference.inference.MsgScheduleMaintenanceResponse is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
+	case "inference.inference.MsgScheduleMaintenanceResponse.reservation_id":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSettleDevshardEscrowResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgScheduleMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSettleDevshardEscrowResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgScheduleMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSettleDevshardEscrowResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgScheduleMaintenanceResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -38346,7 +41047,7 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) WhichOneof(d protorefle
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -38357,7 +41058,7 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) GetUnknown() protorefle
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -38369,7 +41070,7 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) SetUnknown(fields proto
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) IsValid() bool {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -38379,9 +41080,9 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgScheduleMaintenanceResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSettleDevshardEscrowResponse)
+		x := input.Message.Interface().(*MsgScheduleMaintenanceResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38393,6 +41094,9 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoif
 		var n int
 		var l int
 		_ = l
+		if x.ReservationId != 0 {
+			n += 1 + runtime.Sov(uint64(x.ReservationId))
+		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
 		}
@@ -38403,7 +41107,7 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoif
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSettleDevshardEscrowResponse)
+		x := input.Message.Interface().(*MsgScheduleMaintenanceResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38422,6 +41126,11 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoif
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
+		if x.ReservationId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ReservationId))
+			i--
+			dAtA[i] = 0x8
+		}
 		if input.Buf != nil {
 			input.Buf = append(input.Buf, dAtA...)
 		} else {
@@ -38433,7 +41142,7 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoif
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSettleDevshardEscrowResponse)
+		x := input.Message.Interface().(*MsgScheduleMaintenanceResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38465,12 +41174,31 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoif
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrowResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgScheduleMaintenanceResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSettleDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgScheduleMaintenanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
+			case 1:
+				if wireType != 0 {
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+				}
+				x.ReservationId = 0
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					x.ReservationId |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -38507,28 +41235,28 @@ func (x *fastReflection_MsgSettleDevshardEscrowResponse) ProtoMethods() *protoif
 }
 
 var (
-	md_MsgSetDevshardRequestsEnabled           protoreflect.MessageDescriptor
-	fd_MsgSetDevshardRequestsEnabled_authority protoreflect.FieldDescriptor
-	fd_MsgSetDevshardRequestsEnabled_enabled   protoreflect.FieldDescriptor
+	md_MsgCancelMaintenance                protoreflect.MessageDescriptor
+	fd_MsgCancelMaintenance_creator        protoreflect.FieldDescriptor
+	fd_MsgCancelMaintenance_reservation_id protoreflect.FieldDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSetDevshardRequestsEnabled = File_inference_inference_tx_proto.Messages().ByName("MsgSetDevshardRequestsEnabled")
-	fd_MsgSetDevshardRequestsEnabled_authority = md_MsgSetDevshardRequestsEnabled.Fields().ByName("authority")
-	fd_MsgSetDevshardRequestsEnabled_enabled = md_MsgSetDevshardRequestsEnabled.Fields().ByName("enabled")
+	md_MsgCancelMaintenance = File_inference_inference_tx_proto.Messages().ByName("MsgCancelMaintenance")
+	fd_MsgCancelMaintenance_creator = md_MsgCancelMaintenance.Fields().ByName("creator")
+	fd_MsgCancelMaintenance_reservation_id = md_MsgCancelMaintenance.Fields().ByName("reservation_id")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSetDevshardRequestsEnabled)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCancelMaintenance)(nil)
 
-type fastReflection_MsgSetDevshardRequestsEnabled MsgSetDevshardRequestsEnabled
+type fastReflection_MsgCancelMaintenance MsgCancelMaintenance
 
-func (x *MsgSetDevshardRequestsEnabled) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSetDevshardRequestsEnabled)(x)
+func (x *MsgCancelMaintenance) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCancelMaintenance)(x)
 }
 
-func (x *MsgSetDevshardRequestsEnabled) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[72]
+func (x *MsgCancelMaintenance) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[78]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -38539,43 +41267,43 @@ func (x *MsgSetDevshardRequestsEnabled) slowProtoReflect() protoreflect.Message
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSetDevshardRequestsEnabled_messageType fastReflection_MsgSetDevshardRequestsEnabled_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSetDevshardRequestsEnabled_messageType{}
+var _fastReflection_MsgCancelMaintenance_messageType fastReflection_MsgCancelMaintenance_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCancelMaintenance_messageType{}
 
-type fastReflection_MsgSetDevshardRequestsEnabled_messageType struct{}
+type fastReflection_MsgCancelMaintenance_messageType struct{}
 
-func (x fastReflection_MsgSetDevshardRequestsEnabled_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSetDevshardRequestsEnabled)(nil)
+func (x fastReflection_MsgCancelMaintenance_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCancelMaintenance)(nil)
 }
-func (x fastReflection_MsgSetDevshardRequestsEnabled_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSetDevshardRequestsEnabled)
+func (x fastReflection_MsgCancelMaintenance_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelMaintenance)
 }
-func (x fastReflection_MsgSetDevshardRequestsEnabled_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSetDevshardRequestsEnabled
+func (x fastReflection_MsgCancelMaintenance_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelMaintenance
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSetDevshardRequestsEnabled
+func (x *fastReflection_MsgCancelMaintenance) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelMaintenance
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSetDevshardRequestsEnabled_messageType
+func (x *fastReflection_MsgCancelMaintenance) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCancelMaintenance_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) New() protoreflect.Message {
-	return new(fastReflection_MsgSetDevshardRequestsEnabled)
+func (x *fastReflection_MsgCancelMaintenance) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelMaintenance)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Interface() protoreflect.ProtoMessage {
-	return (*MsgSetDevshardRequestsEnabled)(x)
+func (x *fastReflection_MsgCancelMaintenance) Interface() protoreflect.ProtoMessage {
+	return (*MsgCancelMaintenance)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -38583,16 +41311,16 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) Interface() protoreflect.
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
-	if x.Authority != "" {
-		value := protoreflect.ValueOfString(x.Authority)
-		if !f(fd_MsgSetDevshardRequestsEnabled_authority, value) {
+func (x *fastReflection_MsgCancelMaintenance) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+	if x.Creator != "" {
+		value := protoreflect.ValueOfString(x.Creator)
+		if !f(fd_MsgCancelMaintenance_creator, value) {
 			return
 		}
 	}
-	if x.Enabled != false {
-		value := protoreflect.ValueOfBool(x.Enabled)
-		if !f(fd_MsgSetDevshardRequestsEnabled_enabled, value) {
+	if x.ReservationId != uint64(0) {
+		value := protoreflect.ValueOfUint64(x.ReservationId)
+		if !f(fd_MsgCancelMaintenance_reservation_id, value) {
 			return
 		}
 	}
@@ -38609,17 +41337,17 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) Range(f func(protoreflect
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCancelMaintenance) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
-	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
-		return x.Authority != ""
-	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
-		return x.Enabled != false
+	case "inference.inference.MsgCancelMaintenance.creator":
+		return x.Creator != ""
+	case "inference.inference.MsgCancelMaintenance.reservation_id":
+		return x.ReservationId != uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38629,17 +41357,17 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) Has(fd protoreflect.Field
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCancelMaintenance) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
-		x.Authority = ""
-	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
-		x.Enabled = false
+	case "inference.inference.MsgCancelMaintenance.creator":
+		x.Creator = ""
+	case "inference.inference.MsgCancelMaintenance.reservation_id":
+		x.ReservationId = uint64(0)
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38649,19 +41377,19 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) Clear(fd protoreflect.Fie
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelMaintenance) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
-	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
-		value := x.Authority
+	case "inference.inference.MsgCancelMaintenance.creator":
+		value := x.Creator
 		return protoreflect.ValueOfString(value)
-	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
-		value := x.Enabled
-		return protoreflect.ValueOfBool(value)
+	case "inference.inference.MsgCancelMaintenance.reservation_id":
+		value := x.ReservationId
+		return protoreflect.ValueOfUint64(value)
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenance does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -38675,17 +41403,17 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) Get(descriptor protorefle
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCancelMaintenance) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
-	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
-		x.Authority = value.Interface().(string)
-	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
-		x.Enabled = value.Bool()
+	case "inference.inference.MsgCancelMaintenance.creator":
+		x.Creator = value.Interface().(string)
+	case "inference.inference.MsgCancelMaintenance.reservation_id":
+		x.ReservationId = value.Uint()
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -38699,44 +41427,44 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) Set(fd protoreflect.Field
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelMaintenance) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
-		panic(fmt.Errorf("field authority of message inference.inference.MsgSetDevshardRequestsEnabled is not mutable"))
-	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
-		panic(fmt.Errorf("field enabled of message inference.inference.MsgSetDevshardRequestsEnabled is not mutable"))
+	case "inference.inference.MsgCancelMaintenance.creator":
+		panic(fmt.Errorf("field creator of message inference.inference.MsgCancelMaintenance is not mutable"))
+	case "inference.inference.MsgCancelMaintenance.reservation_id":
+		panic(fmt.Errorf("field reservation_id of message inference.inference.MsgCancelMaintenance is not mutable"))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelMaintenance) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
-	case "inference.inference.MsgSetDevshardRequestsEnabled.authority":
+	case "inference.inference.MsgCancelMaintenance.creator":
 		return protoreflect.ValueOfString("")
-	case "inference.inference.MsgSetDevshardRequestsEnabled.enabled":
-		return protoreflect.ValueOfBool(false)
+	case "inference.inference.MsgCancelMaintenance.reservation_id":
+		return protoreflect.ValueOfUint64(uint64(0))
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabled"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenance"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabled does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenance does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCancelMaintenance) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSetDevshardRequestsEnabled", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCancelMaintenance", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -38744,7 +41472,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) WhichOneof(d protoreflect
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCancelMaintenance) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -38755,7 +41483,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) GetUnknown() protoreflect
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCancelMaintenance) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -38767,7 +41495,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) SetUnknown(fields protore
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) IsValid() bool {
+func (x *fastReflection_MsgCancelMaintenance) IsValid() bool {
 	return x != nil
 }
 
@@ -38777,9 +41505,9 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCancelMaintenance) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabled)
+		x := input.Message.Interface().(*MsgCancelMaintenance)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38791,12 +41519,12 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 		var n int
 		var l int
 		_ = l
-		l = len(x.Authority)
+		l = len(x.Creator)
 		if l > 0 {
 			n += 1 + l + runtime.Sov(uint64(l))
 		}
-		if x.Enabled {
-			n += 2
+		if x.ReservationId != 0 {
+			n += 1 + runtime.Sov(uint64(x.ReservationId))
 		}
 		if x.unknownFields != nil {
 			n += len(x.unknownFields)
@@ -38808,7 +41536,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabled)
+		x := input.Message.Interface().(*MsgCancelMaintenance)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38827,20 +41555,15 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 			i -= len(x.unknownFields)
 			copy(dAtA[i:], x.unknownFields)
 		}
-		if x.Enabled {
-			i--
-			if x.Enabled {
-				dAtA[i] = 1
-			} else {
-				dAtA[i] = 0
-			}
+		if x.ReservationId != 0 {
+			i = runtime.EncodeVarint(dAtA, i, uint64(x.ReservationId))
 			i--
 			dAtA[i] = 0x10
 		}
-		if len(x.Authority) > 0 {
-			i -= len(x.Authority)
-			copy(dAtA[i:], x.Authority)
-			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority)))
+		if len(x.Creator) > 0 {
+			i -= len(x.Creator)
+			copy(dAtA[i:], x.Creator)
+			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Creator)))
 			i--
 			dAtA[i] = 0xa
 		}
@@ -38855,7 +41578,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabled)
+		x := input.Message.Interface().(*MsgCancelMaintenance)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -38887,15 +41610,15 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabled: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelMaintenance: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabled: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelMaintenance: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			case 1:
 				if wireType != 2 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
 				}
 				var stringLen uint64
 				for shift := uint(0); ; shift += 7 {
@@ -38923,13 +41646,13 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 				if postIndex > l {
 					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
 				}
-				x.Authority = string(dAtA[iNdEx:postIndex])
+				x.Creator = string(dAtA[iNdEx:postIndex])
 				iNdEx = postIndex
 			case 2:
 				if wireType != 0 {
-					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
+					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
 				}
-				var v int
+				x.ReservationId = 0
 				for shift := uint(0); ; shift += 7 {
 					if shift >= 64 {
 						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
@@ -38939,12 +41662,11 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= int(b&0x7F) << shift
+					x.ReservationId |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
 				}
-				x.Enabled = bool(v != 0)
 			default:
 				iNdEx = preIndex
 				skippy, err := runtime.Skip(dAtA[iNdEx:])
@@ -38981,24 +41703,24 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabled) ProtoMethods() *protoifac
 }
 
 var (
-	md_MsgSetDevshardRequestsEnabledResponse protoreflect.MessageDescriptor
+	md_MsgCancelMaintenanceResponse protoreflect.MessageDescriptor
 )
 
 func init() {
 	file_inference_inference_tx_proto_init()
-	md_MsgSetDevshardRequestsEnabledResponse = File_inference_inference_tx_proto.Messages().ByName("MsgSetDevshardRequestsEnabledResponse")
+	md_MsgCancelMaintenanceResponse = File_inference_inference_tx_proto.Messages().ByName("MsgCancelMaintenanceResponse")
 }
 
-var _ protoreflect.Message = (*fastReflection_MsgSetDevshardRequestsEnabledResponse)(nil)
+var _ protoreflect.Message = (*fastReflection_MsgCancelMaintenanceResponse)(nil)
 
-type fastReflection_MsgSetDevshardRequestsEnabledResponse MsgSetDevshardRequestsEnabledResponse
+type fastReflection_MsgCancelMaintenanceResponse MsgCancelMaintenanceResponse
 
-func (x *MsgSetDevshardRequestsEnabledResponse) ProtoReflect() protoreflect.Message {
-	return (*fastReflection_MsgSetDevshardRequestsEnabledResponse)(x)
+func (x *MsgCancelMaintenanceResponse) ProtoReflect() protoreflect.Message {
+	return (*fastReflection_MsgCancelMaintenanceResponse)(x)
 }
 
-func (x *MsgSetDevshardRequestsEnabledResponse) slowProtoReflect() protoreflect.Message {
-	mi := &file_inference_inference_tx_proto_msgTypes[73]
+func (x *MsgCancelMaintenanceResponse) slowProtoReflect() protoreflect.Message {
+	mi := &file_inference_inference_tx_proto_msgTypes[79]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -39009,43 +41731,43 @@ func (x *MsgSetDevshardRequestsEnabledResponse) slowProtoReflect() protoreflect.
 	return mi.MessageOf(x)
 }
 
-var _fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType
-var _ protoreflect.MessageType = fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType{}
+var _fastReflection_MsgCancelMaintenanceResponse_messageType fastReflection_MsgCancelMaintenanceResponse_messageType
+var _ protoreflect.MessageType = fastReflection_MsgCancelMaintenanceResponse_messageType{}
 
-type fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType struct{}
+type fastReflection_MsgCancelMaintenanceResponse_messageType struct{}
 
-func (x fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType) Zero() protoreflect.Message {
-	return (*fastReflection_MsgSetDevshardRequestsEnabledResponse)(nil)
+func (x fastReflection_MsgCancelMaintenanceResponse_messageType) Zero() protoreflect.Message {
+	return (*fastReflection_MsgCancelMaintenanceResponse)(nil)
 }
-func (x fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType) New() protoreflect.Message {
-	return new(fastReflection_MsgSetDevshardRequestsEnabledResponse)
+func (x fastReflection_MsgCancelMaintenanceResponse_messageType) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelMaintenanceResponse)
 }
-func (x fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSetDevshardRequestsEnabledResponse
+func (x fastReflection_MsgCancelMaintenanceResponse_messageType) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelMaintenanceResponse
 }
 
 // Descriptor returns message descriptor, which contains only the protobuf
 // type information for the message.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Descriptor() protoreflect.MessageDescriptor {
-	return md_MsgSetDevshardRequestsEnabledResponse
+func (x *fastReflection_MsgCancelMaintenanceResponse) Descriptor() protoreflect.MessageDescriptor {
+	return md_MsgCancelMaintenanceResponse
 }
 
 // Type returns the message type, which encapsulates both Go and protobuf
 // type information. If the Go type information is not needed,
 // it is recommended that the message descriptor be used instead.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Type() protoreflect.MessageType {
-	return _fastReflection_MsgSetDevshardRequestsEnabledResponse_messageType
+func (x *fastReflection_MsgCancelMaintenanceResponse) Type() protoreflect.MessageType {
+	return _fastReflection_MsgCancelMaintenanceResponse_messageType
 }
 
 // New returns a newly allocated and mutable empty message.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) New() protoreflect.Message {
-	return new(fastReflection_MsgSetDevshardRequestsEnabledResponse)
+func (x *fastReflection_MsgCancelMaintenanceResponse) New() protoreflect.Message {
+	return new(fastReflection_MsgCancelMaintenanceResponse)
 }
 
 // Interface unwraps the message reflection interface and
 // returns the underlying ProtoMessage interface.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Interface() protoreflect.ProtoMessage {
-	return (*MsgSetDevshardRequestsEnabledResponse)(x)
+func (x *fastReflection_MsgCancelMaintenanceResponse) Interface() protoreflect.ProtoMessage {
+	return (*MsgCancelMaintenanceResponse)(x)
 }
 
 // Range iterates over every populated field in an undefined order,
@@ -39053,7 +41775,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Interface() proto
 // Range returns immediately if f returns false.
 // While iterating, mutating operations may only be performed
 // on the current field descriptor.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
+func (x *fastReflection_MsgCancelMaintenanceResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
 }
 
 // Has reports whether a field is populated.
@@ -39067,13 +41789,13 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Range(f func(prot
 // In other cases (aside from the nullable cases above),
 // a proto3 scalar field is populated if it contains a non-zero value, and
 // a repeated field is populated if it is non-empty.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Has(fd protoreflect.FieldDescriptor) bool {
+func (x *fastReflection_MsgCancelMaintenanceResponse) Has(fd protoreflect.FieldDescriptor) bool {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39083,13 +41805,13 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Has(fd protorefle
 // associated with the given field number.
 //
 // Clear is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Clear(fd protoreflect.FieldDescriptor) {
+func (x *fastReflection_MsgCancelMaintenanceResponse) Clear(fd protoreflect.FieldDescriptor) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39099,13 +41821,13 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Clear(fd protoref
 // the default value of a bytes scalar is guaranteed to be a copy.
 // For unpopulated composite types, it returns an empty, read-only view
 // of the value; to obtain a mutable reference, use Mutable.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelMaintenanceResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
 	switch descriptor.FullName() {
 	default:
 		if descriptor.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", descriptor.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenanceResponse does not contain field %s", descriptor.FullName()))
 	}
 }
 
@@ -39119,13 +41841,13 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Get(descriptor pr
 // empty, read-only value, then it panics.
 //
 // Set is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
+func (x *fastReflection_MsgCancelMaintenanceResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
@@ -39139,36 +41861,36 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Set(fd protorefle
 // It panics if the field does not contain a composite type.
 //
 // Mutable is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelMaintenanceResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // NewField returns a new value that is assignable to the field
 // for the given descriptor. For scalars, this returns the default value.
 // For lists, maps, and messages, this returns a new, empty, mutable value.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
+func (x *fastReflection_MsgCancelMaintenanceResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
 	switch fd.FullName() {
 	default:
 		if fd.IsExtension() {
-			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgSetDevshardRequestsEnabledResponse"))
+			panic(fmt.Errorf("proto3 declared messages do not support extensions: inference.inference.MsgCancelMaintenanceResponse"))
 		}
-		panic(fmt.Errorf("message inference.inference.MsgSetDevshardRequestsEnabledResponse does not contain field %s", fd.FullName()))
+		panic(fmt.Errorf("message inference.inference.MsgCancelMaintenanceResponse does not contain field %s", fd.FullName()))
 	}
 }
 
 // WhichOneof reports which field within the oneof is populated,
 // returning nil if none are populated.
 // It panics if the oneof descriptor does not belong to this message.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
+func (x *fastReflection_MsgCancelMaintenanceResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
 	switch d.FullName() {
 	default:
-		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgSetDevshardRequestsEnabledResponse", d.FullName()))
+		panic(fmt.Errorf("%s is not a oneof field in inference.inference.MsgCancelMaintenanceResponse", d.FullName()))
 	}
 	panic("unreachable")
 }
@@ -39176,7 +41898,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) WhichOneof(d prot
 // GetUnknown retrieves the entire list of unknown fields.
 // The caller may only mutate the contents of the RawFields
 // if the mutated bytes are stored back into the message with SetUnknown.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) GetUnknown() protoreflect.RawFields {
+func (x *fastReflection_MsgCancelMaintenanceResponse) GetUnknown() protoreflect.RawFields {
 	return x.unknownFields
 }
 
@@ -39187,7 +41909,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) GetUnknown() prot
 // An empty RawFields may be passed to clear the fields.
 //
 // SetUnknown is a mutating operation and unsafe for concurrent use.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) SetUnknown(fields protoreflect.RawFields) {
+func (x *fastReflection_MsgCancelMaintenanceResponse) SetUnknown(fields protoreflect.RawFields) {
 	x.unknownFields = fields
 }
 
@@ -39199,7 +41921,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) SetUnknown(fields
 // message type, but the details are implementation dependent.
 // Validity is not part of the protobuf data model, and may not
 // be preserved in marshaling or other operations.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) IsValid() bool {
+func (x *fastReflection_MsgCancelMaintenanceResponse) IsValid() bool {
 	return x != nil
 }
 
@@ -39209,9 +41931,9 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) IsValid() bool {
 // The returned methods type is identical to
 // "google.golang.org/protobuf/runtime/protoiface".Methods.
 // Consult the protoiface package documentation for details.
-func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) ProtoMethods() *protoiface.Methods {
+func (x *fastReflection_MsgCancelMaintenanceResponse) ProtoMethods() *protoiface.Methods {
 	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
-		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabledResponse)
+		x := input.Message.Interface().(*MsgCancelMaintenanceResponse)
 		if x == nil {
 			return protoiface.SizeOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -39233,7 +41955,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) ProtoMethods() *p
 	}
 
 	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabledResponse)
+		x := input.Message.Interface().(*MsgCancelMaintenanceResponse)
 		if x == nil {
 			return protoiface.MarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -39263,7 +41985,7 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) ProtoMethods() *p
 		}, nil
 	}
 	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
-		x := input.Message.Interface().(*MsgSetDevshardRequestsEnabledResponse)
+		x := input.Message.Interface().(*MsgCancelMaintenanceResponse)
 		if x == nil {
 			return protoiface.UnmarshalOutput{
 				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
@@ -39295,10 +42017,10 @@ func (x *fastReflection_MsgSetDevshardRequestsEnabledResponse) ProtoMethods() *p
 			fieldNum := int32(wire >> 3)
 			wireType := int(wire & 0x7)
 			if wireType == 4 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabledResponse: wiretype end group for non-group")
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelMaintenanceResponse: wiretype end group for non-group")
 			}
 			if fieldNum <= 0 {
-				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSetDevshardRequestsEnabledResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelMaintenanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 			}
 			switch fieldNum {
 			default:
@@ -39423,6 +42145,7 @@ func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
 	return file_inference_inference_tx_proto_rawDescGZIP(), []int{1}
 }
 
+// Deprecated: Do not use.
 type MsgStartInference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -39566,6 +42289,7 @@ func (x *MsgStartInference) GetOriginalPromptHash() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgStartInferenceResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -39609,6 +42333,7 @@ func (x *MsgStartInferenceResponse) GetErrorMessage() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgFinishInference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -39768,6 +42493,7 @@ func (x *MsgFinishInference) GetOriginalPromptHash() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgFinishInferenceResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -39913,6 +42639,7 @@ func (x *MsgSubmitNewParticipantResponse) GetStatus() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgValidation struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40008,6 +42735,7 @@ func (x *MsgValidation) GetValueDecimal() *Decimal {
 	return nil
 }
 
+// Deprecated: Do not use.
 type MsgValidationResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40135,6 +42863,7 @@ func (*MsgSubmitNewUnfundedParticipantResponse) Descriptor() ([]byte, []int) {
 	return file_inference_inference_tx_proto_rawDescGZIP(), []int{11}
 }
 
+// Deprecated: Do not use.
 type MsgInvalidateInference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40186,6 +42915,7 @@ func (x *MsgInvalidateInference) GetInvalidator() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgInvalidateInferenceResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40212,6 +42942,7 @@ func (*MsgInvalidateInferenceResponse) Descriptor() ([]byte, []int) {
 	return file_inference_inference_tx_proto_rawDescGZIP(), []int{13}
 }
 
+// Deprecated: Do not use.
 type MsgRevalidateInference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40263,6 +42994,7 @@ func (x *MsgRevalidateInference) GetInvalidator() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgRevalidateInferenceResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40383,6 +43115,79 @@ func (x *MsgClaimRewardsResponse) GetResult() string {
 	return ""
 }
 
+// MsgSetClaimRecipients lets the account owner (cold key) batch-configure
+// per-epoch recipient overrides for MsgClaimRewards. Must be signed by the
+// participant's own key; it is intentionally NOT granted to warm keys via
+// authz, so an operational key cannot redirect rewards.
+type MsgSetClaimRecipients struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Creator string                 `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	Entries []*ClaimRecipientEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
+}
+
+func (x *MsgSetClaimRecipients) Reset() {
+	*x = MsgSetClaimRecipients{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_tx_proto_msgTypes[18]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgSetClaimRecipients) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSetClaimRecipients) ProtoMessage() {}
+
+// Deprecated: Use MsgSetClaimRecipients.ProtoReflect.Descriptor instead.
+func (*MsgSetClaimRecipients) Descriptor() ([]byte, []int) {
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *MsgSetClaimRecipients) GetCreator() string {
+	if x != nil {
+		return x.Creator
+	}
+	return ""
+}
+
+func (x *MsgSetClaimRecipients) GetEntries() []*ClaimRecipientEntry {
+	if x != nil {
+		return x.Entries
+	}
+	return nil
+}
+
+type MsgSetClaimRecipientsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgSetClaimRecipientsResponse) Reset() {
+	*x = MsgSetClaimRecipientsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_tx_proto_msgTypes[19]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgSetClaimRecipientsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgSetClaimRecipientsResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgSetClaimRecipientsResponse.ProtoReflect.Descriptor instead.
+func (*MsgSetClaimRecipientsResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{19}
+}
+
 type MsgSubmitPocBatch struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -40399,7 +43204,7 @@ type MsgSubmitPocBatch struct {
 func (x *MsgSubmitPocBatch) Reset() {
 	*x = MsgSubmitPocBatch{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[18]
+		mi := &file_inference_inference_tx_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40413,7 +43218,7 @@ func (*MsgSubmitPocBatch) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitPocBatch.ProtoReflect.Descriptor instead.
 func (*MsgSubmitPocBatch) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{18}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{20}
 }
 
 func (x *MsgSubmitPocBatch) GetCreator() string {
@@ -40467,7 +43272,7 @@ type MsgSubmitPocBatchResponse struct {
 func (x *MsgSubmitPocBatchResponse) Reset() {
 	*x = MsgSubmitPocBatchResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[19]
+		mi := &file_inference_inference_tx_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40481,7 +43286,7 @@ func (*MsgSubmitPocBatchResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitPocBatchResponse.ProtoReflect.Descriptor instead.
 func (*MsgSubmitPocBatchResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{19}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{21}
 }
 
 // PoC v2 validation messages
@@ -40498,7 +43303,7 @@ type MsgSubmitPocValidationsV2 struct {
 func (x *MsgSubmitPocValidationsV2) Reset() {
 	*x = MsgSubmitPocValidationsV2{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[20]
+		mi := &file_inference_inference_tx_proto_msgTypes[22]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40512,7 +43317,7 @@ func (*MsgSubmitPocValidationsV2) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitPocValidationsV2.ProtoReflect.Descriptor instead.
 func (*MsgSubmitPocValidationsV2) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{20}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{22}
 }
 
 func (x *MsgSubmitPocValidationsV2) GetCreator() string {
@@ -40545,7 +43350,7 @@ type MsgSubmitPocValidationsV2Response struct {
 func (x *MsgSubmitPocValidationsV2Response) Reset() {
 	*x = MsgSubmitPocValidationsV2Response{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[21]
+		mi := &file_inference_inference_tx_proto_msgTypes[23]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40559,7 +43364,7 @@ func (*MsgSubmitPocValidationsV2Response) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitPocValidationsV2Response.ProtoReflect.Descriptor instead.
 func (*MsgSubmitPocValidationsV2Response) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{21}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{23}
 }
 
 // PoC v2 off-chain commit - commits MMR state to chain
@@ -40580,7 +43385,7 @@ type MsgPoCV2StoreCommit struct {
 func (x *MsgPoCV2StoreCommit) Reset() {
 	*x = MsgPoCV2StoreCommit{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[22]
+		mi := &file_inference_inference_tx_proto_msgTypes[24]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40594,7 +43399,7 @@ func (*MsgPoCV2StoreCommit) ProtoMessage() {}
 
 // Deprecated: Use MsgPoCV2StoreCommit.ProtoReflect.Descriptor instead.
 func (*MsgPoCV2StoreCommit) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{22}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{24}
 }
 
 func (x *MsgPoCV2StoreCommit) GetCreator() string {
@@ -40643,7 +43448,7 @@ type MsgPoCV2StoreCommitResponse struct {
 func (x *MsgPoCV2StoreCommitResponse) Reset() {
 	*x = MsgPoCV2StoreCommitResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[23]
+		mi := &file_inference_inference_tx_proto_msgTypes[25]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40657,7 +43462,7 @@ func (*MsgPoCV2StoreCommitResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgPoCV2StoreCommitResponse.ProtoReflect.Descriptor instead.
 func (*MsgPoCV2StoreCommitResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{23}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{25}
 }
 
 // Reports per-node weight distribution after generation
@@ -40676,7 +43481,7 @@ type MsgMLNodeWeightDistribution struct {
 func (x *MsgMLNodeWeightDistribution) Reset() {
 	*x = MsgMLNodeWeightDistribution{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[24]
+		mi := &file_inference_inference_tx_proto_msgTypes[26]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40690,7 +43495,7 @@ func (*MsgMLNodeWeightDistribution) ProtoMessage() {}
 
 // Deprecated: Use MsgMLNodeWeightDistribution.ProtoReflect.Descriptor instead.
 func (*MsgMLNodeWeightDistribution) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{24}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{26}
 }
 
 func (x *MsgMLNodeWeightDistribution) GetCreator() string {
@@ -40731,7 +43536,7 @@ type MsgMLNodeWeightDistributionResponse struct {
 func (x *MsgMLNodeWeightDistributionResponse) Reset() {
 	*x = MsgMLNodeWeightDistributionResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[25]
+		mi := &file_inference_inference_tx_proto_msgTypes[27]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40745,7 +43550,7 @@ func (*MsgMLNodeWeightDistributionResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgMLNodeWeightDistributionResponse.ProtoReflect.Descriptor instead.
 func (*MsgMLNodeWeightDistributionResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{25}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{27}
 }
 
 type MsgSubmitSeed struct {
@@ -40761,7 +43566,7 @@ type MsgSubmitSeed struct {
 func (x *MsgSubmitSeed) Reset() {
 	*x = MsgSubmitSeed{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[26]
+		mi := &file_inference_inference_tx_proto_msgTypes[28]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40775,7 +43580,7 @@ func (*MsgSubmitSeed) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitSeed.ProtoReflect.Descriptor instead.
 func (*MsgSubmitSeed) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{26}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{28}
 }
 
 func (x *MsgSubmitSeed) GetCreator() string {
@@ -40808,7 +43613,7 @@ type MsgSubmitSeedResponse struct {
 func (x *MsgSubmitSeedResponse) Reset() {
 	*x = MsgSubmitSeedResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[27]
+		mi := &file_inference_inference_tx_proto_msgTypes[29]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40822,7 +43627,7 @@ func (*MsgSubmitSeedResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitSeedResponse.ProtoReflect.Descriptor instead.
 func (*MsgSubmitSeedResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{27}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{29}
 }
 
 type MsgSubmitUnitOfComputePriceProposal struct {
@@ -40837,7 +43642,7 @@ type MsgSubmitUnitOfComputePriceProposal struct {
 func (x *MsgSubmitUnitOfComputePriceProposal) Reset() {
 	*x = MsgSubmitUnitOfComputePriceProposal{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[28]
+		mi := &file_inference_inference_tx_proto_msgTypes[30]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40851,7 +43656,7 @@ func (*MsgSubmitUnitOfComputePriceProposal) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitUnitOfComputePriceProposal.ProtoReflect.Descriptor instead.
 func (*MsgSubmitUnitOfComputePriceProposal) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{28}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{30}
 }
 
 func (x *MsgSubmitUnitOfComputePriceProposal) GetCreator() string {
@@ -40877,7 +43682,7 @@ type MsgSubmitUnitOfComputePriceProposalResponse struct {
 func (x *MsgSubmitUnitOfComputePriceProposalResponse) Reset() {
 	*x = MsgSubmitUnitOfComputePriceProposalResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[29]
+		mi := &file_inference_inference_tx_proto_msgTypes[31]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40891,7 +43696,7 @@ func (*MsgSubmitUnitOfComputePriceProposalResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitUnitOfComputePriceProposalResponse.ProtoReflect.Descriptor instead.
 func (*MsgSubmitUnitOfComputePriceProposalResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{29}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{31}
 }
 
 type MsgRegisterModel struct {
@@ -40914,7 +43719,7 @@ type MsgRegisterModel struct {
 func (x *MsgRegisterModel) Reset() {
 	*x = MsgRegisterModel{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[30]
+		mi := &file_inference_inference_tx_proto_msgTypes[32]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -40928,7 +43733,7 @@ func (*MsgRegisterModel) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterModel.ProtoReflect.Descriptor instead.
 func (*MsgRegisterModel) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{30}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{32}
 }
 
 func (x *MsgRegisterModel) GetAuthority() string {
@@ -41010,7 +43815,7 @@ type MsgRegisterModelResponse struct {
 func (x *MsgRegisterModelResponse) Reset() {
 	*x = MsgRegisterModelResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[31]
+		mi := &file_inference_inference_tx_proto_msgTypes[33]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41024,7 +43829,7 @@ func (*MsgRegisterModelResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterModelResponse.ProtoReflect.Descriptor instead.
 func (*MsgRegisterModelResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{31}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{33}
 }
 
 type MsgDeleteGovernanceModel struct {
@@ -41039,7 +43844,7 @@ type MsgDeleteGovernanceModel struct {
 func (x *MsgDeleteGovernanceModel) Reset() {
 	*x = MsgDeleteGovernanceModel{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[32]
+		mi := &file_inference_inference_tx_proto_msgTypes[34]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41053,7 +43858,7 @@ func (*MsgDeleteGovernanceModel) ProtoMessage() {}
 
 // Deprecated: Use MsgDeleteGovernanceModel.ProtoReflect.Descriptor instead.
 func (*MsgDeleteGovernanceModel) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{32}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{34}
 }
 
 func (x *MsgDeleteGovernanceModel) GetAuthority() string {
@@ -41079,7 +43884,7 @@ type MsgDeleteGovernanceModelResponse struct {
 func (x *MsgDeleteGovernanceModelResponse) Reset() {
 	*x = MsgDeleteGovernanceModelResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[33]
+		mi := &file_inference_inference_tx_proto_msgTypes[35]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41093,7 +43898,7 @@ func (*MsgDeleteGovernanceModelResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgDeleteGovernanceModelResponse.ProtoReflect.Descriptor instead.
 func (*MsgDeleteGovernanceModelResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{33}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{35}
 }
 
 type MsgSubmitHardwareDiff struct {
@@ -41109,7 +43914,7 @@ type MsgSubmitHardwareDiff struct {
 func (x *MsgSubmitHardwareDiff) Reset() {
 	*x = MsgSubmitHardwareDiff{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[34]
+		mi := &file_inference_inference_tx_proto_msgTypes[36]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41123,7 +43928,7 @@ func (*MsgSubmitHardwareDiff) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitHardwareDiff.ProtoReflect.Descriptor instead.
 func (*MsgSubmitHardwareDiff) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{34}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{36}
 }
 
 func (x *MsgSubmitHardwareDiff) GetCreator() string {
@@ -41156,7 +43961,7 @@ type MsgSubmitHardwareDiffResponse struct {
 func (x *MsgSubmitHardwareDiffResponse) Reset() {
 	*x = MsgSubmitHardwareDiffResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[35]
+		mi := &file_inference_inference_tx_proto_msgTypes[37]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41170,7 +43975,7 @@ func (*MsgSubmitHardwareDiffResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSubmitHardwareDiffResponse.ProtoReflect.Descriptor instead.
 func (*MsgSubmitHardwareDiffResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{35}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{37}
 }
 
 type MsgCreatePartialUpgrade struct {
@@ -41187,7 +43992,7 @@ type MsgCreatePartialUpgrade struct {
 func (x *MsgCreatePartialUpgrade) Reset() {
 	*x = MsgCreatePartialUpgrade{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[36]
+		mi := &file_inference_inference_tx_proto_msgTypes[38]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41201,7 +44006,7 @@ func (*MsgCreatePartialUpgrade) ProtoMessage() {}
 
 // Deprecated: Use MsgCreatePartialUpgrade.ProtoReflect.Descriptor instead.
 func (*MsgCreatePartialUpgrade) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{36}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{38}
 }
 
 func (x *MsgCreatePartialUpgrade) GetAuthority() string {
@@ -41241,7 +44046,7 @@ type MsgCreatePartialUpgradeResponse struct {
 func (x *MsgCreatePartialUpgradeResponse) Reset() {
 	*x = MsgCreatePartialUpgradeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[37]
+		mi := &file_inference_inference_tx_proto_msgTypes[39]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41255,7 +44060,7 @@ func (*MsgCreatePartialUpgradeResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgCreatePartialUpgradeResponse.ProtoReflect.Descriptor instead.
 func (*MsgCreatePartialUpgradeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{37}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{39}
 }
 
 type MsgBridgeExchange struct {
@@ -41277,7 +44082,7 @@ type MsgBridgeExchange struct {
 func (x *MsgBridgeExchange) Reset() {
 	*x = MsgBridgeExchange{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[38]
+		mi := &file_inference_inference_tx_proto_msgTypes[40]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41291,7 +44096,7 @@ func (*MsgBridgeExchange) ProtoMessage() {}
 
 // Deprecated: Use MsgBridgeExchange.ProtoReflect.Descriptor instead.
 func (*MsgBridgeExchange) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{38}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{40}
 }
 
 func (x *MsgBridgeExchange) GetValidator() string {
@@ -41368,7 +44173,7 @@ type MsgBridgeExchangeResponse struct {
 func (x *MsgBridgeExchangeResponse) Reset() {
 	*x = MsgBridgeExchangeResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[39]
+		mi := &file_inference_inference_tx_proto_msgTypes[41]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41382,7 +44187,7 @@ func (*MsgBridgeExchangeResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgBridgeExchangeResponse.ProtoReflect.Descriptor instead.
 func (*MsgBridgeExchangeResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{39}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{41}
 }
 
 func (x *MsgBridgeExchangeResponse) GetId() string {
@@ -41406,7 +44211,7 @@ type MsgAddParticipantsToAllowList struct {
 func (x *MsgAddParticipantsToAllowList) Reset() {
 	*x = MsgAddParticipantsToAllowList{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[40]
+		mi := &file_inference_inference_tx_proto_msgTypes[42]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41420,7 +44225,7 @@ func (*MsgAddParticipantsToAllowList) ProtoMessage() {}
 
 // Deprecated: Use MsgAddParticipantsToAllowList.ProtoReflect.Descriptor instead.
 func (*MsgAddParticipantsToAllowList) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{40}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{42}
 }
 
 func (x *MsgAddParticipantsToAllowList) GetAuthority() string {
@@ -41446,7 +44251,7 @@ type MsgAddParticipantsToAllowListResponse struct {
 func (x *MsgAddParticipantsToAllowListResponse) Reset() {
 	*x = MsgAddParticipantsToAllowListResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[41]
+		mi := &file_inference_inference_tx_proto_msgTypes[43]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41460,7 +44265,7 @@ func (*MsgAddParticipantsToAllowListResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgAddParticipantsToAllowListResponse.ProtoReflect.Descriptor instead.
 func (*MsgAddParticipantsToAllowListResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{41}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{43}
 }
 
 // MsgRemoveParticipantsFromAllowList removes addresses from the participant epoch-formation allowlist.
@@ -41477,7 +44282,7 @@ type MsgRemoveParticipantsFromAllowList struct {
 func (x *MsgRemoveParticipantsFromAllowList) Reset() {
 	*x = MsgRemoveParticipantsFromAllowList{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[42]
+		mi := &file_inference_inference_tx_proto_msgTypes[44]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41491,7 +44296,7 @@ func (*MsgRemoveParticipantsFromAllowList) ProtoMessage() {}
 
 // Deprecated: Use MsgRemoveParticipantsFromAllowList.ProtoReflect.Descriptor instead.
 func (*MsgRemoveParticipantsFromAllowList) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{42}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{44}
 }
 
 func (x *MsgRemoveParticipantsFromAllowList) GetAuthority() string {
@@ -41517,7 +44322,7 @@ type MsgRemoveParticipantsFromAllowListResponse struct {
 func (x *MsgRemoveParticipantsFromAllowListResponse) Reset() {
 	*x = MsgRemoveParticipantsFromAllowListResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[43]
+		mi := &file_inference_inference_tx_proto_msgTypes[45]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41531,7 +44336,7 @@ func (*MsgRemoveParticipantsFromAllowListResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRemoveParticipantsFromAllowListResponse.ProtoReflect.Descriptor instead.
 func (*MsgRemoveParticipantsFromAllowListResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{43}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{45}
 }
 
 type MsgRegisterBridgeAddresses struct {
@@ -41547,7 +44352,7 @@ type MsgRegisterBridgeAddresses struct {
 func (x *MsgRegisterBridgeAddresses) Reset() {
 	*x = MsgRegisterBridgeAddresses{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[44]
+		mi := &file_inference_inference_tx_proto_msgTypes[46]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41561,7 +44366,7 @@ func (*MsgRegisterBridgeAddresses) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterBridgeAddresses.ProtoReflect.Descriptor instead.
 func (*MsgRegisterBridgeAddresses) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{44}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{46}
 }
 
 func (x *MsgRegisterBridgeAddresses) GetAuthority() string {
@@ -41594,7 +44399,7 @@ type MsgRegisterBridgeAddressesResponse struct {
 func (x *MsgRegisterBridgeAddressesResponse) Reset() {
 	*x = MsgRegisterBridgeAddressesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[45]
+		mi := &file_inference_inference_tx_proto_msgTypes[47]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41608,7 +44413,7 @@ func (*MsgRegisterBridgeAddressesResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterBridgeAddressesResponse.ProtoReflect.Descriptor instead.
 func (*MsgRegisterBridgeAddressesResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{45}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{47}
 }
 
 type MsgRegisterTokenMetadata struct {
@@ -41628,7 +44433,7 @@ type MsgRegisterTokenMetadata struct {
 func (x *MsgRegisterTokenMetadata) Reset() {
 	*x = MsgRegisterTokenMetadata{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[46]
+		mi := &file_inference_inference_tx_proto_msgTypes[48]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41642,7 +44447,7 @@ func (*MsgRegisterTokenMetadata) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterTokenMetadata.ProtoReflect.Descriptor instead.
 func (*MsgRegisterTokenMetadata) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{46}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{48}
 }
 
 func (x *MsgRegisterTokenMetadata) GetAuthority() string {
@@ -41703,7 +44508,7 @@ type MsgRegisterTokenMetadataResponse struct {
 func (x *MsgRegisterTokenMetadataResponse) Reset() {
 	*x = MsgRegisterTokenMetadataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[47]
+		mi := &file_inference_inference_tx_proto_msgTypes[49]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41717,7 +44522,7 @@ func (*MsgRegisterTokenMetadataResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterTokenMetadataResponse.ProtoReflect.Descriptor instead.
 func (*MsgRegisterTokenMetadataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{47}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{49}
 }
 
 type MsgApproveBridgeTokenForTrading struct {
@@ -41733,7 +44538,7 @@ type MsgApproveBridgeTokenForTrading struct {
 func (x *MsgApproveBridgeTokenForTrading) Reset() {
 	*x = MsgApproveBridgeTokenForTrading{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[48]
+		mi := &file_inference_inference_tx_proto_msgTypes[50]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41747,7 +44552,7 @@ func (*MsgApproveBridgeTokenForTrading) ProtoMessage() {}
 
 // Deprecated: Use MsgApproveBridgeTokenForTrading.ProtoReflect.Descriptor instead.
 func (*MsgApproveBridgeTokenForTrading) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{48}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{50}
 }
 
 func (x *MsgApproveBridgeTokenForTrading) GetAuthority() string {
@@ -41780,7 +44585,7 @@ type MsgApproveBridgeTokenForTradingResponse struct {
 func (x *MsgApproveBridgeTokenForTradingResponse) Reset() {
 	*x = MsgApproveBridgeTokenForTradingResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[49]
+		mi := &file_inference_inference_tx_proto_msgTypes[51]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41794,7 +44599,7 @@ func (*MsgApproveBridgeTokenForTradingResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgApproveBridgeTokenForTradingResponse.ProtoReflect.Descriptor instead.
 func (*MsgApproveBridgeTokenForTradingResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{49}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{51}
 }
 
 type MsgRegisterLiquidityPool struct {
@@ -41811,7 +44616,7 @@ type MsgRegisterLiquidityPool struct {
 func (x *MsgRegisterLiquidityPool) Reset() {
 	*x = MsgRegisterLiquidityPool{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[50]
+		mi := &file_inference_inference_tx_proto_msgTypes[52]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41825,7 +44630,7 @@ func (*MsgRegisterLiquidityPool) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterLiquidityPool.ProtoReflect.Descriptor instead.
 func (*MsgRegisterLiquidityPool) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{50}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{52}
 }
 
 func (x *MsgRegisterLiquidityPool) GetAuthority() string {
@@ -41865,7 +44670,7 @@ type MsgRegisterLiquidityPoolResponse struct {
 func (x *MsgRegisterLiquidityPoolResponse) Reset() {
 	*x = MsgRegisterLiquidityPoolResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[51]
+		mi := &file_inference_inference_tx_proto_msgTypes[53]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41879,7 +44684,7 @@ func (*MsgRegisterLiquidityPoolResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterLiquidityPoolResponse.ProtoReflect.Descriptor instead.
 func (*MsgRegisterLiquidityPoolResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{51}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{53}
 }
 
 // Contract-only bridge withdrawal request - can only be executed by smart contracts
@@ -41898,7 +44703,7 @@ type MsgRequestBridgeWithdrawal struct {
 func (x *MsgRequestBridgeWithdrawal) Reset() {
 	*x = MsgRequestBridgeWithdrawal{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[52]
+		mi := &file_inference_inference_tx_proto_msgTypes[54]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41912,7 +44717,7 @@ func (*MsgRequestBridgeWithdrawal) ProtoMessage() {}
 
 // Deprecated: Use MsgRequestBridgeWithdrawal.ProtoReflect.Descriptor instead.
 func (*MsgRequestBridgeWithdrawal) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{52}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{54}
 }
 
 func (x *MsgRequestBridgeWithdrawal) GetCreator() string {
@@ -41963,7 +44768,7 @@ type MsgRequestBridgeWithdrawalResponse struct {
 func (x *MsgRequestBridgeWithdrawalResponse) Reset() {
 	*x = MsgRequestBridgeWithdrawalResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[53]
+		mi := &file_inference_inference_tx_proto_msgTypes[55]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -41977,7 +44782,7 @@ func (*MsgRequestBridgeWithdrawalResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRequestBridgeWithdrawalResponse.ProtoReflect.Descriptor instead.
 func (*MsgRequestBridgeWithdrawalResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{53}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{55}
 }
 
 func (x *MsgRequestBridgeWithdrawalResponse) GetRequestId() string {
@@ -42017,7 +44822,7 @@ type MsgRequestBridgeMint struct {
 func (x *MsgRequestBridgeMint) Reset() {
 	*x = MsgRequestBridgeMint{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[54]
+		mi := &file_inference_inference_tx_proto_msgTypes[56]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42031,7 +44836,7 @@ func (*MsgRequestBridgeMint) ProtoMessage() {}
 
 // Deprecated: Use MsgRequestBridgeMint.ProtoReflect.Descriptor instead.
 func (*MsgRequestBridgeMint) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{54}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{56}
 }
 
 func (x *MsgRequestBridgeMint) GetCreator() string {
@@ -42082,7 +44887,7 @@ type MsgRequestBridgeMintResponse struct {
 func (x *MsgRequestBridgeMintResponse) Reset() {
 	*x = MsgRequestBridgeMintResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[55]
+		mi := &file_inference_inference_tx_proto_msgTypes[57]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42096,7 +44901,7 @@ func (*MsgRequestBridgeMintResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRequestBridgeMintResponse.ProtoReflect.Descriptor instead.
 func (*MsgRequestBridgeMintResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{55}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{57}
 }
 
 func (x *MsgRequestBridgeMintResponse) GetRequestId() string {
@@ -42132,7 +44937,7 @@ type MsgCancelBridgeOperation struct {
 func (x *MsgCancelBridgeOperation) Reset() {
 	*x = MsgCancelBridgeOperation{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[56]
+		mi := &file_inference_inference_tx_proto_msgTypes[58]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42146,7 +44951,7 @@ func (*MsgCancelBridgeOperation) ProtoMessage() {}
 
 // Deprecated: Use MsgCancelBridgeOperation.ProtoReflect.Descriptor instead.
 func (*MsgCancelBridgeOperation) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{56}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{58}
 }
 
 func (x *MsgCancelBridgeOperation) GetCreator() string {
@@ -42172,7 +44977,7 @@ type MsgCancelBridgeOperationResponse struct {
 func (x *MsgCancelBridgeOperationResponse) Reset() {
 	*x = MsgCancelBridgeOperationResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[57]
+		mi := &file_inference_inference_tx_proto_msgTypes[59]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42186,7 +44991,7 @@ func (*MsgCancelBridgeOperationResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgCancelBridgeOperationResponse.ProtoReflect.Descriptor instead.
 func (*MsgCancelBridgeOperationResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{57}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{59}
 }
 
 type MsgGovernanceCancelBridgeOperation struct {
@@ -42204,7 +45009,7 @@ type MsgGovernanceCancelBridgeOperation struct {
 func (x *MsgGovernanceCancelBridgeOperation) Reset() {
 	*x = MsgGovernanceCancelBridgeOperation{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[58]
+		mi := &file_inference_inference_tx_proto_msgTypes[60]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42218,7 +45023,7 @@ func (*MsgGovernanceCancelBridgeOperation) ProtoMessage() {}
 
 // Deprecated: Use MsgGovernanceCancelBridgeOperation.ProtoReflect.Descriptor instead.
 func (*MsgGovernanceCancelBridgeOperation) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{58}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{60}
 }
 
 func (x *MsgGovernanceCancelBridgeOperation) GetAuthority() string {
@@ -42265,7 +45070,7 @@ type MsgGovernanceCancelBridgeOperationResponse struct {
 func (x *MsgGovernanceCancelBridgeOperationResponse) Reset() {
 	*x = MsgGovernanceCancelBridgeOperationResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[59]
+		mi := &file_inference_inference_tx_proto_msgTypes[61]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42279,7 +45084,7 @@ func (*MsgGovernanceCancelBridgeOperationResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgGovernanceCancelBridgeOperationResponse.ProtoReflect.Descriptor instead.
 func (*MsgGovernanceCancelBridgeOperationResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{59}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{61}
 }
 
 // SetCw20CodeId updates the code id used for new wrapped-token instantiations.
@@ -42295,7 +45100,7 @@ type MsgRegisterWrappedTokenContract struct {
 func (x *MsgRegisterWrappedTokenContract) Reset() {
 	*x = MsgRegisterWrappedTokenContract{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[60]
+		mi := &file_inference_inference_tx_proto_msgTypes[62]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42309,7 +45114,7 @@ func (*MsgRegisterWrappedTokenContract) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterWrappedTokenContract.ProtoReflect.Descriptor instead.
 func (*MsgRegisterWrappedTokenContract) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{60}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{62}
 }
 
 func (x *MsgRegisterWrappedTokenContract) GetAuthority() string {
@@ -42335,7 +45140,7 @@ type MsgRegisterWrappedTokenContractResponse struct {
 func (x *MsgRegisterWrappedTokenContractResponse) Reset() {
 	*x = MsgRegisterWrappedTokenContractResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[61]
+		mi := &file_inference_inference_tx_proto_msgTypes[63]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42349,7 +45154,7 @@ func (*MsgRegisterWrappedTokenContractResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterWrappedTokenContractResponse.ProtoReflect.Descriptor instead.
 func (*MsgRegisterWrappedTokenContractResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{61}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{63}
 }
 
 // MigrateAllWrappedTokens migrates all known wrapped-token instances to new_code_id.
@@ -42369,7 +45174,7 @@ type MsgMigrateAllWrappedTokens struct {
 func (x *MsgMigrateAllWrappedTokens) Reset() {
 	*x = MsgMigrateAllWrappedTokens{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[62]
+		mi := &file_inference_inference_tx_proto_msgTypes[64]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42383,7 +45188,7 @@ func (*MsgMigrateAllWrappedTokens) ProtoMessage() {}
 
 // Deprecated: Use MsgMigrateAllWrappedTokens.ProtoReflect.Descriptor instead.
 func (*MsgMigrateAllWrappedTokens) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{62}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{64}
 }
 
 func (x *MsgMigrateAllWrappedTokens) GetAuthority() string {
@@ -42426,7 +45231,7 @@ type MsgMigrateAllWrappedTokensResponse struct {
 func (x *MsgMigrateAllWrappedTokensResponse) Reset() {
 	*x = MsgMigrateAllWrappedTokensResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[63]
+		mi := &file_inference_inference_tx_proto_msgTypes[65]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42440,7 +45245,7 @@ func (*MsgMigrateAllWrappedTokensResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgMigrateAllWrappedTokensResponse.ProtoReflect.Descriptor instead.
 func (*MsgMigrateAllWrappedTokensResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{63}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{65}
 }
 
 func (x *MsgMigrateAllWrappedTokensResponse) GetAttempted() uint32 {
@@ -42463,7 +45268,7 @@ type MsgApproveIbcTokenForTrading struct {
 func (x *MsgApproveIbcTokenForTrading) Reset() {
 	*x = MsgApproveIbcTokenForTrading{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[64]
+		mi := &file_inference_inference_tx_proto_msgTypes[66]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42477,7 +45282,7 @@ func (*MsgApproveIbcTokenForTrading) ProtoMessage() {}
 
 // Deprecated: Use MsgApproveIbcTokenForTrading.ProtoReflect.Descriptor instead.
 func (*MsgApproveIbcTokenForTrading) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{64}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{66}
 }
 
 func (x *MsgApproveIbcTokenForTrading) GetAuthority() string {
@@ -42510,7 +45315,7 @@ type MsgApproveIbcTokenForTradingResponse struct {
 func (x *MsgApproveIbcTokenForTradingResponse) Reset() {
 	*x = MsgApproveIbcTokenForTradingResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[65]
+		mi := &file_inference_inference_tx_proto_msgTypes[67]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42524,7 +45329,7 @@ func (*MsgApproveIbcTokenForTradingResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgApproveIbcTokenForTradingResponse.ProtoReflect.Descriptor instead.
 func (*MsgApproveIbcTokenForTradingResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{65}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{67}
 }
 
 type MsgRegisterIbcTokenMetadata struct {
@@ -42544,7 +45349,7 @@ type MsgRegisterIbcTokenMetadata struct {
 func (x *MsgRegisterIbcTokenMetadata) Reset() {
 	*x = MsgRegisterIbcTokenMetadata{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[66]
+		mi := &file_inference_inference_tx_proto_msgTypes[68]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42558,7 +45363,7 @@ func (*MsgRegisterIbcTokenMetadata) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterIbcTokenMetadata.ProtoReflect.Descriptor instead.
 func (*MsgRegisterIbcTokenMetadata) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{66}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{68}
 }
 
 func (x *MsgRegisterIbcTokenMetadata) GetAuthority() string {
@@ -42619,7 +45424,7 @@ type MsgRegisterIbcTokenMetadataResponse struct {
 func (x *MsgRegisterIbcTokenMetadataResponse) Reset() {
 	*x = MsgRegisterIbcTokenMetadataResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[67]
+		mi := &file_inference_inference_tx_proto_msgTypes[69]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42633,7 +45438,7 @@ func (*MsgRegisterIbcTokenMetadataResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgRegisterIbcTokenMetadataResponse.ProtoReflect.Descriptor instead.
 func (*MsgRegisterIbcTokenMetadataResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{67}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{69}
 }
 
 type MsgCreateDevshardEscrow struct {
@@ -42649,7 +45454,7 @@ type MsgCreateDevshardEscrow struct {
 func (x *MsgCreateDevshardEscrow) Reset() {
 	*x = MsgCreateDevshardEscrow{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[68]
+		mi := &file_inference_inference_tx_proto_msgTypes[70]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42663,7 +45468,7 @@ func (*MsgCreateDevshardEscrow) ProtoMessage() {}
 
 // Deprecated: Use MsgCreateDevshardEscrow.ProtoReflect.Descriptor instead.
 func (*MsgCreateDevshardEscrow) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{68}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{70}
 }
 
 func (x *MsgCreateDevshardEscrow) GetCreator() string {
@@ -42698,7 +45503,7 @@ type MsgCreateDevshardEscrowResponse struct {
 func (x *MsgCreateDevshardEscrowResponse) Reset() {
 	*x = MsgCreateDevshardEscrowResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[69]
+		mi := &file_inference_inference_tx_proto_msgTypes[71]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42712,7 +45517,7 @@ func (*MsgCreateDevshardEscrowResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgCreateDevshardEscrowResponse.ProtoReflect.Descriptor instead.
 func (*MsgCreateDevshardEscrowResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{69}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{71}
 }
 
 func (x *MsgCreateDevshardEscrowResponse) GetEscrowId() uint64 {
@@ -42741,7 +45546,7 @@ type MsgSettleDevshardEscrow struct {
 func (x *MsgSettleDevshardEscrow) Reset() {
 	*x = MsgSettleDevshardEscrow{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[70]
+		mi := &file_inference_inference_tx_proto_msgTypes[72]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42755,7 +45560,7 @@ func (*MsgSettleDevshardEscrow) ProtoMessage() {}
 
 // Deprecated: Use MsgSettleDevshardEscrow.ProtoReflect.Descriptor instead.
 func (*MsgSettleDevshardEscrow) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{70}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{72}
 }
 
 func (x *MsgSettleDevshardEscrow) GetSettler() string {
@@ -42830,7 +45635,7 @@ type MsgSettleDevshardEscrowResponse struct {
 func (x *MsgSettleDevshardEscrowResponse) Reset() {
 	*x = MsgSettleDevshardEscrowResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[71]
+		mi := &file_inference_inference_tx_proto_msgTypes[73]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42844,7 +45649,7 @@ func (*MsgSettleDevshardEscrowResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSettleDevshardEscrowResponse.ProtoReflect.Descriptor instead.
 func (*MsgSettleDevshardEscrowResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{71}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{73}
 }
 
 type MsgSetDevshardRequestsEnabled struct {
@@ -42859,7 +45664,7 @@ type MsgSetDevshardRequestsEnabled struct {
 func (x *MsgSetDevshardRequestsEnabled) Reset() {
 	*x = MsgSetDevshardRequestsEnabled{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[72]
+		mi := &file_inference_inference_tx_proto_msgTypes[74]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42873,7 +45678,7 @@ func (*MsgSetDevshardRequestsEnabled) ProtoMessage() {}
 
 // Deprecated: Use MsgSetDevshardRequestsEnabled.ProtoReflect.Descriptor instead.
 func (*MsgSetDevshardRequestsEnabled) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{72}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{74}
 }
 
 func (x *MsgSetDevshardRequestsEnabled) GetAuthority() string {
@@ -42899,7 +45704,7 @@ type MsgSetDevshardRequestsEnabledResponse struct {
 func (x *MsgSetDevshardRequestsEnabledResponse) Reset() {
 	*x = MsgSetDevshardRequestsEnabledResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_inference_inference_tx_proto_msgTypes[73]
+		mi := &file_inference_inference_tx_proto_msgTypes[75]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -42913,7 +45718,172 @@ func (*MsgSetDevshardRequestsEnabledResponse) ProtoMessage() {}
 
 // Deprecated: Use MsgSetDevshardRequestsEnabledResponse.ProtoReflect.Descriptor instead.
 func (*MsgSetDevshardRequestsEnabledResponse) Descriptor() ([]byte, []int) {
-	return file_inference_inference_tx_proto_rawDescGZIP(), []int{73}
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{75}
+}
+
+// MsgScheduleMaintenance schedules a maintenance window for a participant.
+type MsgScheduleMaintenance struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Creator        string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	Participant    string `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
+	StartHeight    int64  `protobuf:"varint,3,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
+	DurationBlocks uint64 `protobuf:"varint,4,opt,name=duration_blocks,json=durationBlocks,proto3" json:"duration_blocks,omitempty"`
+}
+
+func (x *MsgScheduleMaintenance) Reset() {
+	*x = MsgScheduleMaintenance{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_tx_proto_msgTypes[76]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgScheduleMaintenance) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgScheduleMaintenance) ProtoMessage() {}
+
+// Deprecated: Use MsgScheduleMaintenance.ProtoReflect.Descriptor instead.
+func (*MsgScheduleMaintenance) Descriptor() ([]byte, []int) {
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{76}
+}
+
+func (x *MsgScheduleMaintenance) GetCreator() string {
+	if x != nil {
+		return x.Creator
+	}
+	return ""
+}
+
+func (x *MsgScheduleMaintenance) GetParticipant() string {
+	if x != nil {
+		return x.Participant
+	}
+	return ""
+}
+
+func (x *MsgScheduleMaintenance) GetStartHeight() int64 {
+	if x != nil {
+		return x.StartHeight
+	}
+	return 0
+}
+
+func (x *MsgScheduleMaintenance) GetDurationBlocks() uint64 {
+	if x != nil {
+		return x.DurationBlocks
+	}
+	return 0
+}
+
+type MsgScheduleMaintenanceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	ReservationId uint64 `protobuf:"varint,1,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+}
+
+func (x *MsgScheduleMaintenanceResponse) Reset() {
+	*x = MsgScheduleMaintenanceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_tx_proto_msgTypes[77]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgScheduleMaintenanceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgScheduleMaintenanceResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgScheduleMaintenanceResponse.ProtoReflect.Descriptor instead.
+func (*MsgScheduleMaintenanceResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{77}
+}
+
+func (x *MsgScheduleMaintenanceResponse) GetReservationId() uint64 {
+	if x != nil {
+		return x.ReservationId
+	}
+	return 0
+}
+
+// MsgCancelMaintenance cancels a not-yet-active maintenance reservation.
+type MsgCancelMaintenance struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Creator       string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	ReservationId uint64 `protobuf:"varint,2,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+}
+
+func (x *MsgCancelMaintenance) Reset() {
+	*x = MsgCancelMaintenance{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_tx_proto_msgTypes[78]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgCancelMaintenance) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgCancelMaintenance) ProtoMessage() {}
+
+// Deprecated: Use MsgCancelMaintenance.ProtoReflect.Descriptor instead.
+func (*MsgCancelMaintenance) Descriptor() ([]byte, []int) {
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{78}
+}
+
+func (x *MsgCancelMaintenance) GetCreator() string {
+	if x != nil {
+		return x.Creator
+	}
+	return ""
+}
+
+func (x *MsgCancelMaintenance) GetReservationId() uint64 {
+	if x != nil {
+		return x.ReservationId
+	}
+	return 0
+}
+
+type MsgCancelMaintenanceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MsgCancelMaintenanceResponse) Reset() {
+	*x = MsgCancelMaintenanceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_inference_inference_tx_proto_msgTypes[79]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MsgCancelMaintenanceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MsgCancelMaintenanceResponse) ProtoMessage() {}
+
+// Deprecated: Use MsgCancelMaintenanceResponse.ProtoReflect.Descriptor instead.
+func (*MsgCancelMaintenanceResponse) Descriptor() ([]byte, []int) {
+	return file_inference_inference_tx_proto_rawDescGZIP(), []int{79}
 }
 
 var File_inference_inference_tx_proto protoreflect.FileDescriptor
@@ -42941,189 +45911,196 @@ var file_inference_inference_tx_proto_rawDesc = []byte{
 	0x63, 0x5f, 0x76, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f,
 	0x64, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x28, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x64,
-	0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22,
-	0xc3, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72,
-	0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
-	0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x3e, 0x0a, 0x06, 0x70,
-	0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7,
-	0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x38, 0x82, 0xe7, 0xb0,
-	0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x25,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50,
-	0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61,
-	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0xaf, 0x04, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
-	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
-	0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68, 0x61,
-	0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74,
-	0x48, 0x61, 0x73, 0x68, 0x12, 0x29, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x70,
-	0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01,
-	0x52, 0x0d, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12,
-	0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x73, 0x73, 0x69,
-	0x67, 0x6e, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61,
-	0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x6f, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x6f, 0x64,
-	0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a,
-	0x6d, 0x61, 0x78, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x09, 0x6d, 0x61, 0x78, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x70,
-	0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x63, 0x6f, 0x75, 0x6e,
-	0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x0c,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x6d, 0x61, 0x69, 0x6e, 0x74,
+	0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x28, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x70, 0x6f, 0x63, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x63, 0x6c, 0x61, 0x69,
+	0x6d, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x22, 0xc3, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50,
+	0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+	0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x3e, 0x0a,
+	0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00,
+	0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x38, 0x82,
+	0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0,
+	0x2a, 0x25, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x78, 0x2f, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70,
+	0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0xb1, 0x04, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61,
+	0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
+	0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f,
+	0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f,
+	0x68, 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x6d,
+	0x70, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x29, 0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74,
+	0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02,
+	0x18, 0x01, 0x52, 0x0d, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61,
+	0x64, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x73,
+	0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x54, 0x6f, 0x12, 0x21, 0x0a, 0x0c, 0x6e,
+	0x6f, 0x64, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d,
+	0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x09, 0x6d, 0x61, 0x78, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x2c, 0x0a,
+	0x12, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x63, 0x6f,
+	0x75, 0x6e, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6d, 0x70,
+	0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x72,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d, 0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e,
+	0x73, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0e,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x69,
+	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x2b, 0x0a, 0x0f, 0x6f, 0x72, 0x69, 0x67, 0x69,
+	0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72,
+	0x6f, 0x6d, 0x70, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c,
+	0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x10, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x12, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d,
+	0x70, 0x74, 0x48, 0x61, 0x73, 0x68, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65,
+	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x22, 0x6d, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x74, 0x61,
+	0x72, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d,
+	0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x65, 0x3a, 0x02, 0x18, 0x01, 0x22, 0xa5, 0x05, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e,
+	0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x2d,
+	0x0a, 0x10, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0f, 0x72, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x2c, 0x0a,
+	0x12, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x63, 0x6f,
+	0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6d, 0x70,
+	0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x63,
+	0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f,
+	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x63, 0x6f, 0x6d,
+	0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x75, 0x6e,
+	0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79,
+	0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64,
+	0x42, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, 0x65,
+	0x64, 0x5f, 0x62, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x74, 0x72, 0x61, 0x6e,
+	0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x42, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x09,
 	0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d,
 	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d, 0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66,
-	0x65, 0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0e, 0x20, 0x01,
+	0x65, 0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0a, 0x20, 0x01,
 	0x28, 0x09, 0x52, 0x11, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x69, 0x67, 0x6e,
-	0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x2b, 0x0a, 0x0f, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61,
-	0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02,
-	0x18, 0x01, 0x52, 0x0e, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d,
-	0x70, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70,
-	0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x12, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d, 0x70, 0x74,
-	0x48, 0x61, 0x73, 0x68, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
-	0x6f, 0x72, 0x22, 0x69, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x64,
-	0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x72, 0x72, 0x6f,
-	0x72, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0c, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xa3, 0x05,
-	0x0a, 0x12, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21,
-	0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49,
-	0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x61,
-	0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x2d, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
-	0x42, 0x02, 0x18, 0x01, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61,
-	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f,
-	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f,
-	0x75, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f,
-	0x6e, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x04, 0x52, 0x14, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x65,
-	0x63, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
-	0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x72,
-	0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x08, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x72, 0x65, 0x64, 0x42,
-	0x79, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x69, 0x6d,
-	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d,
-	0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61,
-	0x74, 0x75, 0x72, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x74, 0x72, 0x61, 0x6e,
-	0x73, 0x66, 0x65, 0x72, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x2d, 0x0a,
-	0x12, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74,
-	0x75, 0x72, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75,
-	0x74, 0x6f, 0x72, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x21, 0x0a, 0x0c,
-	0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x0c, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12,
-	0x2b, 0x0a, 0x0f, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6d,
-	0x70, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x6f, 0x72,
-	0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x12, 0x14, 0x0a, 0x05,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64,
-	0x65, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73,
-	0x68, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x48,
-	0x61, 0x73, 0x68, 0x12, 0x30, 0x0a, 0x14, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x5f,
-	0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x10, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x12, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d, 0x70,
-	0x74, 0x48, 0x61, 0x73, 0x68, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x22, 0x6a, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68,
-	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69,
-	0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x72,
-	0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0c, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22,
-	0x97, 0x01, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63,
-	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72,
-	0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a,
-	0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x3a, 0x0c, 0x82, 0xe7, 0xb0,
-	0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x66, 0x0a, 0x1f, 0x4d, 0x73, 0x67,
-	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x11,
-	0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65,
-	0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61,
-	0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
-	0x73, 0x22, 0xbf, 0x02, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x0e, 0x0a,
-	0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a,
-	0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64,
-	0x12, 0x2d, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x70, 0x61, 0x79,
-	0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0f,
-	0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12,
-	0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x48, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x22,
-	0x0a, 0x0c, 0x72, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07,
-	0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x64, 0x65, 0x63, 0x69,
-	0x6d, 0x61, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65,
-	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd2, 0x01, 0x0a,
-	0x1f, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66,
-	0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65,
-	0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12,
-	0x23, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79,
-	0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f,
-	0x72, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x6b,
-	0x65, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72,
-	0x4b, 0x65, 0x79, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
-	0x72, 0x22, 0x29, 0x0a, 0x27, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x2d, 0x0a, 0x12, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f,
+	0x72, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x11, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x6f, 0x72, 0x53, 0x69, 0x67, 0x6e, 0x61,
+	0x74, 0x75, 0x72, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65,
+	0x64, 0x5f, 0x62, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x65, 0x64, 0x42, 0x79, 0x12, 0x2b, 0x0a, 0x0f, 0x6f, 0x72, 0x69, 0x67, 0x69,
+	0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09,
+	0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72,
+	0x6f, 0x6d, 0x70, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x0e, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72,
+	0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0a, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x30, 0x0a, 0x14, 0x6f,
+	0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x5f, 0x68,
+	0x61, 0x73, 0x68, 0x18, 0x10, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6f, 0x72, 0x69, 0x67, 0x69,
+	0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x48, 0x61, 0x73, 0x68, 0x3a, 0x0e, 0x82,
+	0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x22, 0x6e, 0x0a,
+	0x1a, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49,
+	0x6e, 0x64, 0x65, 0x78, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x72, 0x72,
+	0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x3a, 0x02, 0x18, 0x01, 0x22, 0x97, 0x01,
+	0x0a, 0x17, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65,
+	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61,
+	0x74, 0x6f, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x77, 0x6f,
+	0x72, 0x6b, 0x65, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x66, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x53, 0x75,
+	0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+	0x6e, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
+	0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22,
+	0xc1, 0x02, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x12, 0x2d,
+	0x0a, 0x10, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f,
+	0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0f, 0x72, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x23, 0x0a,
+	0x0d, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x61,
+	0x73, 0x68, 0x12, 0x18, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x01, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x22, 0x0a, 0x0c,
+	0x72, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x41, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61,
+	0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65,
+	0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x0c, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65, 0x63, 0x69,
+	0x6d, 0x61, 0x6c, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
+	0x72, 0x18, 0x01, 0x22, 0x1b, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x3a, 0x02, 0x18, 0x01,
+	0x22, 0xd2, 0x01, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65,
 	0x77, 0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69,
-	0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x85, 0x01, 0x0a,
-	0x16, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
-	0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
-	0x72, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69,
-	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65,
-	0x61, 0x74, 0x6f, 0x72, 0x22, 0x20, 0x0a, 0x1e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x85, 0x01, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x52, 0x65,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x12, 0x20,
-	0x0a, 0x0b, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
-	0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x20,
-	0x0a, 0x1e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x70, 0x61, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x18,
+	0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75,
+	0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62,
+	0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72,
+	0x5f, 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x77, 0x6f, 0x72, 0x6b,
+	0x65, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x77, 0x6f,
+	0x72, 0x6b, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x29, 0x0a, 0x27, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d,
+	0x69, 0x74, 0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72,
+	0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x87, 0x01, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69,
+	0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a,
+	0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x22, 0x24, 0x0a, 0x1e, 0x4d, 0x73,
+	0x67, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x3a, 0x02, 0x18, 0x01,
+	0x22, 0x87, 0x01, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x69, 0x6e, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69,
+	0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a,
+	0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x22, 0x24, 0x0a, 0x1e, 0x4d, 0x73,
+	0x67, 0x52, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x3a, 0x02, 0x18, 0x01,
 	0x22, 0x6e, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x77, 0x61,
 	0x72, 0x64, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01,
 	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a,
@@ -43135,763 +46112,821 @@ var file_inference_inference_tx_proto_rawDesc = []byte{
 	0x72, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61,
 	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f,
 	0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0xdb, 0x01, 0x0a, 0x11,
-	0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63,
-	0x68, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
+	0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x89, 0x01, 0x0a, 0x15,
+	0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70,
+	0x69, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12,
+	0x48, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69,
+	0x70, 0x69, 0x65, 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00,
+	0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1f, 0x0a, 0x1d, 0x4d, 0x73, 0x67, 0x53, 0x65,
+	0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xdb, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67,
+	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x18,
+	0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f,
+	0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63,
+	0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18,
+	0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f,
+	0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x62, 0x61, 0x74, 0x63,
+	0x68, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, 0x61, 0x74, 0x63,
+	0x68, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x04, 0x20,
+	0x03, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64,
+	0x69, 0x73, 0x74, 0x18, 0x05, 0x20, 0x03, 0x28, 0x01, 0x52, 0x04, 0x64, 0x69, 0x73, 0x74, 0x12,
+	0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
+	0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0xd0, 0x01, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69,
+	0x74, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56,
+	0x32, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
 	0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x3e, 0x0a, 0x1c, 0x70,
 	0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62,
 	0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28,
 	0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74,
-	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x62,
-	0x61, 0x74, 0x63, 0x68, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62,
-	0x61, 0x74, 0x63, 0x68, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73,
-	0x18, 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x12,
-	0x0a, 0x04, 0x64, 0x69, 0x73, 0x74, 0x18, 0x05, 0x20, 0x03, 0x28, 0x01, 0x52, 0x04, 0x64, 0x69,
-	0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0,
-	0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x73, 0x67,
-	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd0, 0x01, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x56, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x3e,
-	0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72,
-	0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53, 0x74,
-	0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x4b,
-	0x0a, 0x0b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x56, 0x32, 0x52, 0x0b,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0,
-	0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x23, 0x0a, 0x21, 0x4d, 0x73, 0x67,
-	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xf9,
-	0x01, 0x0a, 0x13, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65,
-	0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
+	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x4b, 0x0a, 0x0b, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x56, 0x32, 0x52, 0x0b, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x23, 0x0a, 0x21, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
+	0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x73, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xf9, 0x01, 0x0a, 0x13,
+	0x4d, 0x73, 0x67, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d,
+	0x6d, 0x69, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x3e, 0x0a,
+	0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74,
+	0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61,
+	0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x18, 0x0a,
+	0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x02, 0x18, 0x01,
+	0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f,
+	0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08,
+	0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x3f, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72,
+	0x69, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x50, 0x6f, 0x43, 0x56, 0x32, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1d, 0x0a, 0x1b, 0x4d, 0x73, 0x67, 0x50, 0x6f,
+	0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8e, 0x02, 0x0a, 0x1b, 0x4d, 0x73, 0x67, 0x4d, 0x4c,
+	0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69,
+	0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
 	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
 	0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x74,
 	0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74,
 	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74, 0x61, 0x67, 0x65,
 	0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74,
-	0x12, 0x18, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x42,
-	0x02, 0x18, 0x01, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x09, 0x72, 0x6f,
-	0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x02, 0x18,
-	0x01, 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x3f, 0x0a, 0x07, 0x65,
-	0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x45, 0x6e,
-	0x74, 0x72, 0x79, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x0c, 0x82, 0xe7,
-	0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1d, 0x0a, 0x1b, 0x4d, 0x73,
-	0x67, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69,
-	0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8e, 0x02, 0x0a, 0x1b, 0x4d, 0x73,
-	0x67, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73,
-	0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65,
-	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x12, 0x3e, 0x0a, 0x1c, 0x70, 0x6f, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x67, 0x65,
-	0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x18, 0x70, 0x6f, 0x63, 0x53, 0x74,
-	0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x12, 0x3f, 0x0a, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18, 0x03,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64,
-	0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x77, 0x65, 0x69,
-	0x67, 0x68, 0x74, 0x73, 0x12, 0x46, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18,
-	0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f,
-	0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e,
-	0x74, 0x72, 0x79, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x0c, 0x82, 0xe7,
-	0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x25, 0x0a, 0x23, 0x4d, 0x73,
-	0x67, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73,
-	0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x76, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65,
-	0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x0b,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1c, 0x0a,
-	0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x3a, 0x0c, 0x82, 0xe7, 0xb0,
-	0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x73, 0x67,
-	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x63, 0x0a, 0x23, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x55,
-	0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63,
-	0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65,
-	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07,
-	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x2d, 0x0a, 0x2b, 0x4d, 0x73, 0x67, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74,
-	0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9a, 0x03, 0x0a, 0x10, 0x4d, 0x73, 0x67, 0x52, 0x65,
-	0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x61,
-	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f,
-	0x70, 0x6f, 0x73, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
-	0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x42, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3a, 0x0a, 0x1a, 0x75, 0x6e,
-	0x69, 0x74, 0x73, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x5f, 0x70,
-	0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16,
-	0x75, 0x6e, 0x69, 0x74, 0x73, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x65,
-	0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x68, 0x66, 0x5f, 0x72, 0x65, 0x70,
-	0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x68, 0x66, 0x52, 0x65, 0x70, 0x6f, 0x12,
-	0x1b, 0x0a, 0x09, 0x68, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x08, 0x68, 0x66, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09,
-	0x52, 0x09, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x41, 0x72, 0x67, 0x73, 0x12, 0x13, 0x0a, 0x05, 0x76,
-	0x5f, 0x72, 0x61, 0x6d, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x76, 0x52, 0x61, 0x6d,
-	0x12, 0x30, 0x0a, 0x14, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70, 0x75, 0x74, 0x5f, 0x70,
-	0x65, 0x72, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12,
-	0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70, 0x75, 0x74, 0x50, 0x65, 0x72, 0x4e, 0x6f, 0x6e,
-	0x63, 0x65, 0x12, 0x4f, 0x0a, 0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x13,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68,
-	0x6f, 0x6c, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
-	0x69, 0x74, 0x79, 0x22, 0x1a, 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
-	0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x58, 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f, 0x76, 0x65,
-	0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x61,
-	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x22, 0x0a, 0x20, 0x4d, 0x73, 0x67,
-	0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65,
-	0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc5, 0x01,
-	0x0a, 0x15, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77,
-	0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
-	0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
-	0x72, 0x12, 0x47, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x4f, 0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69,
-	0x65, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48,
-	0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x0d, 0x6e, 0x65, 0x77,
-	0x4f, 0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x12, 0x3b, 0x0a, 0x07, 0x72, 0x65,
-	0x6d, 0x6f, 0x76, 0x65, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x07,
-	0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72,
-	0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x1f, 0x0a, 0x1d, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d,
-	0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xab, 0x01, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x43, 0x72,
-	0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61,
-	0x64, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65,
-	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e,
-	0x6f, 0x64, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x0f, 0x61, 0x70,
-	0x69, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x69, 0x65, 0x73, 0x4a, 0x73, 0x6f, 0x6e, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x70, 0x69, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x69, 0x65, 0x73,
-	0x4a, 0x73, 0x6f, 0x6e, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f,
-	0x72, 0x69, 0x74, 0x79, 0x22, 0x21, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74,
-	0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd5, 0x02, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x42,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1c, 0x0a,
-	0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x20, 0x0a, 0x0b, 0x6f,
-	0x72, 0x69, 0x67, 0x69, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0b, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x28, 0x0a,
-	0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x77, 0x6e, 0x65, 0x72,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f,
-	0x77, 0x6e, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x6f,
-	0x77, 0x6e, 0x65, 0x72, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0b, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x16, 0x0a,
-	0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61,
-	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75,
-	0x6d, 0x62, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x63, 0x65, 0x69,
-	0x70, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72,
-	0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0c, 0x72,
-	0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x3a,
-	0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x22,
-	0x2b, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78, 0x63, 0x68,
-	0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02,
-	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x6b, 0x0a, 0x1d,
-	0x4d, 0x73, 0x67, 0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
-	0x74, 0x73, 0x54, 0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, 0x0a,
-	0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61,
-	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09,
-	0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x27, 0x0a, 0x25, 0x4d, 0x73, 0x67,
-	0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x54,
-	0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x70, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50,
-	0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41,
-	0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
+	0x12, 0x3f, 0x0a, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65,
+	0x69, 0x67, 0x68, 0x74, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
+	0x73, 0x12, 0x46, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x44,
+	0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07,
+	0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x25, 0x0a, 0x23, 0x4d, 0x73, 0x67, 0x4d, 0x4c,
+	0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69,
+	0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x76,
+	0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x12,
+	0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f,
+	0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a,
+	0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69,
+	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63,
+	0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
+	0x6d, 0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x63, 0x0a, 0x23, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69, 0x74,
+	0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72,
+	0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
+	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x05, 0x70, 0x72, 0x69, 0x63, 0x65, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65,
+	0x61, 0x74, 0x6f, 0x72, 0x22, 0x2d, 0x0a, 0x2b, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69,
+	0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72,
+	0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x9a, 0x03, 0x0a, 0x10, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73,
+	0x74, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
 	0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74,
-	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73,
-	0x73, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x65, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f,
-	0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x0a, 0x2a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76,
-	0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f,
-	0x6d, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x86, 0x01, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
-	0x65, 0x72, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
-	0x73, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12,
-	0x1c, 0x0a, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a,
-	0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09,
-	0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0,
-	0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x24, 0x0a, 0x22, 0x4d,
-	0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0xf2, 0x01, 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
-	0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c,
-	0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07,
-	0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63,
-	0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61,
-	0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x05,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x12, 0x1a, 0x0a, 0x08,
-	0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08,
-	0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72,
-	0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65,
-	0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
-	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x22, 0x0a, 0x20, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67,
-	0x69, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
-	0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x93, 0x01, 0x0a, 0x1f, 0x4d,
-	0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x1c,
-	0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07,
-	0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63,
-	0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61,
-	0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73,
+	0x65, 0x64, 0x5f, 0x62, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x6f,
+	0x70, 0x6f, 0x73, 0x65, 0x64, 0x42, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3a, 0x0a, 0x1a, 0x75, 0x6e, 0x69, 0x74, 0x73,
+	0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f,
+	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, 0x75, 0x6e, 0x69,
+	0x74, 0x73, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x65, 0x72, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x68, 0x66, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x68, 0x66, 0x52, 0x65, 0x70, 0x6f, 0x12, 0x1b, 0x0a, 0x09,
+	0x68, 0x66, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x08, 0x68, 0x66, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x6f, 0x64,
+	0x65, 0x6c, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x41, 0x72, 0x67, 0x73, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x5f, 0x72, 0x61,
+	0x6d, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x76, 0x52, 0x61, 0x6d, 0x12, 0x30, 0x0a,
+	0x14, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x70, 0x75, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f,
+	0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x74, 0x68, 0x72,
+	0x6f, 0x75, 0x67, 0x68, 0x70, 0x75, 0x74, 0x50, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x12,
+	0x4f, 0x0a, 0x14, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x68,
+	0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x52, 0x13, 0x76, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64,
 	0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x22, 0x29, 0x0a, 0x27, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72,
-	0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64,
-	0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa0, 0x01, 0x0a, 0x18,
-	0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x71, 0x75, 0x69,
-	0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
+	0x22, 0x1a, 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x58, 0x0a, 0x18,
+	0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61,
+	0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
 	0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74,
-	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69,
-	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12,
-	0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
-	0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,
-	0x69, 0x61, 0x74, 0x65, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e,
-	0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x4d, 0x73, 0x67, 0x3a, 0x0e,
-	0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x22,
-	0x0a, 0x20, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x71,
-	0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0xee, 0x01, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61,
-	0x6c, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x75,
-	0x73, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0b, 0x75, 0x73, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16,
-	0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
-	0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x12, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x64, 0x65, 0x73, 0x74, 0x69,
-	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x64, 0x65, 0x73,
-	0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x22, 0x8a, 0x01, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77,
-	0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
-	0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f,
-	0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a,
-	0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c,
-	0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x0c, 0x62, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64,
-	0x22, 0xe0, 0x01, 0x0a, 0x14, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65,
-	0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x64,
-	0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
-	0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x19, 0x0a, 0x08,
-	0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x3c, 0x0a, 0x1a, 0x64, 0x65, 0x73, 0x74, 0x69,
-	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x61, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x64, 0x65, 0x73,
-	0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64,
-	0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x22, 0x84, 0x01, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f,
-	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64,
-	0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49,
-	0x6e, 0x64, 0x65, 0x78, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x62, 0x6c,
-	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x22, 0x61, 0x0a, 0x18, 0x4d, 0x73,
-	0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65,
-	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x22, 0x0a, 0x20, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c,
+	0x65, 0x74, 0x65, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64,
+	0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc5, 0x01, 0x0a, 0x15, 0x4d,
+	0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65,
+	0x44, 0x69, 0x66, 0x66, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x47,
+	0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x4f, 0x72, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x18,
+	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48, 0x61, 0x72, 0x64,
+	0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x0d, 0x6e, 0x65, 0x77, 0x4f, 0x72, 0x4d,
+	0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x12, 0x3b, 0x0a, 0x07, 0x72, 0x65, 0x6d, 0x6f, 0x76,
+	0x65, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x48,
+	0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x07, 0x72, 0x65, 0x6d,
+	0x6f, 0x76, 0x65, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
+	0x6f, 0x72, 0x22, 0x1f, 0x0a, 0x1d, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48,
+	0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0xab, 0x01, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x12,
+	0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x16, 0x0a,
+	0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x56, 0x65, 0x72,
+	0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65,
+	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x0f, 0x61, 0x70, 0x69, 0x42, 0x69,
+	0x6e, 0x61, 0x72, 0x69, 0x65, 0x73, 0x4a, 0x73, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0f, 0x61, 0x70, 0x69, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x69, 0x65, 0x73, 0x4a, 0x73, 0x6f,
+	0x6e, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
+	0x79, 0x22, 0x21, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd5, 0x02, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x42, 0x72, 0x69, 0x64,
+	0x67, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x76, 0x61,
+	0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x72, 0x69, 0x67,
+	0x69, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f,
+	0x72, 0x69, 0x67, 0x69, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x28, 0x0a, 0x0f, 0x63, 0x6f,
+	0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, 0x77, 0x6e, 0x65,
+	0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x77, 0x6e, 0x65,
+	0x72, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f,
+	0x77, 0x6e, 0x65, 0x72, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d,
+	0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75,
+	0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65,
+	0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75,
+	0x6d, 0x62, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x49,
+	0x6e, 0x64, 0x65, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x65,
+	0x69, 0x70, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x63, 0x65,
+	0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c,
+	0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x73, 0x52, 0x6f, 0x6f, 0x74, 0x3a, 0x0e, 0x82, 0xe7,
+	0xb0, 0x2a, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x2b, 0x0a, 0x19,
+	0x4d, 0x73, 0x67, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x6b, 0x0a, 0x1d, 0x4d, 0x73, 0x67,
+	0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x54,
+	0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75,
+	0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x27, 0x0a, 0x25, 0x4d, 0x73, 0x67, 0x41, 0x64, 0x64,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x54, 0x6f, 0x41, 0x6c,
+	0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x70, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74,
+	0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c, 0x6c, 0x6f,
+	0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+	0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73,
+	0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
+	0x79, 0x22, 0x2c, 0x0a, 0x2a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c,
+	0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x86, 0x01, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42,
+	0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x1c,
+	0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09,
+	0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x24, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x52,
+	0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xf2,
+	0x01, 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61,
+	0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69,
+	0x6e, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f,
+	0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x12, 0x0a,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
+	0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x64, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69,
+	0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72,
+	0x69, 0x74, 0x65, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x74, 0x79, 0x22, 0x22, 0x0a, 0x20, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
+	0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x93, 0x01, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x41,
+	0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61,
+	0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69,
+	0x6e, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41,
+	0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x6f,
+	0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a, 0x0e, 0x82,
+	0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x29, 0x0a,
+	0x27, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67,
+	0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa0, 0x01, 0x0a, 0x18, 0x4d, 0x73, 0x67,
+	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74,
+	0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+	0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x74, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05,
+	0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62,
+	0x65, 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x74,
+	0x65, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x6e, 0x73,
+	0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x4d, 0x73, 0x67, 0x3a, 0x0e, 0x82, 0xe7, 0xb0,
+	0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x22, 0x0a, 0x20, 0x4d,
+	0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64,
+	0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0xee, 0x01, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72,
+	0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x12, 0x18,
+	0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x75, 0x73, 0x65, 0x72,
+	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b,
+	0x75, 0x73, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x61,
+	0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x12, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x1a, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x22, 0x8a, 0x01, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42,
+	0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f,
+	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f,
+	0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x73, 0x5f, 0x72,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x0c, 0x62, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x22, 0xe0, 0x01,
+	0x0a, 0x14, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64,
+	0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f,
 	0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
-	0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x3a,
-	0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x22, 0x0a,
-	0x20, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+	0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x64, 0x65, 0x73, 0x74,
+	0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61,
+	0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61,
+	0x69, 0x6e, 0x49, 0x64, 0x12, 0x3c, 0x0a, 0x1a, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65,
+	0x73, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x22, 0x84, 0x01, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42,
+	0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64,
+	0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65,
+	0x78, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x62, 0x6c, 0x73, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x22, 0x61, 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x43, 0x61,
+	0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a,
+	0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x3a, 0x0c, 0x82, 0xe7,
+	0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x22, 0x22, 0x0a, 0x20, 0x4d, 0x73,
+	0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65,
+	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc2,
+	0x02, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65,
+	0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+	0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1d, 0x0a,
+	0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x47, 0x0a, 0x12,
+	0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65,
+	0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x11, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x52, 0x65, 0x63, 0x69,
+	0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x54, 0x0a, 0x19, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64,
+	0x65, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61,
+	0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x17, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x57, 0x72, 0x61, 0x70,
+	0x70, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72,
+	0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61,
+	0x73, 0x6f, 0x6e, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x74, 0x79, 0x22, 0x2c, 0x0a, 0x2a, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e,
+	0x61, 0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
 	0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0xc2, 0x02, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61,
-	0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f,
-	0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
-	0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d,
-	0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12,
-	0x47, 0x0a, 0x12, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x5f, 0x72, 0x65, 0x63, 0x69,
-	0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d,
-	0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x11, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x52,
-	0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x54, 0x0a, 0x19, 0x6f, 0x76, 0x65, 0x72,
-	0x72, 0x69, 0x64, 0x65, 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e,
-	0x74, 0x72, 0x61, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d,
-	0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x17, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x57,
-	0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x16,
-	0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
-	0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
-	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x2c, 0x0a, 0x2a, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76,
-	0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69,
-	0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x82, 0x01, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69,
-	0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
-	0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68,
-	0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d,
-	0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53,
-	0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x12, 0x17, 0x0a, 0x07, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x06, 0x63, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x29, 0x0a, 0x27, 0x4d, 0x73, 0x67,
-	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc4, 0x01, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x4d, 0x69, 0x67, 0x72,
-	0x61, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d,
-	0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
-	0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x6e,
-	0x65, 0x77, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x52, 0x09, 0x6e, 0x65, 0x77, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x6d,
-	0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x6d, 0x73, 0x67, 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x4d, 0x73,
-	0x67, 0x4a, 0x73, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04,
-	0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x3a, 0x0e, 0x82, 0xe7, 0xb0,
-	0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x42, 0x0a, 0x22, 0x4d,
-	0x73, 0x67, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70,
-	0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x65, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x65, 0x64, 0x22,
-	0x82, 0x01, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x49, 0x62,
-	0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67,
-	0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18,
-	0x0a, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x62, 0x63, 0x44,
-	0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x62, 0x63, 0x44,
-	0x65, 0x6e, 0x6f, 0x6d, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f,
-	0x72, 0x69, 0x74, 0x79, 0x22, 0x26, 0x0a, 0x24, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f,
-	0x76, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61,
-	0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xe7, 0x01, 0x0a,
-	0x1b, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x49, 0x62, 0x63, 0x54,
-	0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68,
-	0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61,
-	0x69, 0x6e, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f, 0x6d,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f, 0x6d,
-	0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x05,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x12, 0x1a, 0x0a, 0x08,
-	0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08,
-	0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72,
-	0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65,
-	0x72, 0x77, 0x72, 0x69, 0x74, 0x65, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
-	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x25, 0x0a, 0x23, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67,
-	0x69, 0x73, 0x74, 0x65, 0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74,
-	0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x74, 0x0a,
-	0x17, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61,
-	0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74,
-	0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x49, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61,
-	0x74, 0x6f, 0x72, 0x22, 0x3e, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
-	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77,
-	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x65, 0x73, 0x63, 0x72, 0x6f,
-	0x77, 0x49, 0x64, 0x22, 0xa7, 0x03, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c,
-	0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12,
-	0x18, 0x0a, 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x73, 0x63,
-	0x72, 0x6f, 0x77, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x65, 0x73,
-	0x63, 0x72, 0x6f, 0x77, 0x49, 0x64, 0x12, 0x44, 0x0a, 0x1f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f,
-	0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
-	0x6c, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x1b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x41, 0x6e, 0x64, 0x50, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a,
-	0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c,
-	0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6e,
-	0x6f, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63,
-	0x65, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x65, 0x73, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x4f,
-	0x0a, 0x0a, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72,
-	0x64, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x53,
-	0x74, 0x61, 0x74, 0x73, 0x52, 0x09, 0x68, 0x6f, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12,
-	0x4a, 0x0a, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x07, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61,
-	0x72, 0x64, 0x53, 0x6c, 0x6f, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52,
-	0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x66,
-	0x65, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x66, 0x65, 0x65, 0x73, 0x3a,
-	0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x22, 0x21, 0x0a,
-	0x1f, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61,
-	0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x22, 0x67, 0x0a, 0x1d, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61,
-	0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65,
-	0x64, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12,
-	0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08,
-	0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09,
-	0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x27, 0x0a, 0x25, 0x4d, 0x73, 0x67,
-	0x53, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x32, 0x9f, 0x27, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x62, 0x0a, 0x0c, 0x55, 0x70,
-	0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x24, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
-	0x1a, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
-	0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68,
-	0x0a, 0x0e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x12, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x22, 0x82, 0x01, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
+	0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x6e,
+	0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69,
+	0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f,
+	0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69,
+	0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x17, 0x0a,
+	0x07, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06,
+	0x63, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x29, 0x0a, 0x27, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67,
+	0x69, 0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0xc4, 0x01, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65,
+	0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e,
+	0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1e, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f,
+	0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6e,
+	0x65, 0x77, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x69, 0x67, 0x72,
+	0x61, 0x74, 0x65, 0x5f, 0x6d, 0x73, 0x67, 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x4d, 0x73, 0x67, 0x4a, 0x73,
+	0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61,
+	0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x42, 0x0a, 0x22, 0x4d, 0x73, 0x67, 0x4d,
+	0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c,
+	0x0a, 0x09, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0d, 0x52, 0x09, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x65, 0x64, 0x22, 0x82, 0x01, 0x0a,
+	0x1c, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x0a,
+	0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x63,
+	0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68,
+	0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f,
+	0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f,
+	0x6d, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74,
+	0x79, 0x22, 0x26, 0x0a, 0x24, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x49,
+	0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e,
+	0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xe7, 0x01, 0x0a, 0x1b, 0x4d, 0x73,
+	0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65,
+	0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75,
+	0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e,
+	0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49,
+	0x64, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x69, 0x62, 0x63, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x12, 0x0a,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
+	0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x64, 0x65, 0x63,
+	0x69, 0x6d, 0x61, 0x6c, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72, 0x69,
+	0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x72,
+	0x69, 0x74, 0x65, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72,
+	0x69, 0x74, 0x79, 0x22, 0x25, 0x0a, 0x23, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
+	0x65, 0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x74, 0x0a, 0x17, 0x4d, 0x73,
+	0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45,
+	0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12,
+	0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x49, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x22, 0x3e, 0x0a, 0x1f, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76,
+	0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x5f, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x49, 0x64,
+	0x22, 0xa7, 0x03, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44, 0x65,
+	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x18, 0x0a, 0x07,
+	0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73,
+	0x65, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x73, 0x63, 0x72, 0x6f, 0x77,
+	0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x65, 0x73, 0x63, 0x72, 0x6f,
+	0x77, 0x49, 0x64, 0x12, 0x44, 0x0a, 0x1f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f,
+	0x74, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x76,
+	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1b, 0x73, 0x74,
+	0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x41, 0x6e, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61,
+	0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73,
+	0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63,
+	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x1b,
+	0x0a, 0x09, 0x72, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x0c, 0x52, 0x08, 0x72, 0x65, 0x73, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x4f, 0x0a, 0x0a, 0x68,
+	0x6f, 0x73, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x53, 0x65,
+	0x74, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x6f, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x52, 0x09, 0x68, 0x6f, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x4a, 0x0a, 0x0a,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x53,
+	0x6c, 0x6f, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x0a, 0x73, 0x69,
+	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x65, 0x65, 0x73,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x66, 0x65, 0x65, 0x73, 0x3a, 0x0c, 0x82, 0xe7,
+	0xb0, 0x2a, 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x22, 0x21, 0x0a, 0x1f, 0x4d, 0x73,
+	0x67, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45,
+	0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x67, 0x0a,
+	0x1d, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x1c,
+	0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07,
+	0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65,
+	0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74,
+	0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x27, 0x0a, 0x25, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74,
+	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73,
+	0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0xae, 0x01, 0x0a, 0x16, 0x4d, 0x73, 0x67, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72,
+	0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65,
+	0x61, 0x74, 0x6f, 0x72, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f,
+	0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x73, 0x74,
+	0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x75, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x04, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x0e, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63,
+	0x6b, 0x73, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x22, 0x47, 0x0a, 0x1e, 0x4d, 0x73, 0x67, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65,
+	0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x65, 0x0a, 0x14, 0x4d, 0x73, 0x67,
+	0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63,
+	0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x25, 0x0a, 0x0e, 0x72,
+	0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x49, 0x64, 0x3a, 0x0c, 0x82, 0xe7, 0xb0, 0x2a, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72,
+	0x22, 0x1e, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4d, 0x61, 0x69,
+	0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x32, 0x9a, 0x2a, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x62, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x24, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
-	0x73, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6b, 0x0a, 0x0f, 0x46, 0x69, 0x6e, 0x69,
-	0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x27, 0x2e, 0x69, 0x6e,
+	0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x2c,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61,
+	0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6d, 0x0a, 0x0e,
+	0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x26,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
+	0x53, 0x74, 0x61, 0x72, 0x74, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12, 0x70, 0x0a, 0x0f, 0x46,
+	0x69, 0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x27,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
+	0x67, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12, 0x7a, 0x0a,
+	0x14, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63,
+	0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53,
+	0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x1a, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
+	0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e,
+	0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x0a, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
+	0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x2a, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x1a, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x69,
-	0x6e, 0x69, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x14, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e,
-	0x65, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x2c, 0x2e,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12, 0x92, 0x01, 0x0a,
+	0x1c, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64,
+	0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x12, 0x34, 0x2e,
 	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77,
-	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x1a, 0x34, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x50, 0x61,
+	0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
+	0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61,
 	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x5c, 0x0a, 0x0a, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x22, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x1a, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x92, 0x01, 0x0a, 0x1c, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66,
-	0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
-	0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
-	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x4e, 0x65, 0x77, 0x55, 0x6e, 0x66, 0x75, 0x6e, 0x64, 0x65,
-	0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a, 0x13, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61,
-	0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x12, 0x7c, 0x0a, 0x13, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
 	0x73, 0x67, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a,
-	0x13, 0x52, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
-	0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0c, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52,
-	0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x24, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x49,
+	0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12,
+	0x7c, 0x0a, 0x13, 0x52, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
-	0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x1a, 0x2c, 0x2e, 0x69,
+	0x52, 0x65, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x76,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x12, 0x62, 0x0a,
+	0x0c, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x12, 0x24, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x77, 0x61,
+	0x72, 0x64, 0x73, 0x1a, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x61,
+	0x69, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x74, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63,
+	0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
+	0x67, 0x53, 0x65, 0x74, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65,
+	0x6e, 0x74, 0x73, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74,
+	0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x0e, 0x53, 0x75, 0x62, 0x6d, 0x69,
+	0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63,
+	0x68, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69,
+	0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x80, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x12, 0x2e, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x6c, 0x61, 0x69, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72,
-	0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x0e, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x26, 0x2e, 0x69,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x1a, 0x36, 0x2e, 0x69,
 	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42,
-	0x61, 0x74, 0x63, 0x68, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75,
-	0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50,
-	0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x12,
-	0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50,
-	0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x1a,
-	0x36, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50,
-	0x6f, 0x63, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x10, 0x50, 0x6f, 0x43, 0x56, 0x32,
-	0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x28, 0x2e, 0x69, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x63, 0x56,
+	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x10, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f,
+	0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
+	0x73, 0x67, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d,
+	0x69, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x43, 0x56,
+	0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x86, 0x01, 0x0a, 0x18, 0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57,
+	0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x4c, 0x4e, 0x6f, 0x64,
+	0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
+	0x69, 0x6f, 0x6e, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x4c, 0x4e,
+	0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62,
+	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a,
+	0x0a, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x12, 0x22, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43,
-	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x50,
-	0x6f, 0x43, 0x56, 0x32, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x86, 0x01, 0x0a, 0x18, 0x4d, 0x4c, 0x4e, 0x6f,
-	0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75,
-	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x4c,
-	0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69,
-	0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x1a,
+	0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53,
+	0x65, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9e, 0x01, 0x0a, 0x20,
+	0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70,
+	0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c,
+	0x12, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74,
+	0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69,
+	0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x1a, 0x40, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66,
+	0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70,
+	0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0d,
+	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x25, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d,
+	0x6f, 0x64, 0x65, 0x6c, 0x1a, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
+	0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f, 0x76,
+	0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x2d, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f, 0x76, 0x65,
+	0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x1a, 0x35, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f, 0x76, 0x65, 0x72,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x74, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64,
+	0x77, 0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66, 0x12, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
+	0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65,
+	0x44, 0x69, 0x66, 0x66, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75,
+	0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61,
+	0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65,
+	0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x1a, 0x34,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61,
+	0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x0e, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78,
+	0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
-	0x4d, 0x4c, 0x4e, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x44, 0x69, 0x73, 0x74,
-	0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x5c, 0x0a, 0x0a, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x12, 0x22,
+	0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x1a, 0x2e,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x65,
-	0x65, 0x64, 0x1a, 0x2a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d,
-	0x69, 0x74, 0x53, 0x65, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9e,
-	0x01, 0x0a, 0x20, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43,
-	0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f,
-	0x73, 0x61, 0x6c, 0x12, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62,
-	0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69, 0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65,
-	0x50, 0x72, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x1a, 0x40, 0x2e,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78,
+	0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x83,
+	0x01, 0x0a, 0x17, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42, 0x72, 0x69, 0x64, 0x67,
+	0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42, 0x72, 0x69, 0x64,
+	0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x1a, 0x37, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42, 0x72, 0x69,
+	0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
+	0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x2d, 0x2e,
 	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x55, 0x6e, 0x69,
-	0x74, 0x4f, 0x66, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x50,
-	0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x65, 0x0a, 0x0d, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c,
-	0x12, 0x25, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
-	0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x1a, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
-	0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
-	0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x12,
-	0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47,
-	0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x1a, 0x35,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x6f,
-	0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48,
-	0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66, 0x12, 0x2a, 0x2e, 0x69, 0x6e,
+	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4c,
+	0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x1a, 0x35, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4c, 0x69,
+	0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x54,
+	0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2d, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x35, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77,
-	0x61, 0x72, 0x65, 0x44, 0x69, 0x66, 0x66, 0x1a, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
-	0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x44,
-	0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x14, 0x43,
-	0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72,
-	0x61, 0x64, 0x65, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64,
-	0x65, 0x1a, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74,
-	0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x0e, 0x42, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x26, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x6b,
+	0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x92, 0x01, 0x0a, 0x1c, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72,
+	0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64,
+	0x69, 0x6e, 0x67, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70,
+	0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46,
+	0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65,
 	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x4d, 0x73, 0x67, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67,
-	0x65, 0x1a, 0x2e, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x83, 0x01, 0x0a, 0x17, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42, 0x72,
-	0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x2f, 0x2e,
+	0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x83, 0x01, 0x0a, 0x17, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61,
+	0x77, 0x61, 0x6c, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72,
+	0x61, 0x77, 0x61, 0x6c, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x64,
+	0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x71, 0x0a,
+	0x11, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69,
+	0x6e, 0x74, 0x12, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x1a, 0x31, 0x2e,
 	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x42,
-	0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x1a, 0x37,
+	0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72,
+	0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x7d, 0x0a, 0x15, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+	0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f,
+	0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
+	0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70,
+	0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x9b, 0x01, 0x0a, 0x1f, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x61,
+	0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76,
+	0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69,
+	0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x3f, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65,
+	0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x92, 0x01,
+	0x0a, 0x1c, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65,
+	0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x34,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
-	0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x52, 0x65, 0x67, 0x69, 0x73,
-	0x74, 0x65, 0x72, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c,
-	0x12, 0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
-	0x65, 0x72, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x1a,
-	0x35, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
-	0x72, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
-	0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12,
-	0x2d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
-	0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x35,
+	0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x6e, 0x74,
+	0x72, 0x61, 0x63, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
+	0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b,
+	0x65, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x83, 0x01, 0x0a, 0x17, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x41, 0x6c,
+	0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x2f,
 	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
-	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x92, 0x01, 0x0a, 0x1c, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76,
-	0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54,
-	0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
-	0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x1a, 0x3c, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x42, 0x72, 0x69,
-	0x64, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69,
-	0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x83, 0x01, 0x0a, 0x17, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68,
-	0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69, 0x74,
-	0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x41,
+	0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x1a,
+	0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65,
+	0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x8c, 0x01, 0x0a, 0x1a, 0x41, 0x64, 0x64,
+	0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x54, 0x6f, 0x41, 0x6c,
+	0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
 	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
-	0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x57, 0x69,
-	0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x71, 0x0a, 0x11, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x4d, 0x69, 0x6e, 0x74, 0x12, 0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74,
-	0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4d, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x7d, 0x0a, 0x15, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69,
-	0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64,
-	0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x35, 0x2e, 0x69, 0x6e,
+	0x67, 0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73,
+	0x54, 0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x1a, 0x3a, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67,
-	0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x9b, 0x01, 0x0a, 0x1f, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63,
-	0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65,
-	0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
-	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
-	0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c,
-	0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a,
-	0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61,
-	0x6e, 0x63, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x4f,
-	0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x92, 0x01, 0x0a, 0x1c, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61,
-	0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63,
-	0x74, 0x12, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73,
-	0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43,
-	0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x1a, 0x3c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
-	0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64,
-	0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x83, 0x01, 0x0a, 0x17, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74,
-	0x65, 0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
-	0x73, 0x12, 0x2f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x69, 0x67, 0x72, 0x61,
-	0x74, 0x65, 0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65,
-	0x6e, 0x73, 0x1a, 0x37, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x4d, 0x69, 0x67, 0x72,
-	0x61, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x8c, 0x01, 0x0a, 0x1a,
-	0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x54,
-	0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66,
-	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x4d, 0x73, 0x67, 0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x73, 0x54, 0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x1a, 0x3a,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69,
-	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x54, 0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69,
-	0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9b, 0x01, 0x0a, 0x1f, 0x52,
-	0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74,
-	0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x37,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61,
-	0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c,
-	0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73,
-	0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
-	0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x89, 0x01, 0x0a, 0x19, 0x41, 0x70, 0x70,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x64, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70,
+	0x61, 0x6e, 0x74, 0x73, 0x54, 0x6f, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9b, 0x01, 0x0a, 0x1f, 0x52, 0x65, 0x6d, 0x6f,
+	0x76, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72,
+	0x6f, 0x6d, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x37, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69,
+	0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c, 0x6c, 0x6f, 0x77,
+	0x4c, 0x69, 0x73, 0x74, 0x1a, 0x3f, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
+	0x6d, 0x6f, 0x76, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73,
+	0x46, 0x72, 0x6f, 0x6d, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x89, 0x01, 0x0a, 0x19, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76,
+	0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64,
+	0x69, 0x6e, 0x67, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x41, 0x70, 0x70,
 	0x72, 0x6f, 0x76, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54,
-	0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x31, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x1a, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
 	0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67,
 	0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46,
-	0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x1a, 0x39, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x4d, 0x73, 0x67, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 0x46, 0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x86, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
-	0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
-	0x61, 0x12, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73,
-	0x74, 0x65, 0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64,
-	0x61, 0x74, 0x61, 0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67,
-	0x69, 0x73, 0x74, 0x65, 0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74,
-	0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a,
-	0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45,
-	0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43,
-	0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63,
-	0x72, 0x6f, 0x77, 0x1a, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
-	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f,
-	0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x14, 0x53, 0x65, 0x74,
-	0x74, 0x6c, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f,
-	0x77, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c,
-	0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x1a,
-	0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
-	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44,
-	0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x8c, 0x01, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x44, 0x65, 0x76,
-	0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x61,
-	0x62, 0x6c, 0x65, 0x64, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65,
-	0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
-	0x73, 0x67, 0x53, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x10, 0x53, 0x65, 0x74, 0x50, 0x6f, 0x43, 0x44, 0x65,
-	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
-	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
-	0x73, 0x67, 0x53, 0x65, 0x74, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
-	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50,
-	0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a, 0x13, 0x52, 0x65, 0x66, 0x75, 0x73, 0x65, 0x50, 0x6f,
-	0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x66, 0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65,
-	0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x6f, 0x72, 0x54, 0x72, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x86, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x49, 0x62,
+	0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x30,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
+	0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x1a, 0x38, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
+	0x65, 0x72, 0x49, 0x62, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x14, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72,
+	0x6f, 0x77, 0x12, 0x2c, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61,
+	0x74, 0x65, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77,
+	0x1a, 0x34, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
+	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x14, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65,
+	0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x12, 0x2c,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
+	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44, 0x65,
+	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x1a, 0x34, 0x2e, 0x69,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44, 0x65, 0x76, 0x73,
+	0x68, 0x61, 0x72, 0x64, 0x45, 0x73, 0x63, 0x72, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x8c, 0x01, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61,
+	0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+	0x64, 0x12, 0x32, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x44, 0x65,
+	0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x45, 0x6e,
+	0x61, 0x62, 0x6c, 0x65, 0x64, 0x1a, 0x3a, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53,
+	0x65, 0x74, 0x44, 0x65, 0x76, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x73, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x77, 0x0a, 0x13, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, 0x69,
+	0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72,
 	0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d,
-	0x73, 0x67, 0x52, 0x65, 0x66, 0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a,
-	0x10, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e,
-	0x74, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x63, 0x6c, 0x61,
-	0x72, 0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e,
+	0x73, 0x67, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+	0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53,
+	0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+	0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x71, 0x0a, 0x11, 0x43, 0x61,
+	0x6e, 0x63, 0x65, 0x6c, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12,
+	0x29, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4d,
+	0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x1a, 0x31, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65,
+	0x6e, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a,
+	0x10, 0x53, 0x65, 0x74, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50, 0x6f,
+	0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x30, 0x2e, 0x69, 0x6e,
 	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43, 0x49,
-	0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80,
-	0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xb5, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66,
+	0x65, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a,
+	0x13, 0x52, 0x65, 0x66, 0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65,
+	0x66, 0x75, 0x73, 0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x1a, 0x33, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e,
+	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x66, 0x75, 0x73,
+	0x65, 0x50, 0x6f, 0x43, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x10, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72,
+	0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x28, 0x2e, 0x69, 0x6e, 0x66,
 	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
-	0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73,
-	0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e,
-	0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58, 0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13,
-	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65,
-	0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c,
-	0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74,
-	0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
-	0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e,
+	0x74, 0x65, 0x6e, 0x74, 0x1a, 0x30, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65,
+	0x63, 0x6c, 0x61, 0x72, 0x65, 0x50, 0x6f, 0x43, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xb5, 0x01,
+	0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e,
+	0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f,
+	0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e,
+	0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+	0x2f, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xa2, 0x02, 0x03, 0x49, 0x49, 0x58,
+	0xaa, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x66,
+	0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xca, 0x02, 0x13, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0xe2, 0x02, 0x1f, 0x49,
+	0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x5c, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e,
+	0x63, 0x65, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02,
+	0x14, 0x49, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x3a, 0x3a, 0x49, 0x6e, 0x66, 0x65,
+	0x72, 0x65, 0x6e, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -43906,7 +46941,7 @@ func file_inference_inference_tx_proto_rawDescGZIP() []byte {
 	return file_inference_inference_tx_proto_rawDescData
 }
 
-var file_inference_inference_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 74)
+var file_inference_inference_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 80)
 var file_inference_inference_tx_proto_goTypes = []interface{}{
 	(*MsgUpdateParams)(nil),                             // 0: inference.inference.MsgUpdateParams
 	(*MsgUpdateParamsResponse)(nil),                     // 1: inference.inference.MsgUpdateParamsResponse
@@ -43926,175 +46961,189 @@ var file_inference_inference_tx_proto_goTypes = []interface{}{
 	(*MsgRevalidateInferenceResponse)(nil),              // 15: inference.inference.MsgRevalidateInferenceResponse
 	(*MsgClaimRewards)(nil),                             // 16: inference.inference.MsgClaimRewards
 	(*MsgClaimRewardsResponse)(nil),                     // 17: inference.inference.MsgClaimRewardsResponse
-	(*MsgSubmitPocBatch)(nil),                           // 18: inference.inference.MsgSubmitPocBatch
-	(*MsgSubmitPocBatchResponse)(nil),                   // 19: inference.inference.MsgSubmitPocBatchResponse
-	(*MsgSubmitPocValidationsV2)(nil),                   // 20: inference.inference.MsgSubmitPocValidationsV2
-	(*MsgSubmitPocValidationsV2Response)(nil),           // 21: inference.inference.MsgSubmitPocValidationsV2Response
-	(*MsgPoCV2StoreCommit)(nil),                         // 22: inference.inference.MsgPoCV2StoreCommit
-	(*MsgPoCV2StoreCommitResponse)(nil),                 // 23: inference.inference.MsgPoCV2StoreCommitResponse
-	(*MsgMLNodeWeightDistribution)(nil),                 // 24: inference.inference.MsgMLNodeWeightDistribution
-	(*MsgMLNodeWeightDistributionResponse)(nil),         // 25: inference.inference.MsgMLNodeWeightDistributionResponse
-	(*MsgSubmitSeed)(nil),                               // 26: inference.inference.MsgSubmitSeed
-	(*MsgSubmitSeedResponse)(nil),                       // 27: inference.inference.MsgSubmitSeedResponse
-	(*MsgSubmitUnitOfComputePriceProposal)(nil),         // 28: inference.inference.MsgSubmitUnitOfComputePriceProposal
-	(*MsgSubmitUnitOfComputePriceProposalResponse)(nil), // 29: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse
-	(*MsgRegisterModel)(nil),                            // 30: inference.inference.MsgRegisterModel
-	(*MsgRegisterModelResponse)(nil),                    // 31: inference.inference.MsgRegisterModelResponse
-	(*MsgDeleteGovernanceModel)(nil),                    // 32: inference.inference.MsgDeleteGovernanceModel
-	(*MsgDeleteGovernanceModelResponse)(nil),            // 33: inference.inference.MsgDeleteGovernanceModelResponse
-	(*MsgSubmitHardwareDiff)(nil),                       // 34: inference.inference.MsgSubmitHardwareDiff
-	(*MsgSubmitHardwareDiffResponse)(nil),               // 35: inference.inference.MsgSubmitHardwareDiffResponse
-	(*MsgCreatePartialUpgrade)(nil),                     // 36: inference.inference.MsgCreatePartialUpgrade
-	(*MsgCreatePartialUpgradeResponse)(nil),             // 37: inference.inference.MsgCreatePartialUpgradeResponse
-	(*MsgBridgeExchange)(nil),                           // 38: inference.inference.MsgBridgeExchange
-	(*MsgBridgeExchangeResponse)(nil),                   // 39: inference.inference.MsgBridgeExchangeResponse
-	(*MsgAddParticipantsToAllowList)(nil),               // 40: inference.inference.MsgAddParticipantsToAllowList
-	(*MsgAddParticipantsToAllowListResponse)(nil),       // 41: inference.inference.MsgAddParticipantsToAllowListResponse
-	(*MsgRemoveParticipantsFromAllowList)(nil),          // 42: inference.inference.MsgRemoveParticipantsFromAllowList
-	(*MsgRemoveParticipantsFromAllowListResponse)(nil),  // 43: inference.inference.MsgRemoveParticipantsFromAllowListResponse
-	(*MsgRegisterBridgeAddresses)(nil),                  // 44: inference.inference.MsgRegisterBridgeAddresses
-	(*MsgRegisterBridgeAddressesResponse)(nil),          // 45: inference.inference.MsgRegisterBridgeAddressesResponse
-	(*MsgRegisterTokenMetadata)(nil),                    // 46: inference.inference.MsgRegisterTokenMetadata
-	(*MsgRegisterTokenMetadataResponse)(nil),            // 47: inference.inference.MsgRegisterTokenMetadataResponse
-	(*MsgApproveBridgeTokenForTrading)(nil),             // 48: inference.inference.MsgApproveBridgeTokenForTrading
-	(*MsgApproveBridgeTokenForTradingResponse)(nil),     // 49: inference.inference.MsgApproveBridgeTokenForTradingResponse
-	(*MsgRegisterLiquidityPool)(nil),                    // 50: inference.inference.MsgRegisterLiquidityPool
-	(*MsgRegisterLiquidityPoolResponse)(nil),            // 51: inference.inference.MsgRegisterLiquidityPoolResponse
-	(*MsgRequestBridgeWithdrawal)(nil),                  // 52: inference.inference.MsgRequestBridgeWithdrawal
-	(*MsgRequestBridgeWithdrawalResponse)(nil),          // 53: inference.inference.MsgRequestBridgeWithdrawalResponse
-	(*MsgRequestBridgeMint)(nil),                        // 54: inference.inference.MsgRequestBridgeMint
-	(*MsgRequestBridgeMintResponse)(nil),                // 55: inference.inference.MsgRequestBridgeMintResponse
-	(*MsgCancelBridgeOperation)(nil),                    // 56: inference.inference.MsgCancelBridgeOperation
-	(*MsgCancelBridgeOperationResponse)(nil),            // 57: inference.inference.MsgCancelBridgeOperationResponse
-	(*MsgGovernanceCancelBridgeOperation)(nil),          // 58: inference.inference.MsgGovernanceCancelBridgeOperation
-	(*MsgGovernanceCancelBridgeOperationResponse)(nil),  // 59: inference.inference.MsgGovernanceCancelBridgeOperationResponse
-	(*MsgRegisterWrappedTokenContract)(nil),             // 60: inference.inference.MsgRegisterWrappedTokenContract
-	(*MsgRegisterWrappedTokenContractResponse)(nil),     // 61: inference.inference.MsgRegisterWrappedTokenContractResponse
-	(*MsgMigrateAllWrappedTokens)(nil),                  // 62: inference.inference.MsgMigrateAllWrappedTokens
-	(*MsgMigrateAllWrappedTokensResponse)(nil),          // 63: inference.inference.MsgMigrateAllWrappedTokensResponse
-	(*MsgApproveIbcTokenForTrading)(nil),                // 64: inference.inference.MsgApproveIbcTokenForTrading
-	(*MsgApproveIbcTokenForTradingResponse)(nil),        // 65: inference.inference.MsgApproveIbcTokenForTradingResponse
-	(*MsgRegisterIbcTokenMetadata)(nil),                 // 66: inference.inference.MsgRegisterIbcTokenMetadata
-	(*MsgRegisterIbcTokenMetadataResponse)(nil),         // 67: inference.inference.MsgRegisterIbcTokenMetadataResponse
-	(*MsgCreateDevshardEscrow)(nil),                     // 68: inference.inference.MsgCreateDevshardEscrow
-	(*MsgCreateDevshardEscrowResponse)(nil),             // 69: inference.inference.MsgCreateDevshardEscrowResponse
-	(*MsgSettleDevshardEscrow)(nil),                     // 70: inference.inference.MsgSettleDevshardEscrow
-	(*MsgSettleDevshardEscrowResponse)(nil),             // 71: inference.inference.MsgSettleDevshardEscrowResponse
-	(*MsgSetDevshardRequestsEnabled)(nil),               // 72: inference.inference.MsgSetDevshardRequestsEnabled
-	(*MsgSetDevshardRequestsEnabledResponse)(nil),       // 73: inference.inference.MsgSetDevshardRequestsEnabledResponse
-	(*Params)(nil),                                      // 74: inference.inference.Params
-	(*Decimal)(nil),                                     // 75: inference.inference.Decimal
-	(*PoCValidationEntryV2)(nil),                        // 76: inference.inference.PoCValidationEntryV2
-	(*PoCV2CommitEntry)(nil),                            // 77: inference.inference.PoCV2CommitEntry
-	(*MLNodeWeight)(nil),                                // 78: inference.inference.MLNodeWeight
-	(*MLNodeDistributionEntry)(nil),                     // 79: inference.inference.MLNodeDistributionEntry
-	(*HardwareNode)(nil),                                // 80: inference.inference.HardwareNode
-	(*DevshardSettlementHostStats)(nil),                 // 81: inference.inference.DevshardSettlementHostStats
-	(*DevshardSlotSignature)(nil),                       // 82: inference.inference.DevshardSlotSignature
-	(*MsgSetPoCDelegation)(nil),                         // 83: inference.inference.MsgSetPoCDelegation
-	(*MsgRefusePoCDelegation)(nil),                      // 84: inference.inference.MsgRefusePoCDelegation
-	(*MsgDeclarePoCIntent)(nil),                         // 85: inference.inference.MsgDeclarePoCIntent
-	(*MsgSetPoCDelegationResponse)(nil),                 // 86: inference.inference.MsgSetPoCDelegationResponse
-	(*MsgRefusePoCDelegationResponse)(nil),              // 87: inference.inference.MsgRefusePoCDelegationResponse
-	(*MsgDeclarePoCIntentResponse)(nil),                 // 88: inference.inference.MsgDeclarePoCIntentResponse
+	(*MsgSetClaimRecipients)(nil),                       // 18: inference.inference.MsgSetClaimRecipients
+	(*MsgSetClaimRecipientsResponse)(nil),               // 19: inference.inference.MsgSetClaimRecipientsResponse
+	(*MsgSubmitPocBatch)(nil),                           // 20: inference.inference.MsgSubmitPocBatch
+	(*MsgSubmitPocBatchResponse)(nil),                   // 21: inference.inference.MsgSubmitPocBatchResponse
+	(*MsgSubmitPocValidationsV2)(nil),                   // 22: inference.inference.MsgSubmitPocValidationsV2
+	(*MsgSubmitPocValidationsV2Response)(nil),           // 23: inference.inference.MsgSubmitPocValidationsV2Response
+	(*MsgPoCV2StoreCommit)(nil),                         // 24: inference.inference.MsgPoCV2StoreCommit
+	(*MsgPoCV2StoreCommitResponse)(nil),                 // 25: inference.inference.MsgPoCV2StoreCommitResponse
+	(*MsgMLNodeWeightDistribution)(nil),                 // 26: inference.inference.MsgMLNodeWeightDistribution
+	(*MsgMLNodeWeightDistributionResponse)(nil),         // 27: inference.inference.MsgMLNodeWeightDistributionResponse
+	(*MsgSubmitSeed)(nil),                               // 28: inference.inference.MsgSubmitSeed
+	(*MsgSubmitSeedResponse)(nil),                       // 29: inference.inference.MsgSubmitSeedResponse
+	(*MsgSubmitUnitOfComputePriceProposal)(nil),         // 30: inference.inference.MsgSubmitUnitOfComputePriceProposal
+	(*MsgSubmitUnitOfComputePriceProposalResponse)(nil), // 31: inference.inference.MsgSubmitUnitOfComputePriceProposalResponse
+	(*MsgRegisterModel)(nil),                            // 32: inference.inference.MsgRegisterModel
+	(*MsgRegisterModelResponse)(nil),                    // 33: inference.inference.MsgRegisterModelResponse
+	(*MsgDeleteGovernanceModel)(nil),                    // 34: inference.inference.MsgDeleteGovernanceModel
+	(*MsgDeleteGovernanceModelResponse)(nil),            // 35: inference.inference.MsgDeleteGovernanceModelResponse
+	(*MsgSubmitHardwareDiff)(nil),                       // 36: inference.inference.MsgSubmitHardwareDiff
+	(*MsgSubmitHardwareDiffResponse)(nil),               // 37: inference.inference.MsgSubmitHardwareDiffResponse
+	(*MsgCreatePartialUpgrade)(nil),                     // 38: inference.inference.MsgCreatePartialUpgrade
+	(*MsgCreatePartialUpgradeResponse)(nil),             // 39: inference.inference.MsgCreatePartialUpgradeResponse
+	(*MsgBridgeExchange)(nil),                           // 40: inference.inference.MsgBridgeExchange
+	(*MsgBridgeExchangeResponse)(nil),                   // 41: inference.inference.MsgBridgeExchangeResponse
+	(*MsgAddParticipantsToAllowList)(nil),               // 42: inference.inference.MsgAddParticipantsToAllowList
+	(*MsgAddParticipantsToAllowListResponse)(nil),       // 43: inference.inference.MsgAddParticipantsToAllowListResponse
+	(*MsgRemoveParticipantsFromAllowList)(nil),          // 44: inference.inference.MsgRemoveParticipantsFromAllowList
+	(*MsgRemoveParticipantsFromAllowListResponse)(nil),  // 45: inference.inference.MsgRemoveParticipantsFromAllowListResponse
+	(*MsgRegisterBridgeAddresses)(nil),                  // 46: inference.inference.MsgRegisterBridgeAddresses
+	(*MsgRegisterBridgeAddressesResponse)(nil),          // 47: inference.inference.MsgRegisterBridgeAddressesResponse
+	(*MsgRegisterTokenMetadata)(nil),                    // 48: inference.inference.MsgRegisterTokenMetadata
+	(*MsgRegisterTokenMetadataResponse)(nil),            // 49: inference.inference.MsgRegisterTokenMetadataResponse
+	(*MsgApproveBridgeTokenForTrading)(nil),             // 50: inference.inference.MsgApproveBridgeTokenForTrading
+	(*MsgApproveBridgeTokenForTradingResponse)(nil),     // 51: inference.inference.MsgApproveBridgeTokenForTradingResponse
+	(*MsgRegisterLiquidityPool)(nil),                    // 52: inference.inference.MsgRegisterLiquidityPool
+	(*MsgRegisterLiquidityPoolResponse)(nil),            // 53: inference.inference.MsgRegisterLiquidityPoolResponse
+	(*MsgRequestBridgeWithdrawal)(nil),                  // 54: inference.inference.MsgRequestBridgeWithdrawal
+	(*MsgRequestBridgeWithdrawalResponse)(nil),          // 55: inference.inference.MsgRequestBridgeWithdrawalResponse
+	(*MsgRequestBridgeMint)(nil),                        // 56: inference.inference.MsgRequestBridgeMint
+	(*MsgRequestBridgeMintResponse)(nil),                // 57: inference.inference.MsgRequestBridgeMintResponse
+	(*MsgCancelBridgeOperation)(nil),                    // 58: inference.inference.MsgCancelBridgeOperation
+	(*MsgCancelBridgeOperationResponse)(nil),            // 59: inference.inference.MsgCancelBridgeOperationResponse
+	(*MsgGovernanceCancelBridgeOperation)(nil),          // 60: inference.inference.MsgGovernanceCancelBridgeOperation
+	(*MsgGovernanceCancelBridgeOperationResponse)(nil),  // 61: inference.inference.MsgGovernanceCancelBridgeOperationResponse
+	(*MsgRegisterWrappedTokenContract)(nil),             // 62: inference.inference.MsgRegisterWrappedTokenContract
+	(*MsgRegisterWrappedTokenContractResponse)(nil),     // 63: inference.inference.MsgRegisterWrappedTokenContractResponse
+	(*MsgMigrateAllWrappedTokens)(nil),                  // 64: inference.inference.MsgMigrateAllWrappedTokens
+	(*MsgMigrateAllWrappedTokensResponse)(nil),          // 65: inference.inference.MsgMigrateAllWrappedTokensResponse
+	(*MsgApproveIbcTokenForTrading)(nil),                // 66: inference.inference.MsgApproveIbcTokenForTrading
+	(*MsgApproveIbcTokenForTradingResponse)(nil),        // 67: inference.inference.MsgApproveIbcTokenForTradingResponse
+	(*MsgRegisterIbcTokenMetadata)(nil),                 // 68: inference.inference.MsgRegisterIbcTokenMetadata
+	(*MsgRegisterIbcTokenMetadataResponse)(nil),         // 69: inference.inference.MsgRegisterIbcTokenMetadataResponse
+	(*MsgCreateDevshardEscrow)(nil),                     // 70: inference.inference.MsgCreateDevshardEscrow
+	(*MsgCreateDevshardEscrowResponse)(nil),             // 71: inference.inference.MsgCreateDevshardEscrowResponse
+	(*MsgSettleDevshardEscrow)(nil),                     // 72: inference.inference.MsgSettleDevshardEscrow
+	(*MsgSettleDevshardEscrowResponse)(nil),             // 73: inference.inference.MsgSettleDevshardEscrowResponse
+	(*MsgSetDevshardRequestsEnabled)(nil),               // 74: inference.inference.MsgSetDevshardRequestsEnabled
+	(*MsgSetDevshardRequestsEnabledResponse)(nil),       // 75: inference.inference.MsgSetDevshardRequestsEnabledResponse
+	(*MsgScheduleMaintenance)(nil),                      // 76: inference.inference.MsgScheduleMaintenance
+	(*MsgScheduleMaintenanceResponse)(nil),              // 77: inference.inference.MsgScheduleMaintenanceResponse
+	(*MsgCancelMaintenance)(nil),                        // 78: inference.inference.MsgCancelMaintenance
+	(*MsgCancelMaintenanceResponse)(nil),                // 79: inference.inference.MsgCancelMaintenanceResponse
+	(*Params)(nil),                                      // 80: inference.inference.Params
+	(*Decimal)(nil),                                     // 81: inference.inference.Decimal
+	(*ClaimRecipientEntry)(nil),                         // 82: inference.inference.ClaimRecipientEntry
+	(*PoCValidationEntryV2)(nil),                        // 83: inference.inference.PoCValidationEntryV2
+	(*PoCV2CommitEntry)(nil),                            // 84: inference.inference.PoCV2CommitEntry
+	(*MLNodeWeight)(nil),                                // 85: inference.inference.MLNodeWeight
+	(*MLNodeDistributionEntry)(nil),                     // 86: inference.inference.MLNodeDistributionEntry
+	(*HardwareNode)(nil),                                // 87: inference.inference.HardwareNode
+	(*DevshardSettlementHostStats)(nil),                 // 88: inference.inference.DevshardSettlementHostStats
+	(*DevshardSlotSignature)(nil),                       // 89: inference.inference.DevshardSlotSignature
+	(*MsgSetPoCDelegation)(nil),                         // 90: inference.inference.MsgSetPoCDelegation
+	(*MsgRefusePoCDelegation)(nil),                      // 91: inference.inference.MsgRefusePoCDelegation
+	(*MsgDeclarePoCIntent)(nil),                         // 92: inference.inference.MsgDeclarePoCIntent
+	(*MsgSetPoCDelegationResponse)(nil),                 // 93: inference.inference.MsgSetPoCDelegationResponse
+	(*MsgRefusePoCDelegationResponse)(nil),              // 94: inference.inference.MsgRefusePoCDelegationResponse
+	(*MsgDeclarePoCIntentResponse)(nil),                 // 95: inference.inference.MsgDeclarePoCIntentResponse
 }
 var file_inference_inference_tx_proto_depIdxs = []int32{
-	74, // 0: inference.inference.MsgUpdateParams.params:type_name -> inference.inference.Params
-	75, // 1: inference.inference.MsgValidation.value_decimal:type_name -> inference.inference.Decimal
-	76, // 2: inference.inference.MsgSubmitPocValidationsV2.validations:type_name -> inference.inference.PoCValidationEntryV2
-	77, // 3: inference.inference.MsgPoCV2StoreCommit.entries:type_name -> inference.inference.PoCV2CommitEntry
-	78, // 4: inference.inference.MsgMLNodeWeightDistribution.weights:type_name -> inference.inference.MLNodeWeight
-	79, // 5: inference.inference.MsgMLNodeWeightDistribution.entries:type_name -> inference.inference.MLNodeDistributionEntry
-	75, // 6: inference.inference.MsgRegisterModel.validation_threshold:type_name -> inference.inference.Decimal
-	80, // 7: inference.inference.MsgSubmitHardwareDiff.newOrModified:type_name -> inference.inference.HardwareNode
-	80, // 8: inference.inference.MsgSubmitHardwareDiff.removed:type_name -> inference.inference.HardwareNode
-	81, // 9: inference.inference.MsgSettleDevshardEscrow.host_stats:type_name -> inference.inference.DevshardSettlementHostStats
-	82, // 10: inference.inference.MsgSettleDevshardEscrow.signatures:type_name -> inference.inference.DevshardSlotSignature
-	0,  // 11: inference.inference.Msg.UpdateParams:input_type -> inference.inference.MsgUpdateParams
-	2,  // 12: inference.inference.Msg.StartInference:input_type -> inference.inference.MsgStartInference
-	4,  // 13: inference.inference.Msg.FinishInference:input_type -> inference.inference.MsgFinishInference
-	6,  // 14: inference.inference.Msg.SubmitNewParticipant:input_type -> inference.inference.MsgSubmitNewParticipant
-	8,  // 15: inference.inference.Msg.Validation:input_type -> inference.inference.MsgValidation
-	10, // 16: inference.inference.Msg.SubmitNewUnfundedParticipant:input_type -> inference.inference.MsgSubmitNewUnfundedParticipant
-	12, // 17: inference.inference.Msg.InvalidateInference:input_type -> inference.inference.MsgInvalidateInference
-	14, // 18: inference.inference.Msg.RevalidateInference:input_type -> inference.inference.MsgRevalidateInference
-	16, // 19: inference.inference.Msg.ClaimRewards:input_type -> inference.inference.MsgClaimRewards
-	18, // 20: inference.inference.Msg.SubmitPocBatch:input_type -> inference.inference.MsgSubmitPocBatch
-	20, // 21: inference.inference.Msg.SubmitPocValidationsV2:input_type -> inference.inference.MsgSubmitPocValidationsV2
-	22, // 22: inference.inference.Msg.PoCV2StoreCommit:input_type -> inference.inference.MsgPoCV2StoreCommit
-	24, // 23: inference.inference.Msg.MLNodeWeightDistribution:input_type -> inference.inference.MsgMLNodeWeightDistribution
-	26, // 24: inference.inference.Msg.SubmitSeed:input_type -> inference.inference.MsgSubmitSeed
-	28, // 25: inference.inference.Msg.SubmitUnitOfComputePriceProposal:input_type -> inference.inference.MsgSubmitUnitOfComputePriceProposal
-	30, // 26: inference.inference.Msg.RegisterModel:input_type -> inference.inference.MsgRegisterModel
-	32, // 27: inference.inference.Msg.DeleteGovernanceModel:input_type -> inference.inference.MsgDeleteGovernanceModel
-	34, // 28: inference.inference.Msg.SubmitHardwareDiff:input_type -> inference.inference.MsgSubmitHardwareDiff
-	36, // 29: inference.inference.Msg.CreatePartialUpgrade:input_type -> inference.inference.MsgCreatePartialUpgrade
-	38, // 30: inference.inference.Msg.BridgeExchange:input_type -> inference.inference.MsgBridgeExchange
-	44, // 31: inference.inference.Msg.RegisterBridgeAddresses:input_type -> inference.inference.MsgRegisterBridgeAddresses
-	50, // 32: inference.inference.Msg.RegisterLiquidityPool:input_type -> inference.inference.MsgRegisterLiquidityPool
-	46, // 33: inference.inference.Msg.RegisterTokenMetadata:input_type -> inference.inference.MsgRegisterTokenMetadata
-	48, // 34: inference.inference.Msg.ApproveBridgeTokenForTrading:input_type -> inference.inference.MsgApproveBridgeTokenForTrading
-	52, // 35: inference.inference.Msg.RequestBridgeWithdrawal:input_type -> inference.inference.MsgRequestBridgeWithdrawal
-	54, // 36: inference.inference.Msg.RequestBridgeMint:input_type -> inference.inference.MsgRequestBridgeMint
-	56, // 37: inference.inference.Msg.CancelBridgeOperation:input_type -> inference.inference.MsgCancelBridgeOperation
-	58, // 38: inference.inference.Msg.GovernanceCancelBridgeOperation:input_type -> inference.inference.MsgGovernanceCancelBridgeOperation
-	60, // 39: inference.inference.Msg.RegisterWrappedTokenContract:input_type -> inference.inference.MsgRegisterWrappedTokenContract
-	62, // 40: inference.inference.Msg.MigrateAllWrappedTokens:input_type -> inference.inference.MsgMigrateAllWrappedTokens
-	40, // 41: inference.inference.Msg.AddParticipantsToAllowList:input_type -> inference.inference.MsgAddParticipantsToAllowList
-	42, // 42: inference.inference.Msg.RemoveParticipantsFromAllowList:input_type -> inference.inference.MsgRemoveParticipantsFromAllowList
-	64, // 43: inference.inference.Msg.ApproveIbcTokenForTrading:input_type -> inference.inference.MsgApproveIbcTokenForTrading
-	66, // 44: inference.inference.Msg.RegisterIbcTokenMetadata:input_type -> inference.inference.MsgRegisterIbcTokenMetadata
-	68, // 45: inference.inference.Msg.CreateDevshardEscrow:input_type -> inference.inference.MsgCreateDevshardEscrow
-	70, // 46: inference.inference.Msg.SettleDevshardEscrow:input_type -> inference.inference.MsgSettleDevshardEscrow
-	72, // 47: inference.inference.Msg.SetDevshardRequestsEnabled:input_type -> inference.inference.MsgSetDevshardRequestsEnabled
-	83, // 48: inference.inference.Msg.SetPoCDelegation:input_type -> inference.inference.MsgSetPoCDelegation
-	84, // 49: inference.inference.Msg.RefusePoCDelegation:input_type -> inference.inference.MsgRefusePoCDelegation
-	85, // 50: inference.inference.Msg.DeclarePoCIntent:input_type -> inference.inference.MsgDeclarePoCIntent
-	1,  // 51: inference.inference.Msg.UpdateParams:output_type -> inference.inference.MsgUpdateParamsResponse
-	3,  // 52: inference.inference.Msg.StartInference:output_type -> inference.inference.MsgStartInferenceResponse
-	5,  // 53: inference.inference.Msg.FinishInference:output_type -> inference.inference.MsgFinishInferenceResponse
-	7,  // 54: inference.inference.Msg.SubmitNewParticipant:output_type -> inference.inference.MsgSubmitNewParticipantResponse
-	9,  // 55: inference.inference.Msg.Validation:output_type -> inference.inference.MsgValidationResponse
-	11, // 56: inference.inference.Msg.SubmitNewUnfundedParticipant:output_type -> inference.inference.MsgSubmitNewUnfundedParticipantResponse
-	13, // 57: inference.inference.Msg.InvalidateInference:output_type -> inference.inference.MsgInvalidateInferenceResponse
-	15, // 58: inference.inference.Msg.RevalidateInference:output_type -> inference.inference.MsgRevalidateInferenceResponse
-	17, // 59: inference.inference.Msg.ClaimRewards:output_type -> inference.inference.MsgClaimRewardsResponse
-	19, // 60: inference.inference.Msg.SubmitPocBatch:output_type -> inference.inference.MsgSubmitPocBatchResponse
-	21, // 61: inference.inference.Msg.SubmitPocValidationsV2:output_type -> inference.inference.MsgSubmitPocValidationsV2Response
-	23, // 62: inference.inference.Msg.PoCV2StoreCommit:output_type -> inference.inference.MsgPoCV2StoreCommitResponse
-	25, // 63: inference.inference.Msg.MLNodeWeightDistribution:output_type -> inference.inference.MsgMLNodeWeightDistributionResponse
-	27, // 64: inference.inference.Msg.SubmitSeed:output_type -> inference.inference.MsgSubmitSeedResponse
-	29, // 65: inference.inference.Msg.SubmitUnitOfComputePriceProposal:output_type -> inference.inference.MsgSubmitUnitOfComputePriceProposalResponse
-	31, // 66: inference.inference.Msg.RegisterModel:output_type -> inference.inference.MsgRegisterModelResponse
-	33, // 67: inference.inference.Msg.DeleteGovernanceModel:output_type -> inference.inference.MsgDeleteGovernanceModelResponse
-	35, // 68: inference.inference.Msg.SubmitHardwareDiff:output_type -> inference.inference.MsgSubmitHardwareDiffResponse
-	37, // 69: inference.inference.Msg.CreatePartialUpgrade:output_type -> inference.inference.MsgCreatePartialUpgradeResponse
-	39, // 70: inference.inference.Msg.BridgeExchange:output_type -> inference.inference.MsgBridgeExchangeResponse
-	45, // 71: inference.inference.Msg.RegisterBridgeAddresses:output_type -> inference.inference.MsgRegisterBridgeAddressesResponse
-	51, // 72: inference.inference.Msg.RegisterLiquidityPool:output_type -> inference.inference.MsgRegisterLiquidityPoolResponse
-	47, // 73: inference.inference.Msg.RegisterTokenMetadata:output_type -> inference.inference.MsgRegisterTokenMetadataResponse
-	49, // 74: inference.inference.Msg.ApproveBridgeTokenForTrading:output_type -> inference.inference.MsgApproveBridgeTokenForTradingResponse
-	53, // 75: inference.inference.Msg.RequestBridgeWithdrawal:output_type -> inference.inference.MsgRequestBridgeWithdrawalResponse
-	55, // 76: inference.inference.Msg.RequestBridgeMint:output_type -> inference.inference.MsgRequestBridgeMintResponse
-	57, // 77: inference.inference.Msg.CancelBridgeOperation:output_type -> inference.inference.MsgCancelBridgeOperationResponse
-	59, // 78: inference.inference.Msg.GovernanceCancelBridgeOperation:output_type -> inference.inference.MsgGovernanceCancelBridgeOperationResponse
-	61, // 79: inference.inference.Msg.RegisterWrappedTokenContract:output_type -> inference.inference.MsgRegisterWrappedTokenContractResponse
-	63, // 80: inference.inference.Msg.MigrateAllWrappedTokens:output_type -> inference.inference.MsgMigrateAllWrappedTokensResponse
-	41, // 81: inference.inference.Msg.AddParticipantsToAllowList:output_type -> inference.inference.MsgAddParticipantsToAllowListResponse
-	43, // 82: inference.inference.Msg.RemoveParticipantsFromAllowList:output_type -> inference.inference.MsgRemoveParticipantsFromAllowListResponse
-	65, // 83: inference.inference.Msg.ApproveIbcTokenForTrading:output_type -> inference.inference.MsgApproveIbcTokenForTradingResponse
-	67, // 84: inference.inference.Msg.RegisterIbcTokenMetadata:output_type -> inference.inference.MsgRegisterIbcTokenMetadataResponse
-	69, // 85: inference.inference.Msg.CreateDevshardEscrow:output_type -> inference.inference.MsgCreateDevshardEscrowResponse
-	71, // 86: inference.inference.Msg.SettleDevshardEscrow:output_type -> inference.inference.MsgSettleDevshardEscrowResponse
-	73, // 87: inference.inference.Msg.SetDevshardRequestsEnabled:output_type -> inference.inference.MsgSetDevshardRequestsEnabledResponse
-	86, // 88: inference.inference.Msg.SetPoCDelegation:output_type -> inference.inference.MsgSetPoCDelegationResponse
-	87, // 89: inference.inference.Msg.RefusePoCDelegation:output_type -> inference.inference.MsgRefusePoCDelegationResponse
-	88, // 90: inference.inference.Msg.DeclarePoCIntent:output_type -> inference.inference.MsgDeclarePoCIntentResponse
-	51, // [51:91] is the sub-list for method output_type
-	11, // [11:51] is the sub-list for method input_type
-	11, // [11:11] is the sub-list for extension type_name
-	11, // [11:11] is the sub-list for extension extendee
-	0,  // [0:11] is the sub-list for field type_name
+	80, // 0: inference.inference.MsgUpdateParams.params:type_name -> inference.inference.Params
+	81, // 1: inference.inference.MsgValidation.value_decimal:type_name -> inference.inference.Decimal
+	82, // 2: inference.inference.MsgSetClaimRecipients.entries:type_name -> inference.inference.ClaimRecipientEntry
+	83, // 3: inference.inference.MsgSubmitPocValidationsV2.validations:type_name -> inference.inference.PoCValidationEntryV2
+	84, // 4: inference.inference.MsgPoCV2StoreCommit.entries:type_name -> inference.inference.PoCV2CommitEntry
+	85, // 5: inference.inference.MsgMLNodeWeightDistribution.weights:type_name -> inference.inference.MLNodeWeight
+	86, // 6: inference.inference.MsgMLNodeWeightDistribution.entries:type_name -> inference.inference.MLNodeDistributionEntry
+	81, // 7: inference.inference.MsgRegisterModel.validation_threshold:type_name -> inference.inference.Decimal
+	87, // 8: inference.inference.MsgSubmitHardwareDiff.newOrModified:type_name -> inference.inference.HardwareNode
+	87, // 9: inference.inference.MsgSubmitHardwareDiff.removed:type_name -> inference.inference.HardwareNode
+	88, // 10: inference.inference.MsgSettleDevshardEscrow.host_stats:type_name -> inference.inference.DevshardSettlementHostStats
+	89, // 11: inference.inference.MsgSettleDevshardEscrow.signatures:type_name -> inference.inference.DevshardSlotSignature
+	0,  // 12: inference.inference.Msg.UpdateParams:input_type -> inference.inference.MsgUpdateParams
+	2,  // 13: inference.inference.Msg.StartInference:input_type -> inference.inference.MsgStartInference
+	4,  // 14: inference.inference.Msg.FinishInference:input_type -> inference.inference.MsgFinishInference
+	6,  // 15: inference.inference.Msg.SubmitNewParticipant:input_type -> inference.inference.MsgSubmitNewParticipant
+	8,  // 16: inference.inference.Msg.Validation:input_type -> inference.inference.MsgValidation
+	10, // 17: inference.inference.Msg.SubmitNewUnfundedParticipant:input_type -> inference.inference.MsgSubmitNewUnfundedParticipant
+	12, // 18: inference.inference.Msg.InvalidateInference:input_type -> inference.inference.MsgInvalidateInference
+	14, // 19: inference.inference.Msg.RevalidateInference:input_type -> inference.inference.MsgRevalidateInference
+	16, // 20: inference.inference.Msg.ClaimRewards:input_type -> inference.inference.MsgClaimRewards
+	18, // 21: inference.inference.Msg.SetClaimRecipients:input_type -> inference.inference.MsgSetClaimRecipients
+	20, // 22: inference.inference.Msg.SubmitPocBatch:input_type -> inference.inference.MsgSubmitPocBatch
+	22, // 23: inference.inference.Msg.SubmitPocValidationsV2:input_type -> inference.inference.MsgSubmitPocValidationsV2
+	24, // 24: inference.inference.Msg.PoCV2StoreCommit:input_type -> inference.inference.MsgPoCV2StoreCommit
+	26, // 25: inference.inference.Msg.MLNodeWeightDistribution:input_type -> inference.inference.MsgMLNodeWeightDistribution
+	28, // 26: inference.inference.Msg.SubmitSeed:input_type -> inference.inference.MsgSubmitSeed
+	30, // 27: inference.inference.Msg.SubmitUnitOfComputePriceProposal:input_type -> inference.inference.MsgSubmitUnitOfComputePriceProposal
+	32, // 28: inference.inference.Msg.RegisterModel:input_type -> inference.inference.MsgRegisterModel
+	34, // 29: inference.inference.Msg.DeleteGovernanceModel:input_type -> inference.inference.MsgDeleteGovernanceModel
+	36, // 30: inference.inference.Msg.SubmitHardwareDiff:input_type -> inference.inference.MsgSubmitHardwareDiff
+	38, // 31: inference.inference.Msg.CreatePartialUpgrade:input_type -> inference.inference.MsgCreatePartialUpgrade
+	40, // 32: inference.inference.Msg.BridgeExchange:input_type -> inference.inference.MsgBridgeExchange
+	46, // 33: inference.inference.Msg.RegisterBridgeAddresses:input_type -> inference.inference.MsgRegisterBridgeAddresses
+	52, // 34: inference.inference.Msg.RegisterLiquidityPool:input_type -> inference.inference.MsgRegisterLiquidityPool
+	48, // 35: inference.inference.Msg.RegisterTokenMetadata:input_type -> inference.inference.MsgRegisterTokenMetadata
+	50, // 36: inference.inference.Msg.ApproveBridgeTokenForTrading:input_type -> inference.inference.MsgApproveBridgeTokenForTrading
+	54, // 37: inference.inference.Msg.RequestBridgeWithdrawal:input_type -> inference.inference.MsgRequestBridgeWithdrawal
+	56, // 38: inference.inference.Msg.RequestBridgeMint:input_type -> inference.inference.MsgRequestBridgeMint
+	58, // 39: inference.inference.Msg.CancelBridgeOperation:input_type -> inference.inference.MsgCancelBridgeOperation
+	60, // 40: inference.inference.Msg.GovernanceCancelBridgeOperation:input_type -> inference.inference.MsgGovernanceCancelBridgeOperation
+	62, // 41: inference.inference.Msg.RegisterWrappedTokenContract:input_type -> inference.inference.MsgRegisterWrappedTokenContract
+	64, // 42: inference.inference.Msg.MigrateAllWrappedTokens:input_type -> inference.inference.MsgMigrateAllWrappedTokens
+	42, // 43: inference.inference.Msg.AddParticipantsToAllowList:input_type -> inference.inference.MsgAddParticipantsToAllowList
+	44, // 44: inference.inference.Msg.RemoveParticipantsFromAllowList:input_type -> inference.inference.MsgRemoveParticipantsFromAllowList
+	66, // 45: inference.inference.Msg.ApproveIbcTokenForTrading:input_type -> inference.inference.MsgApproveIbcTokenForTrading
+	68, // 46: inference.inference.Msg.RegisterIbcTokenMetadata:input_type -> inference.inference.MsgRegisterIbcTokenMetadata
+	70, // 47: inference.inference.Msg.CreateDevshardEscrow:input_type -> inference.inference.MsgCreateDevshardEscrow
+	72, // 48: inference.inference.Msg.SettleDevshardEscrow:input_type -> inference.inference.MsgSettleDevshardEscrow
+	74, // 49: inference.inference.Msg.SetDevshardRequestsEnabled:input_type -> inference.inference.MsgSetDevshardRequestsEnabled
+	76, // 50: inference.inference.Msg.ScheduleMaintenance:input_type -> inference.inference.MsgScheduleMaintenance
+	78, // 51: inference.inference.Msg.CancelMaintenance:input_type -> inference.inference.MsgCancelMaintenance
+	90, // 52: inference.inference.Msg.SetPoCDelegation:input_type -> inference.inference.MsgSetPoCDelegation
+	91, // 53: inference.inference.Msg.RefusePoCDelegation:input_type -> inference.inference.MsgRefusePoCDelegation
+	92, // 54: inference.inference.Msg.DeclarePoCIntent:input_type -> inference.inference.MsgDeclarePoCIntent
+	1,  // 55: inference.inference.Msg.UpdateParams:output_type -> inference.inference.MsgUpdateParamsResponse
+	3,  // 56: inference.inference.Msg.StartInference:output_type -> inference.inference.MsgStartInferenceResponse
+	5,  // 57: inference.inference.Msg.FinishInference:output_type -> inference.inference.MsgFinishInferenceResponse
+	7,  // 58: inference.inference.Msg.SubmitNewParticipant:output_type -> inference.inference.MsgSubmitNewParticipantResponse
+	9,  // 59: inference.inference.Msg.Validation:output_type -> inference.inference.MsgValidationResponse
+	11, // 60: inference.inference.Msg.SubmitNewUnfundedParticipant:output_type -> inference.inference.MsgSubmitNewUnfundedParticipantResponse
+	13, // 61: inference.inference.Msg.InvalidateInference:output_type -> inference.inference.MsgInvalidateInferenceResponse
+	15, // 62: inference.inference.Msg.RevalidateInference:output_type -> inference.inference.MsgRevalidateInferenceResponse
+	17, // 63: inference.inference.Msg.ClaimRewards:output_type -> inference.inference.MsgClaimRewardsResponse
+	19, // 64: inference.inference.Msg.SetClaimRecipients:output_type -> inference.inference.MsgSetClaimRecipientsResponse
+	21, // 65: inference.inference.Msg.SubmitPocBatch:output_type -> inference.inference.MsgSubmitPocBatchResponse
+	23, // 66: inference.inference.Msg.SubmitPocValidationsV2:output_type -> inference.inference.MsgSubmitPocValidationsV2Response
+	25, // 67: inference.inference.Msg.PoCV2StoreCommit:output_type -> inference.inference.MsgPoCV2StoreCommitResponse
+	27, // 68: inference.inference.Msg.MLNodeWeightDistribution:output_type -> inference.inference.MsgMLNodeWeightDistributionResponse
+	29, // 69: inference.inference.Msg.SubmitSeed:output_type -> inference.inference.MsgSubmitSeedResponse
+	31, // 70: inference.inference.Msg.SubmitUnitOfComputePriceProposal:output_type -> inference.inference.MsgSubmitUnitOfComputePriceProposalResponse
+	33, // 71: inference.inference.Msg.RegisterModel:output_type -> inference.inference.MsgRegisterModelResponse
+	35, // 72: inference.inference.Msg.DeleteGovernanceModel:output_type -> inference.inference.MsgDeleteGovernanceModelResponse
+	37, // 73: inference.inference.Msg.SubmitHardwareDiff:output_type -> inference.inference.MsgSubmitHardwareDiffResponse
+	39, // 74: inference.inference.Msg.CreatePartialUpgrade:output_type -> inference.inference.MsgCreatePartialUpgradeResponse
+	41, // 75: inference.inference.Msg.BridgeExchange:output_type -> inference.inference.MsgBridgeExchangeResponse
+	47, // 76: inference.inference.Msg.RegisterBridgeAddresses:output_type -> inference.inference.MsgRegisterBridgeAddressesResponse
+	53, // 77: inference.inference.Msg.RegisterLiquidityPool:output_type -> inference.inference.MsgRegisterLiquidityPoolResponse
+	49, // 78: inference.inference.Msg.RegisterTokenMetadata:output_type -> inference.inference.MsgRegisterTokenMetadataResponse
+	51, // 79: inference.inference.Msg.ApproveBridgeTokenForTrading:output_type -> inference.inference.MsgApproveBridgeTokenForTradingResponse
+	55, // 80: inference.inference.Msg.RequestBridgeWithdrawal:output_type -> inference.inference.MsgRequestBridgeWithdrawalResponse
+	57, // 81: inference.inference.Msg.RequestBridgeMint:output_type -> inference.inference.MsgRequestBridgeMintResponse
+	59, // 82: inference.inference.Msg.CancelBridgeOperation:output_type -> inference.inference.MsgCancelBridgeOperationResponse
+	61, // 83: inference.inference.Msg.GovernanceCancelBridgeOperation:output_type -> inference.inference.MsgGovernanceCancelBridgeOperationResponse
+	63, // 84: inference.inference.Msg.RegisterWrappedTokenContract:output_type -> inference.inference.MsgRegisterWrappedTokenContractResponse
+	65, // 85: inference.inference.Msg.MigrateAllWrappedTokens:output_type -> inference.inference.MsgMigrateAllWrappedTokensResponse
+	43, // 86: inference.inference.Msg.AddParticipantsToAllowList:output_type -> inference.inference.MsgAddParticipantsToAllowListResponse
+	45, // 87: inference.inference.Msg.RemoveParticipantsFromAllowList:output_type -> inference.inference.MsgRemoveParticipantsFromAllowListResponse
+	67, // 88: inference.inference.Msg.ApproveIbcTokenForTrading:output_type -> inference.inference.MsgApproveIbcTokenForTradingResponse
+	69, // 89: inference.inference.Msg.RegisterIbcTokenMetadata:output_type -> inference.inference.MsgRegisterIbcTokenMetadataResponse
+	71, // 90: inference.inference.Msg.CreateDevshardEscrow:output_type -> inference.inference.MsgCreateDevshardEscrowResponse
+	73, // 91: inference.inference.Msg.SettleDevshardEscrow:output_type -> inference.inference.MsgSettleDevshardEscrowResponse
+	75, // 92: inference.inference.Msg.SetDevshardRequestsEnabled:output_type -> inference.inference.MsgSetDevshardRequestsEnabledResponse
+	77, // 93: inference.inference.Msg.ScheduleMaintenance:output_type -> inference.inference.MsgScheduleMaintenanceResponse
+	79, // 94: inference.inference.Msg.CancelMaintenance:output_type -> inference.inference.MsgCancelMaintenanceResponse
+	93, // 95: inference.inference.Msg.SetPoCDelegation:output_type -> inference.inference.MsgSetPoCDelegationResponse
+	94, // 96: inference.inference.Msg.RefusePoCDelegation:output_type -> inference.inference.MsgRefusePoCDelegationResponse
+	95, // 97: inference.inference.Msg.DeclarePoCIntent:output_type -> inference.inference.MsgDeclarePoCIntentResponse
+	55, // [55:98] is the sub-list for method output_type
+	12, // [12:55] is the sub-list for method input_type
+	12, // [12:12] is the sub-list for extension type_name
+	12, // [12:12] is the sub-list for extension extendee
+	0,  // [0:12] is the sub-list for field type_name
 }
 
 func init() { file_inference_inference_tx_proto_init() }
@@ -44107,7 +47156,9 @@ func file_inference_inference_tx_proto_init() {
 	file_inference_inference_bridge_proto_init()
 	file_inference_inference_poc_v2_proto_init()
 	file_inference_inference_devshard_escrow_proto_init()
+	file_inference_inference_maintenance_proto_init()
 	file_inference_inference_poc_delegation_proto_init()
+	file_inference_inference_claim_recipient_proto_init()
 	if !protoimpl.UnsafeEnabled {
 		file_inference_inference_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MsgUpdateParams); i {
@@ -44326,7 +47377,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitPocBatch); i {
+			switch v := v.(*MsgSetClaimRecipients); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44338,7 +47389,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitPocBatchResponse); i {
+			switch v := v.(*MsgSetClaimRecipientsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44350,7 +47401,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitPocValidationsV2); i {
+			switch v := v.(*MsgSubmitPocBatch); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44362,7 +47413,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitPocValidationsV2Response); i {
+			switch v := v.(*MsgSubmitPocBatchResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44374,7 +47425,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgPoCV2StoreCommit); i {
+			switch v := v.(*MsgSubmitPocValidationsV2); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44386,7 +47437,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgPoCV2StoreCommitResponse); i {
+			switch v := v.(*MsgSubmitPocValidationsV2Response); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44398,7 +47449,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgMLNodeWeightDistribution); i {
+			switch v := v.(*MsgPoCV2StoreCommit); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44410,7 +47461,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgMLNodeWeightDistributionResponse); i {
+			switch v := v.(*MsgPoCV2StoreCommitResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44422,7 +47473,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitSeed); i {
+			switch v := v.(*MsgMLNodeWeightDistribution); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44434,7 +47485,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitSeedResponse); i {
+			switch v := v.(*MsgMLNodeWeightDistributionResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44446,7 +47497,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitUnitOfComputePriceProposal); i {
+			switch v := v.(*MsgSubmitSeed); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44458,7 +47509,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitUnitOfComputePriceProposalResponse); i {
+			switch v := v.(*MsgSubmitSeedResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44470,7 +47521,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterModel); i {
+			switch v := v.(*MsgSubmitUnitOfComputePriceProposal); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44482,7 +47533,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterModelResponse); i {
+			switch v := v.(*MsgSubmitUnitOfComputePriceProposalResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44494,7 +47545,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgDeleteGovernanceModel); i {
+			switch v := v.(*MsgRegisterModel); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44506,7 +47557,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgDeleteGovernanceModelResponse); i {
+			switch v := v.(*MsgRegisterModelResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44518,7 +47569,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitHardwareDiff); i {
+			switch v := v.(*MsgDeleteGovernanceModel); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44530,7 +47581,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSubmitHardwareDiffResponse); i {
+			switch v := v.(*MsgDeleteGovernanceModelResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44542,7 +47593,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgCreatePartialUpgrade); i {
+			switch v := v.(*MsgSubmitHardwareDiff); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44554,7 +47605,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgCreatePartialUpgradeResponse); i {
+			switch v := v.(*MsgSubmitHardwareDiffResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44566,7 +47617,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgBridgeExchange); i {
+			switch v := v.(*MsgCreatePartialUpgrade); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44578,7 +47629,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgBridgeExchangeResponse); i {
+			switch v := v.(*MsgCreatePartialUpgradeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44590,7 +47641,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgAddParticipantsToAllowList); i {
+			switch v := v.(*MsgBridgeExchange); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44602,7 +47653,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgAddParticipantsToAllowListResponse); i {
+			switch v := v.(*MsgBridgeExchangeResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44614,7 +47665,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRemoveParticipantsFromAllowList); i {
+			switch v := v.(*MsgAddParticipantsToAllowList); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44626,7 +47677,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRemoveParticipantsFromAllowListResponse); i {
+			switch v := v.(*MsgAddParticipantsToAllowListResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44638,7 +47689,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterBridgeAddresses); i {
+			switch v := v.(*MsgRemoveParticipantsFromAllowList); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44650,7 +47701,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterBridgeAddressesResponse); i {
+			switch v := v.(*MsgRemoveParticipantsFromAllowListResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44662,7 +47713,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterTokenMetadata); i {
+			switch v := v.(*MsgRegisterBridgeAddresses); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44674,7 +47725,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterTokenMetadataResponse); i {
+			switch v := v.(*MsgRegisterBridgeAddressesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44686,7 +47737,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgApproveBridgeTokenForTrading); i {
+			switch v := v.(*MsgRegisterTokenMetadata); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44698,7 +47749,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgApproveBridgeTokenForTradingResponse); i {
+			switch v := v.(*MsgRegisterTokenMetadataResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44710,7 +47761,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterLiquidityPool); i {
+			switch v := v.(*MsgApproveBridgeTokenForTrading); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44722,7 +47773,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterLiquidityPoolResponse); i {
+			switch v := v.(*MsgApproveBridgeTokenForTradingResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44734,7 +47785,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRequestBridgeWithdrawal); i {
+			switch v := v.(*MsgRegisterLiquidityPool); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44746,7 +47797,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRequestBridgeWithdrawalResponse); i {
+			switch v := v.(*MsgRegisterLiquidityPoolResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44758,7 +47809,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRequestBridgeMint); i {
+			switch v := v.(*MsgRequestBridgeWithdrawal); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44770,7 +47821,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRequestBridgeMintResponse); i {
+			switch v := v.(*MsgRequestBridgeWithdrawalResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44782,7 +47833,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgCancelBridgeOperation); i {
+			switch v := v.(*MsgRequestBridgeMint); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44794,7 +47845,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgCancelBridgeOperationResponse); i {
+			switch v := v.(*MsgRequestBridgeMintResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44806,7 +47857,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgGovernanceCancelBridgeOperation); i {
+			switch v := v.(*MsgCancelBridgeOperation); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44818,7 +47869,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgGovernanceCancelBridgeOperationResponse); i {
+			switch v := v.(*MsgCancelBridgeOperationResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44830,7 +47881,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterWrappedTokenContract); i {
+			switch v := v.(*MsgGovernanceCancelBridgeOperation); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44842,7 +47893,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterWrappedTokenContractResponse); i {
+			switch v := v.(*MsgGovernanceCancelBridgeOperationResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44854,7 +47905,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgMigrateAllWrappedTokens); i {
+			switch v := v.(*MsgRegisterWrappedTokenContract); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44866,7 +47917,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgMigrateAllWrappedTokensResponse); i {
+			switch v := v.(*MsgRegisterWrappedTokenContractResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44878,7 +47929,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgApproveIbcTokenForTrading); i {
+			switch v := v.(*MsgMigrateAllWrappedTokens); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44890,7 +47941,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgApproveIbcTokenForTradingResponse); i {
+			switch v := v.(*MsgMigrateAllWrappedTokensResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44902,7 +47953,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterIbcTokenMetadata); i {
+			switch v := v.(*MsgApproveIbcTokenForTrading); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44914,7 +47965,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgRegisterIbcTokenMetadataResponse); i {
+			switch v := v.(*MsgApproveIbcTokenForTradingResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44926,7 +47977,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgCreateDevshardEscrow); i {
+			switch v := v.(*MsgRegisterIbcTokenMetadata); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44938,7 +47989,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgCreateDevshardEscrowResponse); i {
+			switch v := v.(*MsgRegisterIbcTokenMetadataResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44950,7 +48001,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSettleDevshardEscrow); i {
+			switch v := v.(*MsgCreateDevshardEscrow); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44962,7 +48013,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSettleDevshardEscrowResponse); i {
+			switch v := v.(*MsgCreateDevshardEscrowResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44974,7 +48025,7 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MsgSetDevshardRequestsEnabled); i {
+			switch v := v.(*MsgSettleDevshardEscrow); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -44986,6 +48037,30 @@ func file_inference_inference_tx_proto_init() {
 			}
 		}
 		file_inference_inference_tx_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgSettleDevshardEscrowResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_tx_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgSetDevshardRequestsEnabled); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_tx_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MsgSetDevshardRequestsEnabledResponse); i {
 			case 0:
 				return &v.state
@@ -44997,6 +48072,54 @@ func file_inference_inference_tx_proto_init() {
 				return nil
 			}
 		}
+		file_inference_inference_tx_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgScheduleMaintenance); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_tx_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgScheduleMaintenanceResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_tx_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgCancelMaintenance); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_inference_inference_tx_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MsgCancelMaintenanceResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -45004,7 +48127,7 @@ func file_inference_inference_tx_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_inference_inference_tx_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   74,
+			NumMessages:   80,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/inference-chain/api/inference/inference/tx_grpc.pb.go b/inference-chain/api/inference/inference/tx_grpc.pb.go
index f2adead61d..63adae3346 100644
--- a/inference-chain/api/inference/inference/tx_grpc.pb.go
+++ b/inference-chain/api/inference/inference/tx_grpc.pb.go
@@ -28,6 +28,7 @@ const (
 	Msg_InvalidateInference_FullMethodName              = "/inference.inference.Msg/InvalidateInference"
 	Msg_RevalidateInference_FullMethodName              = "/inference.inference.Msg/RevalidateInference"
 	Msg_ClaimRewards_FullMethodName                     = "/inference.inference.Msg/ClaimRewards"
+	Msg_SetClaimRecipients_FullMethodName               = "/inference.inference.Msg/SetClaimRecipients"
 	Msg_SubmitPocBatch_FullMethodName                   = "/inference.inference.Msg/SubmitPocBatch"
 	Msg_SubmitPocValidationsV2_FullMethodName           = "/inference.inference.Msg/SubmitPocValidationsV2"
 	Msg_PoCV2StoreCommit_FullMethodName                 = "/inference.inference.Msg/PoCV2StoreCommit"
@@ -56,6 +57,8 @@ const (
 	Msg_CreateDevshardEscrow_FullMethodName             = "/inference.inference.Msg/CreateDevshardEscrow"
 	Msg_SettleDevshardEscrow_FullMethodName             = "/inference.inference.Msg/SettleDevshardEscrow"
 	Msg_SetDevshardRequestsEnabled_FullMethodName       = "/inference.inference.Msg/SetDevshardRequestsEnabled"
+	Msg_ScheduleMaintenance_FullMethodName              = "/inference.inference.Msg/ScheduleMaintenance"
+	Msg_CancelMaintenance_FullMethodName                = "/inference.inference.Msg/CancelMaintenance"
 	Msg_SetPoCDelegation_FullMethodName                 = "/inference.inference.Msg/SetPoCDelegation"
 	Msg_RefusePoCDelegation_FullMethodName              = "/inference.inference.Msg/RefusePoCDelegation"
 	Msg_DeclarePoCIntent_FullMethodName                 = "/inference.inference.Msg/DeclarePoCIntent"
@@ -68,14 +71,20 @@ type MsgClient interface {
 	// UpdateParams defines a (governance) operation for updating the module
 	// parameters. The authority defaults to the x/gov module account.
 	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
+	// Deprecated: Do not use.
 	StartInference(ctx context.Context, in *MsgStartInference, opts ...grpc.CallOption) (*MsgStartInferenceResponse, error)
+	// Deprecated: Do not use.
 	FinishInference(ctx context.Context, in *MsgFinishInference, opts ...grpc.CallOption) (*MsgFinishInferenceResponse, error)
 	SubmitNewParticipant(ctx context.Context, in *MsgSubmitNewParticipant, opts ...grpc.CallOption) (*MsgSubmitNewParticipantResponse, error)
+	// Deprecated: Do not use.
 	Validation(ctx context.Context, in *MsgValidation, opts ...grpc.CallOption) (*MsgValidationResponse, error)
 	SubmitNewUnfundedParticipant(ctx context.Context, in *MsgSubmitNewUnfundedParticipant, opts ...grpc.CallOption) (*MsgSubmitNewUnfundedParticipantResponse, error)
+	// Deprecated: Do not use.
 	InvalidateInference(ctx context.Context, in *MsgInvalidateInference, opts ...grpc.CallOption) (*MsgInvalidateInferenceResponse, error)
+	// Deprecated: Do not use.
 	RevalidateInference(ctx context.Context, in *MsgRevalidateInference, opts ...grpc.CallOption) (*MsgRevalidateInferenceResponse, error)
 	ClaimRewards(ctx context.Context, in *MsgClaimRewards, opts ...grpc.CallOption) (*MsgClaimRewardsResponse, error)
+	SetClaimRecipients(ctx context.Context, in *MsgSetClaimRecipients, opts ...grpc.CallOption) (*MsgSetClaimRecipientsResponse, error)
 	SubmitPocBatch(ctx context.Context, in *MsgSubmitPocBatch, opts ...grpc.CallOption) (*MsgSubmitPocBatchResponse, error)
 	// PoC v2 validation messages
 	SubmitPocValidationsV2(ctx context.Context, in *MsgSubmitPocValidationsV2, opts ...grpc.CallOption) (*MsgSubmitPocValidationsV2Response, error)
@@ -106,6 +115,8 @@ type MsgClient interface {
 	CreateDevshardEscrow(ctx context.Context, in *MsgCreateDevshardEscrow, opts ...grpc.CallOption) (*MsgCreateDevshardEscrowResponse, error)
 	SettleDevshardEscrow(ctx context.Context, in *MsgSettleDevshardEscrow, opts ...grpc.CallOption) (*MsgSettleDevshardEscrowResponse, error)
 	SetDevshardRequestsEnabled(ctx context.Context, in *MsgSetDevshardRequestsEnabled, opts ...grpc.CallOption) (*MsgSetDevshardRequestsEnabledResponse, error)
+	ScheduleMaintenance(ctx context.Context, in *MsgScheduleMaintenance, opts ...grpc.CallOption) (*MsgScheduleMaintenanceResponse, error)
+	CancelMaintenance(ctx context.Context, in *MsgCancelMaintenance, opts ...grpc.CallOption) (*MsgCancelMaintenanceResponse, error)
 	SetPoCDelegation(ctx context.Context, in *MsgSetPoCDelegation, opts ...grpc.CallOption) (*MsgSetPoCDelegationResponse, error)
 	RefusePoCDelegation(ctx context.Context, in *MsgRefusePoCDelegation, opts ...grpc.CallOption) (*MsgRefusePoCDelegationResponse, error)
 	DeclarePoCIntent(ctx context.Context, in *MsgDeclarePoCIntent, opts ...grpc.CallOption) (*MsgDeclarePoCIntentResponse, error)
@@ -128,6 +139,7 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) StartInference(ctx context.Context, in *MsgStartInference, opts ...grpc.CallOption) (*MsgStartInferenceResponse, error) {
 	out := new(MsgStartInferenceResponse)
 	err := c.cc.Invoke(ctx, Msg_StartInference_FullMethodName, in, out, opts...)
@@ -137,6 +149,7 @@ func (c *msgClient) StartInference(ctx context.Context, in *MsgStartInference, o
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) FinishInference(ctx context.Context, in *MsgFinishInference, opts ...grpc.CallOption) (*MsgFinishInferenceResponse, error) {
 	out := new(MsgFinishInferenceResponse)
 	err := c.cc.Invoke(ctx, Msg_FinishInference_FullMethodName, in, out, opts...)
@@ -155,6 +168,7 @@ func (c *msgClient) SubmitNewParticipant(ctx context.Context, in *MsgSubmitNewPa
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) Validation(ctx context.Context, in *MsgValidation, opts ...grpc.CallOption) (*MsgValidationResponse, error) {
 	out := new(MsgValidationResponse)
 	err := c.cc.Invoke(ctx, Msg_Validation_FullMethodName, in, out, opts...)
@@ -173,6 +187,7 @@ func (c *msgClient) SubmitNewUnfundedParticipant(ctx context.Context, in *MsgSub
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) InvalidateInference(ctx context.Context, in *MsgInvalidateInference, opts ...grpc.CallOption) (*MsgInvalidateInferenceResponse, error) {
 	out := new(MsgInvalidateInferenceResponse)
 	err := c.cc.Invoke(ctx, Msg_InvalidateInference_FullMethodName, in, out, opts...)
@@ -182,6 +197,7 @@ func (c *msgClient) InvalidateInference(ctx context.Context, in *MsgInvalidateIn
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) RevalidateInference(ctx context.Context, in *MsgRevalidateInference, opts ...grpc.CallOption) (*MsgRevalidateInferenceResponse, error) {
 	out := new(MsgRevalidateInferenceResponse)
 	err := c.cc.Invoke(ctx, Msg_RevalidateInference_FullMethodName, in, out, opts...)
@@ -200,6 +216,15 @@ func (c *msgClient) ClaimRewards(ctx context.Context, in *MsgClaimRewards, opts
 	return out, nil
 }
 
+func (c *msgClient) SetClaimRecipients(ctx context.Context, in *MsgSetClaimRecipients, opts ...grpc.CallOption) (*MsgSetClaimRecipientsResponse, error) {
+	out := new(MsgSetClaimRecipientsResponse)
+	err := c.cc.Invoke(ctx, Msg_SetClaimRecipients_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) SubmitPocBatch(ctx context.Context, in *MsgSubmitPocBatch, opts ...grpc.CallOption) (*MsgSubmitPocBatchResponse, error) {
 	out := new(MsgSubmitPocBatchResponse)
 	err := c.cc.Invoke(ctx, Msg_SubmitPocBatch_FullMethodName, in, out, opts...)
@@ -452,6 +477,24 @@ func (c *msgClient) SetDevshardRequestsEnabled(ctx context.Context, in *MsgSetDe
 	return out, nil
 }
 
+func (c *msgClient) ScheduleMaintenance(ctx context.Context, in *MsgScheduleMaintenance, opts ...grpc.CallOption) (*MsgScheduleMaintenanceResponse, error) {
+	out := new(MsgScheduleMaintenanceResponse)
+	err := c.cc.Invoke(ctx, Msg_ScheduleMaintenance_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) CancelMaintenance(ctx context.Context, in *MsgCancelMaintenance, opts ...grpc.CallOption) (*MsgCancelMaintenanceResponse, error) {
+	out := new(MsgCancelMaintenanceResponse)
+	err := c.cc.Invoke(ctx, Msg_CancelMaintenance_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) SetPoCDelegation(ctx context.Context, in *MsgSetPoCDelegation, opts ...grpc.CallOption) (*MsgSetPoCDelegationResponse, error) {
 	out := new(MsgSetPoCDelegationResponse)
 	err := c.cc.Invoke(ctx, Msg_SetPoCDelegation_FullMethodName, in, out, opts...)
@@ -486,14 +529,20 @@ type MsgServer interface {
 	// UpdateParams defines a (governance) operation for updating the module
 	// parameters. The authority defaults to the x/gov module account.
 	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
+	// Deprecated: Do not use.
 	StartInference(context.Context, *MsgStartInference) (*MsgStartInferenceResponse, error)
+	// Deprecated: Do not use.
 	FinishInference(context.Context, *MsgFinishInference) (*MsgFinishInferenceResponse, error)
 	SubmitNewParticipant(context.Context, *MsgSubmitNewParticipant) (*MsgSubmitNewParticipantResponse, error)
+	// Deprecated: Do not use.
 	Validation(context.Context, *MsgValidation) (*MsgValidationResponse, error)
 	SubmitNewUnfundedParticipant(context.Context, *MsgSubmitNewUnfundedParticipant) (*MsgSubmitNewUnfundedParticipantResponse, error)
+	// Deprecated: Do not use.
 	InvalidateInference(context.Context, *MsgInvalidateInference) (*MsgInvalidateInferenceResponse, error)
+	// Deprecated: Do not use.
 	RevalidateInference(context.Context, *MsgRevalidateInference) (*MsgRevalidateInferenceResponse, error)
 	ClaimRewards(context.Context, *MsgClaimRewards) (*MsgClaimRewardsResponse, error)
+	SetClaimRecipients(context.Context, *MsgSetClaimRecipients) (*MsgSetClaimRecipientsResponse, error)
 	SubmitPocBatch(context.Context, *MsgSubmitPocBatch) (*MsgSubmitPocBatchResponse, error)
 	// PoC v2 validation messages
 	SubmitPocValidationsV2(context.Context, *MsgSubmitPocValidationsV2) (*MsgSubmitPocValidationsV2Response, error)
@@ -524,6 +573,8 @@ type MsgServer interface {
 	CreateDevshardEscrow(context.Context, *MsgCreateDevshardEscrow) (*MsgCreateDevshardEscrowResponse, error)
 	SettleDevshardEscrow(context.Context, *MsgSettleDevshardEscrow) (*MsgSettleDevshardEscrowResponse, error)
 	SetDevshardRequestsEnabled(context.Context, *MsgSetDevshardRequestsEnabled) (*MsgSetDevshardRequestsEnabledResponse, error)
+	ScheduleMaintenance(context.Context, *MsgScheduleMaintenance) (*MsgScheduleMaintenanceResponse, error)
+	CancelMaintenance(context.Context, *MsgCancelMaintenance) (*MsgCancelMaintenanceResponse, error)
 	SetPoCDelegation(context.Context, *MsgSetPoCDelegation) (*MsgSetPoCDelegationResponse, error)
 	RefusePoCDelegation(context.Context, *MsgRefusePoCDelegation) (*MsgRefusePoCDelegationResponse, error)
 	DeclarePoCIntent(context.Context, *MsgDeclarePoCIntent) (*MsgDeclarePoCIntentResponse, error)
@@ -561,6 +612,9 @@ func (UnimplementedMsgServer) RevalidateInference(context.Context, *MsgRevalidat
 func (UnimplementedMsgServer) ClaimRewards(context.Context, *MsgClaimRewards) (*MsgClaimRewardsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ClaimRewards not implemented")
 }
+func (UnimplementedMsgServer) SetClaimRecipients(context.Context, *MsgSetClaimRecipients) (*MsgSetClaimRecipientsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SetClaimRecipients not implemented")
+}
 func (UnimplementedMsgServer) SubmitPocBatch(context.Context, *MsgSubmitPocBatch) (*MsgSubmitPocBatchResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SubmitPocBatch not implemented")
 }
@@ -645,6 +699,12 @@ func (UnimplementedMsgServer) SettleDevshardEscrow(context.Context, *MsgSettleDe
 func (UnimplementedMsgServer) SetDevshardRequestsEnabled(context.Context, *MsgSetDevshardRequestsEnabled) (*MsgSetDevshardRequestsEnabledResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SetDevshardRequestsEnabled not implemented")
 }
+func (UnimplementedMsgServer) ScheduleMaintenance(context.Context, *MsgScheduleMaintenance) (*MsgScheduleMaintenanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ScheduleMaintenance not implemented")
+}
+func (UnimplementedMsgServer) CancelMaintenance(context.Context, *MsgCancelMaintenance) (*MsgCancelMaintenanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CancelMaintenance not implemented")
+}
 func (UnimplementedMsgServer) SetPoCDelegation(context.Context, *MsgSetPoCDelegation) (*MsgSetPoCDelegationResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SetPoCDelegation not implemented")
 }
@@ -829,6 +889,24 @@ func _Msg_ClaimRewards_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_SetClaimRecipients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgSetClaimRecipients)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).SetClaimRecipients(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_SetClaimRecipients_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).SetClaimRecipients(ctx, req.(*MsgSetClaimRecipients))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_SubmitPocBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgSubmitPocBatch)
 	if err := dec(in); err != nil {
@@ -1333,6 +1411,42 @@ func _Msg_SetDevshardRequestsEnabled_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_ScheduleMaintenance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgScheduleMaintenance)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).ScheduleMaintenance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_ScheduleMaintenance_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).ScheduleMaintenance(ctx, req.(*MsgScheduleMaintenance))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_CancelMaintenance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgCancelMaintenance)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).CancelMaintenance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Msg_CancelMaintenance_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).CancelMaintenance(ctx, req.(*MsgCancelMaintenance))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_SetPoCDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgSetPoCDelegation)
 	if err := dec(in); err != nil {
@@ -1430,6 +1544,10 @@ var Msg_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "ClaimRewards",
 			Handler:    _Msg_ClaimRewards_Handler,
 		},
+		{
+			MethodName: "SetClaimRecipients",
+			Handler:    _Msg_SetClaimRecipients_Handler,
+		},
 		{
 			MethodName: "SubmitPocBatch",
 			Handler:    _Msg_SubmitPocBatch_Handler,
@@ -1542,6 +1660,14 @@ var Msg_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "SetDevshardRequestsEnabled",
 			Handler:    _Msg_SetDevshardRequestsEnabled_Handler,
 		},
+		{
+			MethodName: "ScheduleMaintenance",
+			Handler:    _Msg_ScheduleMaintenance_Handler,
+		},
+		{
+			MethodName: "CancelMaintenance",
+			Handler:    _Msg_CancelMaintenance_Handler,
+		},
 		{
 			MethodName: "SetPoCDelegation",
 			Handler:    _Msg_SetPoCDelegation_Handler,
diff --git a/inference-chain/app/ante.go b/inference-chain/app/ante.go
index b5a11a23a3..9c9b94e7cd 100644
--- a/inference-chain/app/ante.go
+++ b/inference-chain/app/ante.go
@@ -211,14 +211,19 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 		},
 		NetworkDutyFeeBypassDecorator{
 			InferenceKeeper: options.InferenceKeeper,
-			// Cap for fee-exempt duty transactions. Must accommodate the
-			// DAPI's batched transactions (BatchGasLimit = 100M in tx_manager)
-			// plus headroom for future batch-size growth. 200M is 2x current
-			// batch size, giving room for larger PoC validation V2 batches
-			// without bumping against the cap. Raise if you see legitimate
-			// duty transactions rejected with "gas N exceeds cap 20000000".
-			GasCap:   3_000_000_000,
-			Priority: 500_000, // ensure zero-fee duty txs aren't starved
+			// Cap for fee-exempt duty transactions. Sized at 3x the DAPI's
+			// BatchGasLimit (1B, see decentralized-api/cosmosclient/tx_manager/
+			// tx_manager.go:58) to accommodate the largest legitimate batched
+			// PoC V2 / weight-distribution txs with headroom for future growth.
+			// Raise if you see legitimate duty transactions rejected with
+			// "gas N exceeds cap 3000000000".
+			GasCap: 3_000_000_000,
+			// Network-duty txs (PoC, validation, BLS, weight distribution) are
+			// consensus-critical and must outrank all other zero-fee bypass
+			// paths. LiquidityPoolFeeBypass uses Priority=1_000_000; this is
+			// 10x to ensure under mempool pressure the duty txs land in blocks
+			// before discretionary swap traffic.
+			Priority: 10_000_000,
 		},
 		ante.NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper, GonkaFeeChecker(options.InferenceKeeper)),
 		// Run mempool filters AFTER fee deduction (so invalid txs pay fees), but BEFORE signature verification (to avoid crypto work).
diff --git a/inference-chain/app/ante_fee.go b/inference-chain/app/ante_fee.go
index 5791147407..e863b133ce 100644
--- a/inference-chain/app/ante_fee.go
+++ b/inference-chain/app/ante_fee.go
@@ -115,10 +115,14 @@ func isNetworkDuty(msg sdk.Msg, ik *inferencemodulekeeper.Keeper) bool {
 // These are already rate-limited by timing windows, duplicate checks, or allowlists.
 func isExemptMessageType(msg sdk.Msg) bool {
 	switch msg.(type) {
-	// PoC duty messages (throttled by PocPeriodValidationDecorator window checks)
+	// PoC duty messages (throttled by PocPeriodValidationDecorator window checks).
+	// MsgPoCV2StoreCommit is intentionally NOT exempt: it carries a
+	// count-proportional sybil-defense gas charge (see chargePoCV2StoreCommitGas
+	// in msg_server_poc_v2_commit.go) that requires the tx to pay fees.
 	case *inferencetypes.MsgSubmitPocBatch,
 		*inferencetypes.MsgSubmitPocValidationsV2,
-		*inferencetypes.MsgMLNodeWeightDistribution:
+		*inferencetypes.MsgMLNodeWeightDistribution,
+		*inferencetypes.MsgSubmitSeed:
 		return true
 
 	// Inference validation duty (throttled by ValidationEarlyRejectDecorator)
@@ -135,11 +139,29 @@ func isExemptMessageType(msg sdk.Msg) bool {
 		*inferencetypes.MsgRevalidateInference:
 		return true
 
+	// Routine host duties on a fixed schedule. Not user-discretionary, not a
+	// sybil-attack vector. Rate-limited implicitly: hardware diff fires only
+	// on changes / per-block heartbeat, claim rewards is once per epoch per
+	// host. Excluding these from fees keeps the per-host yearly budget from
+	// being dominated by mechanical chain bookkeeping.
+	case *inferencetypes.MsgSubmitHardwareDiff,
+		*inferencetypes.MsgClaimRewards:
+		return true
+
+	// Devshard escrow settlement is the protocol-side disbursement tx. It is
+	// allowlist-restricted (EscrowAllowListPermission, see permissions.go:123)
+	// and per-epoch capped via DevshardEscrowParams.MaxEscrowsPerEpoch. The
+	// MsgCreateDevshardEscrow counterpart is user-driven and intentionally
+	// NOT exempted — the escrow creator pays fees like any other user.
+	case *inferencetypes.MsgSettleDevshardEscrow:
+		return true
+
 	// BLS DKG protocol messages (epoch-scoped, duplicate-checked, deadline-enforced)
 	case *blstypes.MsgSubmitDealerPart,
 		*blstypes.MsgSubmitVerificationVector,
 		*blstypes.MsgSubmitGroupKeyValidationSignature,
-		*blstypes.MsgSubmitPartialSignature:
+		*blstypes.MsgSubmitPartialSignature,
+		*blstypes.MsgRespondDealerComplaints:
 		return true
 
 	// NOTE: MsgRequestThresholdSignature is intentionally NOT exempt.
diff --git a/inference-chain/app/ante_fee_test.go b/inference-chain/app/ante_fee_test.go
index e327a95f7c..6dc90ad689 100644
--- a/inference-chain/app/ante_fee_test.go
+++ b/inference-chain/app/ante_fee_test.go
@@ -43,6 +43,7 @@ func (t testFeeTx) FeeGranter() []byte                     { return nil }
 func TestNetworkDutyBypass_AllExemptMessages(t *testing.T) {
 	exemptMsgs := map[string]sdk.Msg{
 		"MsgSubmitPocBatch":                    &inferencetypes.MsgSubmitPocBatch{},
+		"MsgSubmitSeed":                        &inferencetypes.MsgSubmitSeed{},
 		"MsgValidation":                        &inferencetypes.MsgValidation{},
 		"MsgStartInference":                    &inferencetypes.MsgStartInference{},
 		"MsgFinishInference":                   &inferencetypes.MsgFinishInference{},
@@ -50,10 +51,14 @@ func TestNetworkDutyBypass_AllExemptMessages(t *testing.T) {
 		"MsgRevalidateInference":               &inferencetypes.MsgRevalidateInference{},
 		"MsgMLNodeWeightDistribution":          &inferencetypes.MsgMLNodeWeightDistribution{},
 		"MsgSubmitPocValidationsV2":            &inferencetypes.MsgSubmitPocValidationsV2{},
+		"MsgSubmitHardwareDiff":                &inferencetypes.MsgSubmitHardwareDiff{},
+		"MsgClaimRewards":                      &inferencetypes.MsgClaimRewards{},
+		"MsgSettleDevshardEscrow":              &inferencetypes.MsgSettleDevshardEscrow{},
 		"MsgSubmitDealerPart":                  &blstypes.MsgSubmitDealerPart{},
 		"MsgSubmitVerificationVector":          &blstypes.MsgSubmitVerificationVector{},
 		"MsgSubmitGroupKeyValidationSignature": &blstypes.MsgSubmitGroupKeyValidationSignature{},
 		"MsgSubmitPartialSignature":            &blstypes.MsgSubmitPartialSignature{},
+		"MsgRespondDealerComplaints":           &blstypes.MsgRespondDealerComplaints{},
 	}
 
 	for name, msg := range exemptMsgs {
@@ -89,7 +94,9 @@ func TestNetworkDutyBypass_NonExemptMessages(t *testing.T) {
 	nonExemptMsgs := []sdk.Msg{
 		&banktypes.MsgSend{},
 		&stakingtypes.MsgDelegate{},
-		&inferencetypes.MsgClaimRewards{},
+		// MsgPoCV2StoreCommit is intentionally non-exempt: it carries the
+		// count-proportional sybil-defense fee defined in FeeParams. See
+		// chargePoCV2StoreCommitGas in msg_server_poc_v2_commit.go.
 		&inferencetypes.MsgPoCV2StoreCommit{},
 		&inferencetypes.MsgSubmitNewParticipant{},
 	}
@@ -163,6 +170,7 @@ func TestNetworkDutyBypass_GasCapEnforced(t *testing.T) {
 func TestIsExemptMessageType(t *testing.T) {
 	// Exempt
 	require.True(t, isExemptMessageType(&inferencetypes.MsgSubmitPocBatch{}))
+	require.True(t, isExemptMessageType(&inferencetypes.MsgSubmitSeed{}))
 	require.True(t, isExemptMessageType(&inferencetypes.MsgSubmitPocValidationsV2{}))
 	require.True(t, isExemptMessageType(&inferencetypes.MsgValidation{}))
 	require.True(t, isExemptMessageType(&inferencetypes.MsgStartInference{}))
@@ -174,11 +182,15 @@ func TestIsExemptMessageType(t *testing.T) {
 	require.True(t, isExemptMessageType(&blstypes.MsgSubmitVerificationVector{}))
 	require.True(t, isExemptMessageType(&blstypes.MsgSubmitGroupKeyValidationSignature{}))
 	require.True(t, isExemptMessageType(&blstypes.MsgSubmitPartialSignature{}))
+	require.True(t, isExemptMessageType(&blstypes.MsgRespondDealerComplaints{}))
+	require.True(t, isExemptMessageType(&inferencetypes.MsgSubmitHardwareDiff{}))
+	require.True(t, isExemptMessageType(&inferencetypes.MsgClaimRewards{}))
+	require.True(t, isExemptMessageType(&inferencetypes.MsgSettleDevshardEscrow{}))
 
 	// Not exempt
 	require.False(t, isExemptMessageType(&blstypes.MsgRequestThresholdSignature{})) // open to anyone, no rate limit
-	require.False(t, isExemptMessageType(&inferencetypes.MsgPoCV2StoreCommit{}))
-	require.False(t, isExemptMessageType(&inferencetypes.MsgClaimRewards{}))
+	require.False(t, isExemptMessageType(&inferencetypes.MsgPoCV2StoreCommit{}))    // intentional sybil-defense fee via chargePoCV2StoreCommitGas
+	require.False(t, isExemptMessageType(&inferencetypes.MsgCreateDevshardEscrow{})) // user-driven, paid
 	require.False(t, isExemptMessageType(&inferencetypes.MsgSubmitNewParticipant{}))
 	require.False(t, isExemptMessageType(&banktypes.MsgSend{}))
 	require.False(t, isExemptMessageType(&stakingtypes.MsgDelegate{}))
@@ -225,7 +237,7 @@ func TestIsNetworkDuty_MsgExec_FailsClosed(t *testing.T) {
 func TestIsNetworkDuty_NonExecNonExempt(t *testing.T) {
 	// Non-MsgExec, non-exempt message
 	require.False(t, isNetworkDuty(&banktypes.MsgSend{}, nil))
-	require.False(t, isNetworkDuty(&inferencetypes.MsgClaimRewards{}, nil))
+	require.False(t, isNetworkDuty(&inferencetypes.MsgPoCV2StoreCommit{}, nil))
 }
 
 func TestIsNetworkDuty_ExemptDirectMessage(t *testing.T) {
diff --git a/inference-chain/app/app.go b/inference-chain/app/app.go
index b92d6b32cd..474c3bf930 100644
--- a/inference-chain/app/app.go
+++ b/inference-chain/app/app.go
@@ -288,6 +288,13 @@ func New(
 	}
 
 	app.CollateralKeeper.SetRequiredCollateralProvider(app.InferenceKeeper)
+	app.CollateralKeeper.SetMaintenanceChecker(&app.InferenceKeeper)
+
+	// Wire maintenance-aware liveness exemption into slashing keeper.
+	// The adapter bridges inference keeper's AccAddress-based maintenance state
+	// to the slashing keeper's ConsAddress-based liveness checks.
+	maintenanceAdapter := NewMaintenanceSlashingAdapter(&app.InferenceKeeper)
+	app.SlashingKeeper.SetMaintenanceChecker(maintenanceAdapter)
 
 	app.App = appBuilder.Build(db, traceStore, baseAppOptions...)
 
diff --git a/inference-chain/app/maintenance_slashing_adapter.go b/inference-chain/app/maintenance_slashing_adapter.go
new file mode 100644
index 0000000000..93928f14ea
--- /dev/null
+++ b/inference-chain/app/maintenance_slashing_adapter.go
@@ -0,0 +1,57 @@
+package app
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/keeper"
+)
+
+// MaintenanceSlashingAdapter adapts the inference keeper's maintenance check
+// (which uses AccAddress) to the slashing keeper's MaintenanceChecker interface
+// (which uses ConsAddress). This bridge is necessary because the slashing module
+// operates on consensus addresses while maintenance state is keyed by participant
+// (account) addresses.
+type MaintenanceSlashingAdapter struct {
+	inferenceKeeper *keeper.Keeper
+}
+
+// NewMaintenanceSlashingAdapter creates a new adapter.
+func NewMaintenanceSlashingAdapter(k *keeper.Keeper) *MaintenanceSlashingAdapter {
+	return &MaintenanceSlashingAdapter{inferenceKeeper: k}
+}
+
+// IsValidatorInActiveMaintenance checks if the validator identified by its
+// consensus address is currently in an active maintenance window.
+//
+// This is on the slashing hot path: it is invoked for every validator that
+// missed a block, on every block. Implementation must be O(1) — never iterate
+// the validator set here.
+//
+// On lookup failure we conservatively return true (treat as in-maintenance) so
+// that a transient staking-keeper error cannot cause a validator that IS in
+// active maintenance to be slashed for downtime. Liveness slashing must be
+// fail-closed: skipping a slash is recoverable, slashing in error is not.
+// Genuine downtime (without active maintenance) will still be caught by the
+// next block's evaluation once the lookup succeeds.
+func (a *MaintenanceSlashingAdapter) IsValidatorInActiveMaintenance(ctx context.Context, consAddr sdk.ConsAddress) bool {
+	// O(1) lookup of the validator by consensus address.
+	v, err := a.inferenceKeeper.Staking.GetValidatorByConsAddr(ctx, consAddr)
+	if err != nil {
+		a.inferenceKeeper.Logger().Warn(
+			"MaintenanceSlashingAdapter: failed to look up validator by consensus address; treating as in maintenance to avoid false slashing",
+			"cons_addr", consAddr.String(), "error", err,
+		)
+		return true
+	}
+	valAddr, err := sdk.ValAddressFromBech32(v.GetOperator())
+	if err != nil {
+		a.inferenceKeeper.Logger().Warn(
+			"MaintenanceSlashingAdapter: failed to decode validator operator address; treating as in maintenance to avoid false slashing",
+			"cons_addr", consAddr.String(), "operator", v.GetOperator(), "error", err,
+		)
+		return true
+	}
+	// In Gonka, AccAddress and ValAddress share the same underlying bytes.
+	return a.inferenceKeeper.IsParticipantInActiveMaintenance(ctx, sdk.AccAddress(valAddr))
+}
diff --git a/inference-chain/app/upgrade_handler_primer.md b/inference-chain/app/upgrade_handler_primer.md
new file mode 100644
index 0000000000..c2f451dd14
--- /dev/null
+++ b/inference-chain/app/upgrade_handler_primer.md
@@ -0,0 +1,13 @@
+---
+id: inference-chain-upgrade-handlers
+ai_review: primer
+type: implementation
+path_filters:
+  - "inference-chain/app/upgrades.go"
+  - "inference-chain/app/upgrades_enabled.go"
+  - "inference-chain/app/upgrade_tracking.go"
+  - "inference-chain/app/upgrades/**.go"
+---
+Use `app.setTrackedUpgradeHandler(name, handler)` as the standard way to register full software upgrade handlers. Do not call `app.UpgradeKeeper.SetUpgradeHandler(...)` directly for new upgrades unless there is a deliberate, reviewed reason to bypass `LastUpgradeHeight` tracking. The helper applies the shared `withLastUpgradeHeight(...)` wrapper so successful full software upgrades record the applied height in one centralized place.
+
+Historical upgrade registrations remain in `upgrades.go` for readability and for the normal Cosmos SDK upgrade registration pattern, but they are not expected to be re-executed by replaying chain history on a single modern binary. The intended operational model is live upgrade sequencing across historical binaries, where an old binary runs until its scheduled halt and the next binary resumes with the matching handler. Review changes here with that assumption in mind: preserve the registration map for clarity and continuity, but focus behavioral scrutiny on newly introduced upgrade handlers and the current tracked-registration convention.
diff --git a/inference-chain/app/upgrade_tracking.go b/inference-chain/app/upgrade_tracking.go
new file mode 100644
index 0000000000..ede2a1c0d8
--- /dev/null
+++ b/inference-chain/app/upgrade_tracking.go
@@ -0,0 +1,37 @@
+package app
+
+import (
+	"context"
+
+	upgradetypes "cosmossdk.io/x/upgrade/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+)
+
+func (app *App) withLastUpgradeHeight(next upgradetypes.UpgradeHandler) upgradetypes.UpgradeHandler {
+	return func(ctx context.Context, plan upgradetypes.Plan, vm module.VersionMap) (module.VersionMap, error) {
+		outVM, err := next(ctx, plan, vm)
+		if err != nil {
+			return outVM, err
+		}
+
+		if err := app.InferenceKeeper.SetLastUpgradeHeight(ctx, plan.Height); err != nil {
+			app.Logger().Error("Failed to set last upgrade height from upgrade handler",
+				"height", plan.Height,
+				"name", plan.Name,
+				"error", err,
+			)
+			return outVM, err
+		}
+
+		app.Logger().Info("Recorded last upgrade height from upgrade handler",
+			"height", plan.Height,
+			"name", plan.Name,
+		)
+
+		return outVM, nil
+	}
+}
+
+func (app *App) setTrackedUpgradeHandler(name string, handler upgradetypes.UpgradeHandler) {
+	app.UpgradeKeeper.SetUpgradeHandler(name, app.withLastUpgradeHeight(handler))
+}
diff --git a/inference-chain/app/upgrades.go b/inference-chain/app/upgrades.go
index 0a10fccb11..b31db5543a 100644
--- a/inference-chain/app/upgrades.go
+++ b/inference-chain/app/upgrades.go
@@ -56,19 +56,19 @@ func (app *App) setupUpgradeHandlers() {
 	}
 	app.Logger().Info("Applying upgrade", "upgradeInfo", upgradeInfo)
 
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_2.UpgradeName, v0_2_2.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_3.UpgradeName, v0_2_3.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_4.UpgradeName, v0_2_4.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_5.UpgradeName, v0_2_5.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.BlsKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_6.UpgradeName, v0_2_6.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_7.UpgradeName, v0_2_7.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_8.UpgradeName, v0_2_8.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.BlsKeeper, app.DistrKeeper, app.AuthzKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_9.UpgradeName, v0_2_9.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_10.UpgradeName, v0_2_10.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_11.UpgradeName, v0_2_11.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper, app.BlsKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_12.UpgradeName, v0_2_12.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper, app.BlsKeeper, app.AuthzKeeper, app.FeeGrantKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_13.UpgradeName, v0_2_13.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.AuthzKeeper, app.GovKeeper))
-	app.UpgradeKeeper.SetUpgradeHandler(v0_2_14.UpgradeName, v0_2_14.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
+	app.setTrackedUpgradeHandler(v0_2_2.UpgradeName, v0_2_2.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
+	app.setTrackedUpgradeHandler(v0_2_3.UpgradeName, v0_2_3.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
+	app.setTrackedUpgradeHandler(v0_2_4.UpgradeName, v0_2_4.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
+	app.setTrackedUpgradeHandler(v0_2_5.UpgradeName, v0_2_5.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.BlsKeeper))
+	app.setTrackedUpgradeHandler(v0_2_6.UpgradeName, v0_2_6.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper))
+	app.setTrackedUpgradeHandler(v0_2_7.UpgradeName, v0_2_7.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper))
+	app.setTrackedUpgradeHandler(v0_2_8.UpgradeName, v0_2_8.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.BlsKeeper, app.DistrKeeper, app.AuthzKeeper))
+	app.setTrackedUpgradeHandler(v0_2_9.UpgradeName, v0_2_9.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper))
+	app.setTrackedUpgradeHandler(v0_2_10.UpgradeName, v0_2_10.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper))
+	app.setTrackedUpgradeHandler(v0_2_11.UpgradeName, v0_2_11.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper, app.BlsKeeper))
+	app.setTrackedUpgradeHandler(v0_2_12.UpgradeName, v0_2_12.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.DistrKeeper, app.BlsKeeper, app.AuthzKeeper, app.FeeGrantKeeper))
+	app.setTrackedUpgradeHandler(v0_2_13.UpgradeName, v0_2_13.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.AuthzKeeper, app.GovKeeper))
+	app.setTrackedUpgradeHandler(v0_2_14.UpgradeName, v0_2_14.CreateUpgradeHandler(app.ModuleManager, app.Configurator(), app.InferenceKeeper, app.GenesistransferKeeper, app.MintKeeper))
 }
 
 func (app *App) registerMigrations() {
diff --git a/inference-chain/app/upgrades/v0_2_14/constants.go b/inference-chain/app/upgrades/v0_2_14/constants.go
index f2727c317a..d7acdcefe3 100644
--- a/inference-chain/app/upgrades/v0_2_14/constants.go
+++ b/inference-chain/app/upgrades/v0_2_14/constants.go
@@ -1,3 +1,4 @@
 package v0_2_14
 
+// UpgradeName MUST exactly match the on-chain governance proposal name.
 const UpgradeName = "v0.2.14"
diff --git a/inference-chain/app/upgrades/v0_2_14/upgrades.go b/inference-chain/app/upgrades/v0_2_14/upgrades.go
index f0f9080151..8cc49cf585 100644
--- a/inference-chain/app/upgrades/v0_2_14/upgrades.go
+++ b/inference-chain/app/upgrades/v0_2_14/upgrades.go
@@ -1,23 +1,47 @@
+// Package v0_2_14 holds the upgrade handler scaffold for the v0.2.14 release.
+//
+// At bootstrap time this stays intentionally small: capability-version fix
+// plus RunMigrations. As upgrade work lands, add migration steps below the
+// capability fix and above RunMigrations.
+//
+// If later work bumps a module ConsensusVersion, it must also register the
+// corresponding migration in app/upgrades.go's registerMigrations().
 package v0_2_14
 
 import (
 	"context"
 	"fmt"
 
+	math "cosmossdk.io/math"
 	upgradetypes "cosmossdk.io/x/upgrade/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	mintkeeper "github.com/cosmos/cosmos-sdk/x/mint/keeper"
+
+	genesistransferkeeper "github.com/productscience/inference/x/genesistransfer/keeper"
+	genesistransfertypes "github.com/productscience/inference/x/genesistransfer/types"
 	"github.com/productscience/inference/x/inference/keeper"
 	"github.com/productscience/inference/x/inference/types"
 )
 
+var devshardAllowedCreatorAddressesToAdd = []string{
+	// Dahl / @paranjko
+	"gonka1t9akhsrqjkavh68c7cannlfdj58y25vsewfflt",
+}
+
 func CreateUpgradeHandler(
 	mm *module.Manager,
 	configurator module.Configurator,
 	k keeper.Keeper,
+	gtKeeper genesistransferkeeper.Keeper,
+	mintKeeper mintkeeper.Keeper,
 ) upgradetypes.UpgradeHandler {
 	return func(ctx context.Context, plan upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) {
 		k.LogInfo("starting upgrade", types.Upgrades, "version", UpgradeName)
 
+		// Capability state can already exist even when the version map entry is
+		// missing. Set it explicitly so RunMigrations does not re-run InitGenesis.
 		if _, ok := fromVM["capability"]; !ok {
 			fromVM["capability"] = mm.Modules["capability"].(module.HasConsensusVersion).ConsensusVersion()
 		}
@@ -27,12 +51,35 @@ func CreateUpgradeHandler(
 		if err := backfillDevshardEscrowParamDefaults(ctx, k); err != nil {
 			return nil, err
 		}
+		if err := setDevshardAllowedCreatorAddresses(ctx, k); err != nil {
+			return nil, err
+		}
 		if err := backfillDevshardEscrowFees(ctx, k); err != nil {
 			return nil, err
 		}
 		if err := backfillDevshardEscrowInferenceSealGrace(ctx, k); err != nil {
 			return nil, err
 		}
+		if err := seedDelegationRewardSnapshotForEffectiveEpoch(ctx, k); err != nil {
+			return nil, err
+		}
+		if err := zeroMintInflation(ctx, k, mintKeeper); err != nil {
+			return nil, err
+		}
+		if err := burnFeeCollectorBalance(ctx, k); err != nil {
+			return nil, err
+		}
+
+		// Initialize maintenance params with defaults for existing chains.
+		// All participants start with zero credit — credit is earned going forward.
+		if err := initMaintenanceParams(ctx, k); err != nil {
+			return nil, err
+		}
+
+		// Update genesistransfer params to enable the whitelist and restrict to founders
+		if err := updateGenesisTransferParams(ctx, gtKeeper); err != nil {
+			return nil, fmt.Errorf("update genesistransfer params: %w", err)
+		}
 
 		toVM, err := mm.RunMigrations(ctx, configurator, fromVM)
 		if err != nil {
@@ -44,6 +91,183 @@ func CreateUpgradeHandler(
 	}
 }
 
+func zeroMintInflation(ctx context.Context, k keeper.Keeper, mintKeeper mintkeeper.Keeper) error {
+	params, err := mintKeeper.Params.Get(ctx)
+	if err != nil {
+		return fmt.Errorf("get mint params: %w", err)
+	}
+
+	oldInflationMax := params.InflationMax
+	oldInflationMin := params.InflationMin
+	oldInflationRateChange := params.InflationRateChange
+	params.InflationMax = math.LegacyZeroDec()
+	params.InflationMin = math.LegacyZeroDec()
+	params.InflationRateChange = math.LegacyZeroDec()
+	if err := mintKeeper.Params.Set(ctx, params); err != nil {
+		return fmt.Errorf("set mint params: %w", err)
+	}
+
+	minter, err := mintKeeper.Minter.Get(ctx)
+	if err != nil {
+		return fmt.Errorf("get mint minter: %w", err)
+	}
+
+	oldInflation := minter.Inflation
+	oldAnnualProvisions := minter.AnnualProvisions
+	minter.Inflation = math.LegacyZeroDec()
+	minter.AnnualProvisions = math.LegacyZeroDec()
+	if err := mintKeeper.Minter.Set(ctx, minter); err != nil {
+		return fmt.Errorf("set mint minter: %w", err)
+	}
+
+	k.LogInfo("zeroed mint inflation", types.Upgrades,
+		"old_inflation_max", oldInflationMax.String(),
+		"old_inflation_min", oldInflationMin.String(),
+		"old_inflation_rate_change", oldInflationRateChange.String(),
+		"old_inflation", oldInflation.String(),
+		"old_annual_provisions", oldAnnualProvisions.String(),
+		"new_inflation_max", params.InflationMax.String(),
+		"new_inflation_min", params.InflationMin.String(),
+		"new_inflation_rate_change", params.InflationRateChange.String(),
+		"new_inflation", minter.Inflation.String(),
+		"new_annual_provisions", minter.AnnualProvisions.String(),
+	)
+	return nil
+}
+
+func burnFeeCollectorBalance(ctx context.Context, k keeper.Keeper) error {
+	feeCollectorAddress := authtypes.NewModuleAddress(authtypes.FeeCollectorName)
+	balance := k.BankView.GetAllBalances(ctx, feeCollectorAddress)
+	burnAmount := balance.AmountOf(types.BaseCoin)
+	if burnAmount.IsZero() {
+		k.LogInfo("burn fee collector balance skipped: no base denom balance", types.Upgrades,
+			"denom", types.BaseCoin,
+			"fee_collector_balance", balance.String(),
+		)
+		return nil
+	}
+
+	burnCoins := sdk.NewCoins(sdk.NewCoin(types.BaseCoin, burnAmount))
+	const memo = "v0.2.14: burn erroneously minted inflation"
+	if err := k.BankKeeper.SendCoinsFromModuleToModule(ctx, authtypes.FeeCollectorName, types.ModuleName, burnCoins, memo); err != nil {
+		return fmt.Errorf("transfer fee collector balance to inference module for burn: %w", err)
+	}
+	if err := k.BankKeeper.BurnCoins(ctx, types.ModuleName, burnCoins, memo); err != nil {
+		return fmt.Errorf("burn fee collector balance: %w", err)
+	}
+
+	k.LogInfo("burned fee collector balance", types.Upgrades,
+		"amount", burnCoins.String(),
+		"fee_collector_balance", balance.String(),
+	)
+	return nil
+}
+
+func setDevshardAllowedCreatorAddresses(ctx context.Context, k keeper.Keeper) error {
+	return addDevshardAllowedCreatorAddresses(ctx, k, devshardAllowedCreatorAddressesToAdd)
+}
+
+func addDevshardAllowedCreatorAddresses(ctx context.Context, k keeper.Keeper, addresses []string) error {
+	params, err := k.GetParams(ctx)
+	if err != nil {
+		return err
+	}
+	if params.DevshardEscrowParams == nil {
+		params.DevshardEscrowParams = types.DefaultDevshardEscrowParams()
+	}
+
+	seen := make(map[string]struct{}, len(params.DevshardEscrowParams.AllowedCreatorAddresses)+len(addresses))
+	for _, address := range params.DevshardEscrowParams.AllowedCreatorAddresses {
+		seen[address] = struct{}{}
+	}
+
+	added := 0
+	for _, address := range addresses {
+		if _, ok := seen[address]; ok {
+			continue
+		}
+		params.DevshardEscrowParams.AllowedCreatorAddresses = append(params.DevshardEscrowParams.AllowedCreatorAddresses, address)
+		seen[address] = struct{}{}
+		added++
+	}
+
+	if err := k.SetParams(ctx, params); err != nil {
+		return err
+	}
+	k.LogInfo("set devshard allowed creator addresses", types.Upgrades,
+		"total", len(params.DevshardEscrowParams.AllowedCreatorAddresses),
+		"added", added)
+	return nil
+}
+
+func seedDelegationRewardSnapshotForEffectiveEpoch(ctx context.Context, k keeper.Keeper) error {
+	effectiveEpochIndex, found := k.GetEffectiveEpochIndex(ctx)
+	if !found {
+		k.LogError("seed delegation reward snapshot skipped: effective epoch not found", types.Upgrades)
+		return nil
+	}
+
+	snapshot, snapshotFound := k.GetDelegationRewardTransferSnapshot(ctx)
+	if snapshotFound {
+		if snapshot.EpochIndex != effectiveEpochIndex {
+			k.LogWarn("existing delegation reward snapshot epoch differs from effective epoch", types.Upgrades,
+				"snapshot_epoch", snapshot.EpochIndex, "effective_epoch", effectiveEpochIndex)
+		}
+		return nil
+	}
+
+	if err := k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: effectiveEpochIndex,
+	}); err != nil {
+		return err
+	}
+
+	k.LogInfo("seeded delegation reward snapshot for effective epoch", types.Upgrades, "epoch", effectiveEpochIndex)
+	return nil
+}
+
+// initMaintenanceParams initializes the MaintenanceParams sub-struct with defaults.
+// The feature starts disabled; governance can enable it once the network is ready.
+// No per-participant state initialization is needed because:
+//   - MaintenanceState is lazily created via GetOrCreateMaintenanceState
+//   - Credit starts at zero (the default for a missing entry)
+//   - Maintenance collections (reservations, transitions, indexes) start empty
+//
+// This is the seeding step from the maintenance-windows PR (#998), relocated
+// from the v0.2.12 handler: mainnet executed that upgrade before the feature
+// landed, so it could never run there. Two deliberate deviations from the
+// original: errors are returned instead of logged-and-swallowed (matching the
+// other v0.2.14 migrations, so a failed SetParams halts the upgrade), and
+// existing non-nil params short-circuit without a redundant SetParams
+// round-trip.
+func initMaintenanceParams(ctx context.Context, k keeper.Keeper) error {
+	params, err := k.GetParams(ctx)
+	if err != nil {
+		return err
+	}
+	if params.MaintenanceParams != nil {
+		k.LogInfo("maintenance params already present, skipping init", types.Upgrades,
+			"maintenance_enabled", params.MaintenanceParams.MaintenanceEnabled)
+		return nil
+	}
+
+	params.MaintenanceParams = types.DefaultMaintenanceParams()
+	if err := k.SetParams(ctx, params); err != nil {
+		return err
+	}
+
+	k.LogInfo("initialized maintenance params", types.Upgrades,
+		"maintenance_enabled", params.MaintenanceParams.MaintenanceEnabled,
+		"min_schedule_lead_blocks", params.MaintenanceParams.MaintenanceMinScheduleLeadBlocks,
+		"max_window_blocks", params.MaintenanceParams.MaintenanceMaxWindowBlocks,
+		"max_concurrent_validators", params.MaintenanceParams.MaintenanceMaxConcurrentValidators,
+		"max_concurrent_power_bps", params.MaintenanceParams.MaintenanceMaxConcurrentPowerBps,
+		"credit_cap_blocks", params.MaintenanceParams.MaintenanceCreditCapBlocks,
+		"credit_earn_per_epoch_blocks", params.MaintenanceParams.MaintenanceCreditEarnPerSuccessfulEpochBlocks,
+	)
+	return nil
+}
+
 // backfillDevshardEscrowParamDefaults seeds zero-valued DevshardEscrowParams
 // fields introduced in v0.2.13. Fresh genesis chains get these from defaults;
 // mainnet chains that upgraded to v0.2.13 without this migration decode them as
@@ -215,3 +439,57 @@ func backfillDevshardEscrowInferenceSealGrace(ctx context.Context, k keeper.Keep
 	)
 	return nil
 }
+
+// updateGenesisTransferParams updates the genesistransfer parameters to enable the whitelist of founders.
+func updateGenesisTransferParams(ctx context.Context, gtKeeper genesistransferkeeper.Keeper) error {
+	allowedAccounts := []string{
+		"gonka18299ldv2cym0gh5spmm6yncv3at3qgn0t7km5w",
+		"gonka16fdw9ve0xj5yy42asg85wgykr4y4kw2l37rkfp",
+		"gonka1dtvqtnq6fjvetajs25kuc9f3944fctveuukxpx",
+		"gonka1k4rnc2e9upscac85tkjwa43wr6kqpfyqcmdwej",
+		"gonka1s7jy6fajstlxzhtxgqmdh4a2cgq26uxcu7jptk",
+		"gonka1rusnaafgmk0h464fthswch3pzh0zzpsegrda09",
+		"gonka12tz8qs5kxjp6qsdgj2u3rzx009z2qf6hjrwrrl",
+		"gonka1n7ph0qezwcr666kp6tesylw4eqnyqwd0g76u7d",
+		"gonka1ld2e89rhfmdlke69m444jcd99h7fra4whksdk4",
+		"gonka1a0rh2dej6lrnj5zkx005f5jrxem0tpdh4cpcmg",
+		"gonka18qmj244rxzt3274357jd2mp45tv8n4508g29r8",
+		"gonka1v86vj8e8eqd3gk5zlf9zawrg0w7c7tfa7x9k25",
+		"gonka108eh38a2pelplqz2lh3ujjnvk7ucdylql6gfmg",
+		"gonka1cpxpnskkf6hlpldu76tya7d53rklnjlqu4uars",
+		"gonka17u7kemct38fx3cuj2yh0x5j2fd9zxkuwkes6q7",
+		"gonka1th0qvf05sqdd09p9rgq69nlchw5xzpc3ddply8",
+		"gonka1pq9r54md9zrd9xqyxx9f3h7as9kfgnp2c0ucat",
+		"gonka1gvx5swzrur89kg5r0z5jn9a0krvmhvzx3f2fea",
+		"gonka1x29n95z989ycxymqw60w56dpz7kcdxpp8w8y6x",
+		"gonka1327uf364ql39e63fax5n8t8y5e8lag4xjl7e49",
+		"gonka1tyfdmaulndss4wqpxr24e8reytj03aw338sphz",
+		"gonka1akmamql0z9vnd48tfw3d75zexu3dswqcawtnxa",
+		"gonka13t3cvaeke9z5vlwps3z7eyp9uj98z2xkt02352",
+		"gonka19cw7kkrkdcxkxmkz56hjatfwrunn79fsyvfky5",
+		"gonka1689695npe7amwyunaaj9dwz58v8n7cgkw5emn4",
+		"gonka1fxls283es0m7cymxky9xuml9x74flfjhkfrz4q",
+		"gonka179nv57lqeana9nvgeul8twegj58ccrd2hm5uzc",
+		"gonka1ucl3pfq6sy9ggxuxahvjhm52hgl3qu4wg46hsk",
+		"gonka1jle7z5mmfczkvy76gvsxud6kjryzhr8c3cpyal",
+		"gonka1xn25n0hphw8tkfg6r3hjvh8d6nerpzqjpql3nx",
+		"gonka1z5a69mz9gzhphf4eu6yznzru2la0em89xutepm",
+		"gonka1lrwu2czkxwaadqnvsttfa5uvc6mshv8wjd3wyz",
+		"gonka1469wnu47q925a4ekazp09tx9k5phyj2nv67jv3",
+		"gonka1h78hmsvknwp86qzu9xftv9znwga7u0sjghmz20",
+		"gonka1qm66c5gqyew27nefdknspf2x5nwvetsk80zvay",
+		"gonka1qgstmj6k2xwx5p8s2p0ch2qd32lkgegqkcsljs",
+		"gonka1g02qwpgju9xu8lwtqpgrzfqrj7x45tnnhgh3xz",
+		"gonka1clvs7fyag6zjkpnvapjj6m0jn38mgsn63tdnhc",
+		"gonka18weyd0tlmtvnn47c0fqg0p8jj3q6s2hz3w67nc",
+		"gonka1l4z4swg3e0pf937qm08u0cnkszss34kpe32y52",
+		"gonka10k4rmsg3e9xrmm2my9dp6lal4nxlenck9uur39",
+		"gonka1vthfz8j7gkeu04jx2ju6akcyv6s9apc497x2e3",
+		"gonka19xcrqllduyr6ur3l5ldln4qj0jfpaqfx20280q",
+	}
+	params := genesistransfertypes.Params{
+		AllowedAccounts: allowedAccounts,
+		RestrictToList:  true,
+	}
+	return gtKeeper.SetParams(ctx, params)
+}
diff --git a/inference-chain/app/upgrades/v0_2_14/upgrades_test.go b/inference-chain/app/upgrades/v0_2_14/upgrades_test.go
index fb31047b95..e78bcd9e91 100644
--- a/inference-chain/app/upgrades/v0_2_14/upgrades_test.go
+++ b/inference-chain/app/upgrades/v0_2_14/upgrades_test.go
@@ -3,15 +3,76 @@ package v0_2_14
 import (
 	"testing"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	keepertest "github.com/productscience/inference/testutil/keeper"
 	inferencetypes "github.com/productscience/inference/x/inference/types"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 )
 
+// TestUpgradeName pins the future on-chain proposal name. The governance
+// proposal and UpgradeName must stay identical or the handler will not run.
 func TestUpgradeName(t *testing.T) {
 	require.Equal(t, "v0.2.14", UpgradeName)
 }
 
+func TestBurnFeeCollectorBalance(t *testing.T) {
+	k, ctx, mocks := keepertest.InferenceKeeperReturningMocks(t)
+
+	burnCoins := sdk.NewCoins(sdk.NewInt64Coin(inferencetypes.BaseCoin, 12_345))
+	balance := sdk.NewCoins(
+		sdk.NewInt64Coin(inferencetypes.BaseCoin, 12_345),
+		sdk.NewInt64Coin("uusdc", 99),
+	)
+	feeCollectorAddress := authtypes.NewModuleAddress(authtypes.FeeCollectorName)
+	const memo = "v0.2.14: burn erroneously minted inflation"
+
+	mocks.BankViewKeeper.EXPECT().
+		GetAllBalances(gomock.Any(), feeCollectorAddress).
+		Return(balance)
+	mocks.BankKeeper.EXPECT().
+		SendCoinsFromModuleToModule(gomock.Any(), authtypes.FeeCollectorName, inferencetypes.ModuleName, burnCoins, memo).
+		Return(nil)
+	mocks.BankKeeper.EXPECT().
+		BurnCoins(gomock.Any(), inferencetypes.ModuleName, burnCoins, memo).
+		Return(nil)
+
+	require.NoError(t, burnFeeCollectorBalance(ctx, k))
+}
+
+func TestBurnFeeCollectorBalance_NoBaseDenomBalanceIsNoOp(t *testing.T) {
+	k, ctx, mocks := keepertest.InferenceKeeperReturningMocks(t)
+
+	feeCollectorAddress := authtypes.NewModuleAddress(authtypes.FeeCollectorName)
+
+	mocks.BankViewKeeper.EXPECT().
+		GetAllBalances(gomock.Any(), feeCollectorAddress).
+		Return(sdk.NewCoins(sdk.NewInt64Coin("uusdc", 99)))
+
+	require.NoError(t, burnFeeCollectorBalance(ctx, k))
+}
+
+func TestSetDevshardAllowedCreatorAddressesAddsDahl(t *testing.T) {
+	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
+
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	params.DevshardEscrowParams = inferencetypes.DefaultDevshardEscrowParams()
+	params.DevshardEscrowParams.AllowedCreatorAddresses = []string{"gonka1existing"}
+	require.NoError(t, k.SetParams(ctx, params))
+
+	require.NoError(t, setDevshardAllowedCreatorAddresses(ctx, k))
+	require.NoError(t, setDevshardAllowedCreatorAddresses(ctx, k))
+
+	got, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	require.Equal(t, []string{
+		"gonka1existing",
+		"gonka1t9akhsrqjkavh68c7cannlfdj58y25vsewfflt",
+	}, got.DevshardEscrowParams.AllowedCreatorAddresses)
+}
+
 func TestBackfillDevshardEscrowParamDefaults_DefaultInferenceSealGraceNonces(t *testing.T) {
 	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
 
@@ -177,3 +238,113 @@ func TestBackfillDevshardEscrowParamDefaults_PreservesExistingDefaultInferenceSe
 	require.NoError(t, err)
 	require.Equal(t, customGrace, got.DevshardEscrowParams.DefaultInferenceSealGraceNonces)
 }
+
+func TestSeedDelegationRewardSnapshotForEffectiveEpoch(t *testing.T) {
+	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, 7))
+
+	_, found := k.GetDelegationRewardTransferSnapshot(ctx)
+	require.False(t, found)
+
+	require.NoError(t, seedDelegationRewardSnapshotForEffectiveEpoch(ctx, k))
+
+	snapshot, found := k.GetDelegationRewardTransferSnapshot(ctx)
+	require.True(t, found)
+	require.Equal(t, uint64(7), snapshot.EpochIndex)
+	require.Empty(t, snapshot.Transfers)
+	require.Empty(t, snapshot.Penalties)
+}
+
+func TestSeedDelegationRewardSnapshotForEffectiveEpoch_DoesNotOverrideExisting(t *testing.T) {
+	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, 8))
+	require.NoError(t, k.SetDelegationRewardTransferSnapshot(ctx, inferencetypes.DelegationRewardTransferSnapshot{
+		EpochIndex: 8,
+		Transfers: []*inferencetypes.DelegationRewardTransfer{
+			{
+				ModelId: "m",
+				From:    "a",
+				To:      "b",
+				Share:   inferencetypes.DecimalFromFloat(0.1),
+			},
+		},
+		Penalties: []*inferencetypes.DelegationRewardPenalty{
+			{
+				Participant:     "a",
+				PenaltyFraction: inferencetypes.DecimalFromFloat(0.2),
+			},
+		},
+	}))
+
+	require.NoError(t, seedDelegationRewardSnapshotForEffectiveEpoch(ctx, k))
+
+	snapshot, found := k.GetDelegationRewardTransferSnapshot(ctx)
+	require.True(t, found)
+	require.Equal(t, uint64(8), snapshot.EpochIndex)
+	require.Len(t, snapshot.Transfers, 1)
+	require.Len(t, snapshot.Penalties, 1)
+}
+
+// TestInitMaintenanceParams_NilParams simulates mainnet state: the chain
+// upgraded past v0.2.12 before maintenance landed, so MaintenanceParams is
+// nil. The init must install defaults with the feature disabled.
+func TestInitMaintenanceParams_NilParams(t *testing.T) {
+	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
+
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	params.MaintenanceParams = nil
+	require.NoError(t, k.SetParams(ctx, params))
+
+	require.NoError(t, initMaintenanceParams(ctx, k))
+
+	got, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	require.NotNil(t, got.MaintenanceParams)
+	require.False(t, got.MaintenanceParams.MaintenanceEnabled, "maintenance must ship disabled")
+	require.Equal(t, inferencetypes.DefaultMaintenanceParams(), got.MaintenanceParams)
+	require.NoError(t, got.MaintenanceParams.Validate())
+}
+
+// TestInitMaintenanceParams_PreservesExisting ensures chains that
+// already carry deliberate maintenance settings (e.g. testnets with the
+// feature enabled) are not stomped by the upgrade.
+func TestInitMaintenanceParams_PreservesExisting(t *testing.T) {
+	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
+
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	existing := inferencetypes.DefaultMaintenanceParams()
+	existing.MaintenanceEnabled = true
+	existing.MaintenanceMaxWindowBlocks = 999
+	params.MaintenanceParams = existing
+	require.NoError(t, k.SetParams(ctx, params))
+
+	require.NoError(t, initMaintenanceParams(ctx, k))
+
+	got, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	require.NotNil(t, got.MaintenanceParams)
+	require.True(t, got.MaintenanceParams.MaintenanceEnabled)
+	require.Equal(t, uint64(999), got.MaintenanceParams.MaintenanceMaxWindowBlocks)
+}
+
+func TestUpdateGenesisTransferParams(t *testing.T) {
+	gtKeeper, ctx := keepertest.GenesistransferKeeper(t)
+
+	// Ensure initial params are default (whitelist disabled, empty list)
+	initParams, err := gtKeeper.GetParams(ctx)
+	require.NoError(t, err)
+	require.False(t, initParams.RestrictToList)
+	require.Empty(t, initParams.AllowedAccounts)
+
+	// Run the migration function
+	err = updateGenesisTransferParams(ctx, gtKeeper)
+	require.NoError(t, err)
+
+	// Verify params were updated correctly
+	migratedParams, err := gtKeeper.GetParams(ctx)
+	require.NoError(t, err)
+	require.True(t, migratedParams.RestrictToList)
+	require.Len(t, migratedParams.AllowedAccounts, 43)
+}
diff --git a/inference-chain/app/upgrades_enabled.go b/inference-chain/app/upgrades_enabled.go
index c1e4885ac4..3be9b6992f 100644
--- a/inference-chain/app/upgrades_enabled.go
+++ b/inference-chain/app/upgrades_enabled.go
@@ -7,7 +7,10 @@ import (
 )
 
 func (app *App) setupUpgradeHandlers() {
-	app.UpgradeKeeper.SetUpgradeHandler(v2test.UpgradeName, v2test.CreateUpgradeHandler(app.ModuleManager, app.Configurator()))
+	app.setTrackedUpgradeHandler(
+		v2test.UpgradeName,
+		v2test.CreateUpgradeHandler(app.ModuleManager, app.Configurator()),
+	)
 }
 
 func (app *App) registerMigrations() {
diff --git a/inference-chain/cmd/inferenced/cmd/set_seeds.go b/inference-chain/cmd/inferenced/cmd/set_seeds.go
index 6a0ef55739..9208d95102 100644
--- a/inference-chain/cmd/inferenced/cmd/set_seeds.go
+++ b/inference-chain/cmd/inferenced/cmd/set_seeds.go
@@ -3,10 +3,12 @@ package cmd
 import (
 	"fmt"
 	"github.com/productscience/inference/internal/rpc"
+	"net"
 	"github.com/spf13/cobra"
 	"net/url"
 	"os"
 	"regexp"
+	"strings"
 )
 
 func SetSeedCommand() *cobra.Command {
@@ -62,6 +64,17 @@ type urlParseResult struct {
 }
 
 func parseURL(rawURL string) (*urlParseResult, error) {
+	if !strings.Contains(rawURL, "://") {
+		host, port, err := net.SplitHostPort(rawURL)
+		if err != nil {
+			return nil, fmt.Errorf("could not parse host:port %q: %w", rawURL, err)
+		}
+		return &urlParseResult{
+			Host: host,
+			Port: port,
+		}, nil
+	}
+
 	u, err := url.Parse(rawURL)
 	if err != nil {
 		return nil, fmt.Errorf("could not parse URL: %w", err)
@@ -77,6 +90,8 @@ func parseURL(rawURL string) (*urlParseResult, error) {
 			port = "80"
 		case "https":
 			port = "443"
+		case "tcp":
+			return nil, fmt.Errorf("missing port in tcp URL %q", rawURL)
 		default:
 			return nil, fmt.Errorf("unsupported scheme: %q", u.Scheme)
 		}
diff --git a/inference-chain/go.mod b/inference-chain/go.mod
index b447419c9c..e9ef4f847f 100644
--- a/inference-chain/go.mod
+++ b/inference-chain/go.mod
@@ -4,7 +4,7 @@ go 1.24.2
 
 replace (
 	cosmossdk.io/store => github.com/gonka-ai/cosmos-sdk/store v1.1.2-ps1
-	github.com/cosmos/cosmos-sdk => github.com/gonka-ai/cosmos-sdk v0.53.3-ps17-observability
+	github.com/cosmos/cosmos-sdk => github.com/gonka-ai/cosmos-sdk v0.53.3-ps19-observability
 	// fix upstream GHSA-h395-qcrw-5vmq vulnerability.
 	github.com/gin-gonic/gin => github.com/gin-gonic/gin v1.7.0
 	// replace broken goleveldb
diff --git a/inference-chain/go.sum b/inference-chain/go.sum
index 546dd53d63..db12ba8a61 100644
--- a/inference-chain/go.sum
+++ b/inference-chain/go.sum
@@ -790,8 +790,8 @@ github.com/golangci/revgrep v0.5.3 h1:3tL7c1XBMtWHHqVpS5ChmiAAoe4PF/d5+ULzV9sLAz
 github.com/golangci/revgrep v0.5.3/go.mod h1:U4R/s9dlXZsg8uJmaR1GrloUr14D7qDl8gi2iPXJH8k=
 github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed h1:IURFTjxeTfNFP0hTEi1YKjB/ub8zkpaOqFFMApi2EAs=
 github.com/golangci/unconvert v0.0.0-20240309020433-c5143eacb3ed/go.mod h1:XLXN8bNw4CGRPaqgl3bv/lhz7bsGPh4/xSaMTbo2vkQ=
-github.com/gonka-ai/cosmos-sdk v0.53.3-ps17-observability h1:vWph4b1Xzvwj9jV3BVD6RXQLqRmCsGNyPAxePlFIU0Q=
-github.com/gonka-ai/cosmos-sdk v0.53.3-ps17-observability/go.mod h1:90S054hIbadFB1MlXVZVC5w0QbKfd1P4b79zT+vvJxw=
+github.com/gonka-ai/cosmos-sdk v0.53.3-ps19-observability h1:jzgFsresYGzIbtF/Ov69GxFQ7NHG42R0bP6nMNdzoQU=
+github.com/gonka-ai/cosmos-sdk v0.53.3-ps19-observability/go.mod h1:90S054hIbadFB1MlXVZVC5w0QbKfd1P4b79zT+vvJxw=
 github.com/gonka-ai/cosmos-sdk/store v1.1.2-ps1 h1:8kmYjdJ9ht+o+0GnJywdf2JounFAWOZZ5xZSrJ6ntFk=
 github.com/gonka-ai/cosmos-sdk/store v1.1.2-ps1/go.mod h1:7a15p+QsM5UXf7VMhO3ylmqj85k9UBN/h1kwMcLiffA=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
diff --git a/inference-chain/proto/inference/bls/tx.proto b/inference-chain/proto/inference/bls/tx.proto
index 4792cba8c8..8eb558ceee 100644
--- a/inference-chain/proto/inference/bls/tx.proto
+++ b/inference-chain/proto/inference/bls/tx.proto
@@ -34,7 +34,9 @@ service Msg {
   rpc SubmitPartialSignature(MsgSubmitPartialSignature) returns (MsgSubmitPartialSignatureResponse);
   
   // RequestThresholdSignature allows external users to request a threshold signature
-  rpc RequestThresholdSignature(MsgRequestThresholdSignature) returns (MsgRequestThresholdSignatureResponse);
+  rpc RequestThresholdSignature(MsgRequestThresholdSignature) returns (MsgRequestThresholdSignatureResponse) {
+    option deprecated = true;
+  }
 }
 
 // MsgUpdateParams is the Msg/UpdateParams request type.
@@ -208,6 +210,7 @@ message MsgSubmitPartialSignatureResponse {}
 message MsgRequestThresholdSignature {
   option (cosmos.msg.v1.signer) = "creator";
   option (amino.name)           = "inference/x/bls/MsgRequestThresholdSignature";
+  option deprecated = true;
 
   // creator is the address of the user requesting the threshold signature
   string creator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
@@ -228,6 +231,8 @@ message MsgRequestThresholdSignature {
 // MsgRequestThresholdSignatureResponse defines the response structure for executing a
 // MsgRequestThresholdSignature message.
 message MsgRequestThresholdSignatureResponse {
+  option deprecated = true;
+
   // derived_request_id is the actual request ID used for KVStore lookups, derived as keccak256(creator || request_id)
   bytes derived_request_id = 1;
 }
\ No newline at end of file
diff --git a/inference-chain/proto/inference/inference/claim_recipient.proto b/inference-chain/proto/inference/inference/claim_recipient.proto
new file mode 100644
index 0000000000..510147e2a3
--- /dev/null
+++ b/inference-chain/proto/inference/inference/claim_recipient.proto
@@ -0,0 +1,12 @@
+syntax = "proto3";
+package inference.inference;
+
+option go_package = "github.com/productscience/inference/x/inference/types";
+
+// ClaimRecipientEntry specifies, for a given epoch, where the participant's
+// claim rewards must be sent. An empty recipient removes the override (revert
+// to the participant's own creator address).
+message ClaimRecipientEntry {
+  uint64 epoch     = 1;
+  string recipient = 2;
+}
diff --git a/inference-chain/proto/inference/inference/devshard_escrow.proto b/inference-chain/proto/inference/inference/devshard_escrow.proto
index 5fc3f442a2..48b29c749a 100644
--- a/inference-chain/proto/inference/inference/devshard_escrow.proto
+++ b/inference-chain/proto/inference/inference/devshard_escrow.proto
@@ -19,6 +19,9 @@ message DevshardEscrow {
   uint32 inference_seal_grace_nonces = 12;
   uint32 inference_seal_grace_seconds = 13;
   uint32 auto_seal_every_n_nonces = 14;
+  // Snapshotted from DevshardEscrowParams at create (lane A). Zero on legacy
+  // rows means "unset"; clients fall back to DefaultDevshardValidationRate.
+  uint32 validation_rate = 15;
 }
 
 message DevshardHostEpochStats {
diff --git a/inference-chain/proto/inference/inference/maintenance.proto b/inference-chain/proto/inference/inference/maintenance.proto
new file mode 100644
index 0000000000..87c95bcbe7
--- /dev/null
+++ b/inference-chain/proto/inference/inference/maintenance.proto
@@ -0,0 +1,57 @@
+syntax = "proto3";
+
+package inference.inference;
+
+option go_package = "github.com/productscience/inference/x/inference/types";
+
+// MaintenanceReservationStatus represents the lifecycle status of a maintenance reservation.
+enum MaintenanceReservationStatus {
+  MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED = 0;
+  MAINTENANCE_RESERVATION_STATUS_SCHEDULED   = 1;
+  MAINTENANCE_RESERVATION_STATUS_ACTIVE      = 2;
+  MAINTENANCE_RESERVATION_STATUS_COMPLETED   = 3;
+  MAINTENANCE_RESERVATION_STATUS_CANCELED    = 4;
+}
+
+// MaintenanceTransitionType represents the type of lifecycle transition at a given block height.
+enum MaintenanceTransitionType {
+  MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED = 0;
+  MAINTENANCE_TRANSITION_TYPE_ACTIVATE   = 1;
+  MAINTENANCE_TRANSITION_TYPE_COMPLETE   = 2;
+}
+
+// MaintenanceReservation represents a scheduled maintenance window for a participant.
+message MaintenanceReservation {
+  uint64 reservation_id = 1;
+  string participant     = 2;
+  int64  start_height    = 3;
+  uint64 duration_blocks = 4;
+  string created_by      = 5;
+  MaintenanceReservationStatus status = 6;
+  string activation_warning = 7;
+}
+
+// MaintenanceState holds per-participant maintenance metadata, keyed by participant address.
+message MaintenanceState {
+  string participant                = 1;
+  uint64 credit_blocks              = 2;
+  // Earliest epoch covered by the most recent maintenance window (set on
+  // activation). Combined with last_maintenance_end_epoch, defines the
+  // [start, end] range of epochs in which credit accrual is suppressed
+  // for the participant's most recent window.
+  uint64 last_maintenance_epoch     = 3;
+  uint64 active_reservation_id      = 4;
+  uint64 scheduled_reservation_id   = 5;
+  // Latest epoch covered by the most recent maintenance window. Set on
+  // completion (BeginBlock) to the epoch in which the window's last block
+  // fell. While the window is still active, this stays at the activation
+  // epoch and the active_reservation_id check covers the in-progress epochs.
+  uint64 last_maintenance_end_epoch = 6;
+}
+
+// MaintenanceTransition is an entry in the exact-height transition schedule for BeginBlock processing.
+message MaintenanceTransition {
+  int64  block_height               = 1;
+  uint64 reservation_id             = 2;
+  MaintenanceTransitionType type    = 3;
+}
diff --git a/inference-chain/proto/inference/inference/params.proto b/inference-chain/proto/inference/inference/params.proto
index 3b8b7829c4..4e2295df98 100644
--- a/inference-chain/proto/inference/inference/params.proto
+++ b/inference-chain/proto/inference/inference/params.proto
@@ -27,7 +27,38 @@ message Params {
   DevshardEscrowParams devshard_escrow_params = 14;
   reserved "subnet_escrow_params";
   FeeParams fee_params = 15;
+  // Field numbers 16 and 17 are wire-format-locked to match the upstream
+  // multi-model branch (which shipped delegation_params=16 first). Renumbering
+  // would silently lose DelegationParams from any chain that already stored
+  // params under field 16.
   DelegationParams delegation_params = 16;
+  MaintenanceParams maintenance_params = 17;
+}
+
+// MaintenanceParams defines the governance-controlled parameters for participant maintenance windows.
+message MaintenanceParams {
+  option (gogoproto.equal) = true;
+
+  // maintenance_enabled enables or disables scheduling and activation of maintenance windows.
+  bool maintenance_enabled = 1;
+
+  // maintenance_min_schedule_lead_blocks is the minimum number of blocks between scheduling and start.
+  uint64 maintenance_min_schedule_lead_blocks = 2;
+
+  // maintenance_max_window_blocks is the maximum duration of a single maintenance window.
+  uint64 maintenance_max_window_blocks = 3;
+
+  // maintenance_max_concurrent_validators is the maximum number of participants concurrently in maintenance.
+  uint32 maintenance_max_concurrent_validators = 4;
+
+  // maintenance_max_concurrent_power_bps is the maximum consensus power concurrently in maintenance (basis points).
+  uint32 maintenance_max_concurrent_power_bps = 5;
+
+  // maintenance_credit_cap_blocks is the maximum maintenance credit a participant may accumulate.
+  uint64 maintenance_credit_cap_blocks = 6;
+
+  // maintenance_credit_earn_per_successful_epoch_blocks is the number of credit blocks earned per successful epoch.
+  uint64 maintenance_credit_earn_per_successful_epoch_blocks = 7;
 }
 
 message GenesisOnlyParams {
diff --git a/inference-chain/proto/inference/inference/poc_delegation.proto b/inference-chain/proto/inference/inference/poc_delegation.proto
index 8b81601370..19c8356425 100644
--- a/inference-chain/proto/inference/inference/poc_delegation.proto
+++ b/inference-chain/proto/inference/inference/poc_delegation.proto
@@ -4,6 +4,7 @@ package inference.inference;
 
 import "cosmos/msg/v1/msg.proto";
 import "cosmos_proto/cosmos.proto";
+import "inference/inference/params.proto";
 
 option go_package = "github.com/productscience/inference/x/inference/types";
 
@@ -61,6 +62,24 @@ message BootstrapDelegationSnapshot {
   repeated BootstrapModelPreEligibility preeligibility = 5;
 }
 
+message DelegationRewardTransfer {
+  string model_id = 1;
+  string from = 2;
+  string to = 3;
+  Decimal share = 4;
+}
+
+message DelegationRewardPenalty {
+  string participant = 1;
+  Decimal penalty_fraction = 2;
+}
+
+message DelegationRewardTransferSnapshot {
+  uint64 epoch_index = 1;
+  repeated DelegationRewardTransfer transfers = 2;
+  repeated DelegationRewardPenalty penalties = 3;
+}
+
 // --- Transaction messages ---
 
 message MsgSetPoCDelegation {
diff --git a/inference-chain/proto/inference/inference/pruning_state.proto b/inference-chain/proto/inference/inference/pruning_state.proto
index 9c40da80b7..3b7cfa9ff3 100644
--- a/inference-chain/proto/inference/inference/pruning_state.proto
+++ b/inference-chain/proto/inference/inference/pruning_state.proto
@@ -14,4 +14,5 @@ message PruningState {
   int64 mlnode_weight_distributions_pruned_epoch = 7;
   int64 poc_validations_v2_pruned_epoch = 8;
   int64 poc_validation_snapshots_pruned_epoch = 9;
+  int64 claim_recipients_pruned_epoch = 10;
 }
diff --git a/inference-chain/proto/inference/inference/query.proto b/inference-chain/proto/inference/inference/query.proto
index 6bff866dee..b181371962 100644
--- a/inference-chain/proto/inference/inference/query.proto
+++ b/inference-chain/proto/inference/inference/query.proto
@@ -33,8 +33,10 @@ import "inference/inference/poc_v2.proto";
 import "inference/inference/random_seed.proto";
 import "inference/inference/poc_validation_snapshot.proto";
 import "inference/inference/devshard_escrow.proto";
+import "inference/inference/maintenance.proto";
 import "inference/inference/preserved_nodes_snapshot.proto";
 import "inference/inference/poc_delegation.proto";
+import "inference/inference/claim_recipient.proto";
 
 option go_package = "github.com/productscience/inference/x/inference/types";
 
@@ -97,6 +99,10 @@ service Query {
   rpc SettleAmountAll (QueryAllSettleAmountRequest) returns (QueryAllSettleAmountResponse) {
     option (google.api.http).get = "/productscience/inference/inference/settle_amount";
 
+  }
+  rpc EstimateBitcoinReward (QueryEstimateBitcoinRewardRequest) returns (QueryEstimateBitcoinRewardResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/estimate_bitcoin_reward/{participant}";
+
   }
 
   // Queries a list of EpochGroupValidations items.
@@ -389,6 +395,12 @@ service Query {
 
   }
 
+  // Queries the most recent applied upgrade height.
+  rpc LastUpgradeHeight (QueryGetLastUpgradeHeightRequest) returns (QueryGetLastUpgradeHeightResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/last_upgrade_height";
+
+  }
+
   // Queries the participant allowlist.
   rpc ParticipantAllowList (QueryParticipantAllowListRequest) returns (QueryParticipantAllowListResponse) {
     option (google.api.http).get = "/productscience/inference/inference/participant_allow_list";
@@ -442,6 +454,41 @@ service Query {
   rpc PoCDelegation (QueryPoCDelegationRequest) returns (QueryPoCDelegationResponse) {
     option (google.api.http).get = "/productscience/inference/inference/poc_delegation/{participant}";
   }
+
+  // Queries the maintenance credit balance for a participant.
+  rpc MaintenanceCredit (QueryMaintenanceCreditRequest) returns (QueryMaintenanceCreditResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/maintenance_credit/{participant}";
+  }
+
+  // Queries scheduled maintenance windows for a participant.
+  rpc MaintenanceScheduled (QueryMaintenanceScheduledRequest) returns (QueryMaintenanceScheduledResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/maintenance_scheduled/{participant}";
+  }
+
+  // Queries all currently active maintenance windows.
+  rpc MaintenanceActive (QueryMaintenanceActiveRequest) returns (QueryMaintenanceActiveResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/maintenance_active";
+  }
+
+  // Queries the full maintenance status for a participant at the current height.
+  rpc MaintenanceStatus (QueryMaintenanceStatusRequest) returns (QueryMaintenanceStatusResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/maintenance_status/{participant}";
+  }
+
+  // Queries the concurrent reserved participant count and power at a given height.
+  rpc MaintenanceConcurrency (QueryMaintenanceConcurrencyRequest) returns (QueryMaintenanceConcurrencyResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/maintenance_concurrency/{height}";
+  }
+
+  // Queries whether a proposed maintenance window is schedulable.
+  rpc MaintenanceSchedulability (QueryMaintenanceSchedulabilityRequest) returns (QueryMaintenanceSchedulabilityResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/maintenance_schedulability/{participant}/{start_height}/{duration_blocks}";
+  }
+
+  // Lists the scheduled per-epoch claim recipient overrides for a participant.
+  rpc ListClaimRecipients (QueryListClaimRecipientsRequest) returns (QueryListClaimRecipientsResponse) {
+    option (google.api.http).get = "/productscience/inference/inference/list_claim_recipients/{participant}";
+  }
 }
 // QueryParamsRequest is request type for the Query/Params RPC method.
 message QueryParamsRequest {}
@@ -541,6 +588,14 @@ message QueryAllSettleAmountResponse {
            cosmos.base.query.v1beta1.PageResponse pagination    = 2;
 }
 
+message QueryEstimateBitcoinRewardRequest {
+  string participant = 1;
+}
+
+message QueryEstimateBitcoinRewardResponse {
+  SettleAmount settle_amount = 1 [(gogoproto.nullable) = false];
+}
+
 message QueryGetEpochGroupValidationsRequest {
   string participant = 1;
   uint64 epoch_index = 2;
@@ -663,7 +718,6 @@ message MLNodeWeightDistributionWithAddress {
 
 message QueryGetCurrentEpochRequest {}
 
-// DEPRECATED: ambiguous query, re-check what it expect as epoch: id, poc_start_block_height, or epoch_group_id
 message QueryGetCurrentEpochResponse {
   uint64 epoch = 1;
 }
@@ -1095,6 +1149,13 @@ message QueryGetMLNodeVersionResponse {
   MLNodeVersion mlnode_version = 1 [(gogoproto.nullable) = false];
 }
 
+message QueryGetLastUpgradeHeightRequest {}
+
+message QueryGetLastUpgradeHeightResponse {
+  int64 last_upgrade_height = 1;
+  bool  found               = 2;
+}
+
 // QueryExcludedParticipantsRequest requests excluded participants for an epoch.
 // If epoch_index is 0, the query should return for the current effective epoch.
 message QueryExcludedParticipantsRequest {
@@ -1187,3 +1248,68 @@ message QueryGetDevshardHostEpochStatsResponse {
   DevshardHostEpochStats stats = 1;
   bool found = 2;
 }
+
+// Maintenance query messages
+
+message QueryMaintenanceCreditRequest {
+  string participant = 1;
+}
+
+message QueryMaintenanceCreditResponse {
+  uint64 credit_blocks = 1;
+  bool   found         = 2;
+}
+
+message QueryMaintenanceScheduledRequest {
+  string participant = 1;
+}
+
+message QueryMaintenanceScheduledResponse {
+  MaintenanceReservation reservation = 1;
+  bool found = 2;
+}
+
+message QueryMaintenanceActiveRequest {}
+
+message QueryMaintenanceActiveResponse {
+  repeated MaintenanceReservation reservations = 1;
+}
+
+message QueryMaintenanceStatusRequest {
+  string participant = 1;
+}
+
+message QueryMaintenanceStatusResponse {
+  MaintenanceState state = 1;
+  MaintenanceReservation active_reservation    = 2;
+  MaintenanceReservation scheduled_reservation = 3;
+  bool found = 4;
+}
+
+message QueryMaintenanceConcurrencyRequest {
+  int64 height = 1;
+}
+
+message QueryMaintenanceConcurrencyResponse {
+  uint32 concurrent_count     = 1;
+  int64  concurrent_power_bps = 2;
+}
+
+message QueryMaintenanceSchedulabilityRequest {
+  string participant     = 1;
+  int64  start_height    = 2;
+  uint64 duration_blocks = 3;
+}
+
+message QueryMaintenanceSchedulabilityResponse {
+  bool   schedulable        = 1;
+  string rejection_reason   = 2;
+}
+
+message QueryListClaimRecipientsRequest {
+  string participant = 1;
+}
+
+message QueryListClaimRecipientsResponse {
+  repeated ClaimRecipientEntry entries = 1 [(gogoproto.nullable) = false];
+}
diff --git a/inference-chain/proto/inference/inference/tx.proto b/inference-chain/proto/inference/inference/tx.proto
index 31979f98e7..c61ea01241 100644
--- a/inference-chain/proto/inference/inference/tx.proto
+++ b/inference-chain/proto/inference/inference/tx.proto
@@ -12,7 +12,9 @@ import "inference/inference/hardware_node.proto";
 import "inference/inference/bridge.proto";
 import "inference/inference/poc_v2.proto";
 import "inference/inference/devshard_escrow.proto";
+import "inference/inference/maintenance.proto";
 import "inference/inference/poc_delegation.proto";
+import "inference/inference/claim_recipient.proto";
 
 option go_package = "github.com/productscience/inference/x/inference/types";
 
@@ -23,14 +25,25 @@ service Msg {
   // UpdateParams defines a (governance) operation for updating the module
   // parameters. The authority defaults to the x/gov module account.
   rpc UpdateParams                     (MsgUpdateParams) returns (MsgUpdateParamsResponse);
-  rpc StartInference                   (MsgStartInference) returns (MsgStartInferenceResponse);
-  rpc FinishInference                  (MsgFinishInference) returns (MsgFinishInferenceResponse);
+  rpc StartInference                   (MsgStartInference) returns (MsgStartInferenceResponse) {
+    option deprecated = true;
+  }
+  rpc FinishInference                  (MsgFinishInference) returns (MsgFinishInferenceResponse) {
+    option deprecated = true;
+  }
   rpc SubmitNewParticipant             (MsgSubmitNewParticipant) returns (MsgSubmitNewParticipantResponse);
-  rpc Validation                       (MsgValidation) returns (MsgValidationResponse);
+  rpc Validation                       (MsgValidation) returns (MsgValidationResponse) {
+    option deprecated = true;
+  }
   rpc SubmitNewUnfundedParticipant     (MsgSubmitNewUnfundedParticipant) returns (MsgSubmitNewUnfundedParticipantResponse);
-  rpc InvalidateInference              (MsgInvalidateInference) returns (MsgInvalidateInferenceResponse);
-  rpc RevalidateInference              (MsgRevalidateInference) returns (MsgRevalidateInferenceResponse);
+  rpc InvalidateInference              (MsgInvalidateInference) returns (MsgInvalidateInferenceResponse) {
+    option deprecated = true;
+  }
+  rpc RevalidateInference              (MsgRevalidateInference) returns (MsgRevalidateInferenceResponse) {
+    option deprecated = true;
+  }
   rpc ClaimRewards                     (MsgClaimRewards) returns (MsgClaimRewardsResponse);
+  rpc SetClaimRecipients               (MsgSetClaimRecipients) returns (MsgSetClaimRecipientsResponse);
   rpc SubmitPocBatch                   (MsgSubmitPocBatch) returns (MsgSubmitPocBatchResponse);
   // PoC v2 validation messages
   rpc SubmitPocValidationsV2           (MsgSubmitPocValidationsV2) returns (MsgSubmitPocValidationsV2Response);
@@ -61,6 +74,8 @@ service Msg {
   rpc CreateDevshardEscrow             (MsgCreateDevshardEscrow) returns (MsgCreateDevshardEscrowResponse);
   rpc SettleDevshardEscrow             (MsgSettleDevshardEscrow) returns (MsgSettleDevshardEscrowResponse);
   rpc SetDevshardRequestsEnabled       (MsgSetDevshardRequestsEnabled) returns (MsgSetDevshardRequestsEnabledResponse);
+  rpc ScheduleMaintenance              (MsgScheduleMaintenance) returns (MsgScheduleMaintenanceResponse);
+  rpc CancelMaintenance                (MsgCancelMaintenance) returns (MsgCancelMaintenanceResponse);
   rpc SetPoCDelegation                 (MsgSetPoCDelegation) returns (MsgSetPoCDelegationResponse);
   rpc RefusePoCDelegation              (MsgRefusePoCDelegation) returns (MsgRefusePoCDelegationResponse);
   rpc DeclarePoCIntent                 (MsgDeclarePoCIntent) returns (MsgDeclarePoCIntentResponse);
@@ -85,6 +100,7 @@ message MsgUpdateParamsResponse {}
 
 message MsgStartInference {
   option (cosmos.msg.v1.signer) = "creator";
+  option deprecated = true;
   string creator = 1;
   string inference_id = 2;
   string prompt_hash = 3;
@@ -102,12 +118,14 @@ message MsgStartInference {
 }
 
 message MsgStartInferenceResponse {
+  option deprecated = true;
   string inference_index = 1;
   string error_message = 2;
 }
 
 message MsgFinishInference {
   option (cosmos.msg.v1.signer) = "creator";
+  option deprecated = true;
   string creator = 1;
   string inference_id = 2;
   string response_hash = 3;
@@ -127,6 +145,7 @@ message MsgFinishInference {
 }
 
 message MsgFinishInferenceResponse {
+  option deprecated = true;
   string inference_index = 1;
   string error_message = 2;
 }
@@ -146,6 +165,7 @@ message MsgSubmitNewParticipantResponse {
 
 message MsgValidation {
   option (cosmos.msg.v1.signer) = "creator";
+  option deprecated = true;
   string creator = 1;
   string id = 2;
   string inference_id = 3;
@@ -156,7 +176,9 @@ message MsgValidation {
   Decimal value_decimal = 8;
 }
 
-message MsgValidationResponse {}
+message MsgValidationResponse {
+  option deprecated = true;
+}
 
 message MsgSubmitNewUnfundedParticipant {
   option (cosmos.msg.v1.signer) = "creator";
@@ -172,21 +194,27 @@ message MsgSubmitNewUnfundedParticipantResponse {}
 
 message MsgInvalidateInference {
   option (cosmos.msg.v1.signer) = "creator";
+  option deprecated = true;
   string creator = 1;
   string inference_id = 2;
   string invalidator = 3;
 }
 
-message MsgInvalidateInferenceResponse {}
+message MsgInvalidateInferenceResponse {
+  option deprecated = true;
+}
 
 message MsgRevalidateInference {
   option (cosmos.msg.v1.signer) = "creator";
+  option deprecated = true;
   string creator = 1;
   string inference_id = 2;
   string invalidator = 3;
 }
 
-message MsgRevalidateInferenceResponse {}
+message MsgRevalidateInferenceResponse {
+  option deprecated = true;
+}
 
 message MsgClaimRewards {
   option (cosmos.msg.v1.signer) = "creator";
@@ -200,6 +228,18 @@ message MsgClaimRewardsResponse {
   string result = 2;
 }
 
+// MsgSetClaimRecipients lets the account owner (cold key) batch-configure
+// per-epoch recipient overrides for MsgClaimRewards. Must be signed by the
+// participant's own key; it is intentionally NOT granted to warm keys via
+// authz, so an operational key cannot redirect rewards.
+message MsgSetClaimRecipients {
+  option (cosmos.msg.v1.signer) = "creator";
+  string                       creator = 1;
+  repeated ClaimRecipientEntry entries = 2 [(gogoproto.nullable) = false];
+}
+
+message MsgSetClaimRecipientsResponse {}
+
 message MsgSubmitPocBatch {
   option (cosmos.msg.v1.signer) = "creator";
   string creator = 1;
@@ -514,3 +554,25 @@ message MsgSetDevshardRequestsEnabled {
 }
 
 message MsgSetDevshardRequestsEnabledResponse {}
+
+// MsgScheduleMaintenance schedules a maintenance window for a participant.
+message MsgScheduleMaintenance {
+  option (cosmos.msg.v1.signer) = "creator";
+  string creator       = 1;
+  string participant   = 2;
+  int64  start_height  = 3;
+  uint64 duration_blocks = 4;
+}
+
+message MsgScheduleMaintenanceResponse {
+  uint64 reservation_id = 1;
+}
+
+// MsgCancelMaintenance cancels a not-yet-active maintenance reservation.
+message MsgCancelMaintenance {
+  option (cosmos.msg.v1.signer) = "creator";
+  string creator        = 1;
+  uint64 reservation_id = 2;
+}
+
+message MsgCancelMaintenanceResponse {}
diff --git a/inference-chain/test_genesis_overrides.json b/inference-chain/test_genesis_overrides.json
index 74aa5bbd2e..2723dd425a 100644
--- a/inference-chain/test_genesis_overrides.json
+++ b/inference-chain/test_genesis_overrides.json
@@ -70,6 +70,15 @@
           "v_min": "0",
           "cap_factor": { "value": "1", "exponent": 0 },
           "initial_model_id": "Qwen/Qwen2.5-7B-Instruct"
+        },
+        "maintenance_params": {
+          "maintenance_enabled": true,
+          "maintenance_min_schedule_lead_blocks": "2",
+          "maintenance_max_window_blocks": "50",
+          "maintenance_max_concurrent_validators": 3,
+          "maintenance_max_concurrent_power_bps": 5000,
+          "maintenance_credit_cap_blocks": "200",
+          "maintenance_credit_earn_per_successful_epoch_blocks": "50"
         }
       },
       "genesis_only_params": {
@@ -119,4 +128,4 @@
       ]
     }
   }
-}
\ No newline at end of file
+}
diff --git a/inference-chain/testutil/keeper/expected_keepers_mocks.go b/inference-chain/testutil/keeper/expected_keepers_mocks.go
index 67a549c907..a9d78dc362 100644
--- a/inference-chain/testutil/keeper/expected_keepers_mocks.go
+++ b/inference-chain/testutil/keeper/expected_keepers_mocks.go
@@ -31,6 +31,7 @@ import (
 type MockAccountKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockAccountKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper.
@@ -136,6 +137,7 @@ func (mr *MockAccountKeeperMockRecorder) SetAccount(ctx, acc any) *gomock.Call {
 type MockBankKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockBankKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper.
@@ -240,6 +242,7 @@ func (mr *MockBankKeeperMockRecorder) SpendableCoins(arg0, arg1 any) *gomock.Cal
 type MockGroupMessageKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockGroupMessageKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockGroupMessageKeeperMockRecorder is the mock recorder for MockGroupMessageKeeper.
@@ -398,6 +401,7 @@ func (mr *MockGroupMessageKeeperMockRecorder) Vote(goCtx, msg any) *gomock.Call
 type MockParamSubspace struct {
 	ctrl     *gomock.Controller
 	recorder *MockParamSubspaceMockRecorder
+	isgomock struct{}
 }
 
 // MockParamSubspaceMockRecorder is the mock recorder for MockParamSubspace.
@@ -445,6 +449,7 @@ func (mr *MockParamSubspaceMockRecorder) Set(arg0, arg1, arg2 any) *gomock.Call
 type MockStakingHooks struct {
 	ctrl     *gomock.Controller
 	recorder *MockStakingHooksMockRecorder
+	isgomock struct{}
 }
 
 // MockStakingHooksMockRecorder is the mock recorder for MockStakingHooks.
@@ -608,6 +613,7 @@ func (mr *MockStakingHooksMockRecorder) BeforeValidatorSlashed(ctx, valAddr, fra
 type MockValidatorSet struct {
 	ctrl     *gomock.Controller
 	recorder *MockValidatorSetMockRecorder
+	isgomock struct{}
 }
 
 // MockValidatorSetMockRecorder is the mock recorder for MockValidatorSet.
@@ -645,6 +651,7 @@ func (mr *MockValidatorSetMockRecorder) IterateValidators(arg0, arg1 any) *gomoc
 type MockStakingKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockStakingKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockStakingKeeperMockRecorder is the mock recorder for MockStakingKeeper.
@@ -679,6 +686,51 @@ func (mr *MockStakingKeeperMockRecorder) GetAllValidators(ctx any) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllValidators", reflect.TypeOf((*MockStakingKeeper)(nil).GetAllValidators), ctx)
 }
 
+// GetLastTotalPower mocks base method.
+func (m *MockStakingKeeper) GetLastTotalPower(ctx context.Context) (math.Int, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLastTotalPower", ctx)
+	ret0, _ := ret[0].(math.Int)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLastTotalPower indicates an expected call of GetLastTotalPower.
+func (mr *MockStakingKeeperMockRecorder) GetLastTotalPower(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastTotalPower", reflect.TypeOf((*MockStakingKeeper)(nil).GetLastTotalPower), ctx)
+}
+
+// GetValidator mocks base method.
+func (m *MockStakingKeeper) GetValidator(ctx context.Context, addr types1.ValAddress) (types3.Validator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetValidator", ctx, addr)
+	ret0, _ := ret[0].(types3.Validator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetValidator indicates an expected call of GetValidator.
+func (mr *MockStakingKeeperMockRecorder) GetValidator(ctx, addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidator", reflect.TypeOf((*MockStakingKeeper)(nil).GetValidator), ctx, addr)
+}
+
+// GetValidatorByConsAddr mocks base method.
+func (m *MockStakingKeeper) GetValidatorByConsAddr(ctx context.Context, consAddr types1.ConsAddress) (types3.Validator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetValidatorByConsAddr", ctx, consAddr)
+	ret0, _ := ret[0].(types3.Validator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetValidatorByConsAddr indicates an expected call of GetValidatorByConsAddr.
+func (mr *MockStakingKeeperMockRecorder) GetValidatorByConsAddr(ctx, consAddr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorByConsAddr", reflect.TypeOf((*MockStakingKeeper)(nil).GetValidatorByConsAddr), ctx, consAddr)
+}
+
 // SetComputeValidators mocks base method.
 func (m *MockStakingKeeper) SetComputeValidators(ctx context.Context, computeResults []keeper.ComputeResult, isTestnet bool) ([]types3.Validator, error) {
 	m.ctrl.T.Helper()
@@ -698,6 +750,7 @@ func (mr *MockStakingKeeperMockRecorder) SetComputeValidators(ctx, computeResult
 type MockCollateralKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockCollateralKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockCollateralKeeperMockRecorder is the mock recorder for MockCollateralKeeper.
@@ -765,6 +818,7 @@ func (mr *MockCollateralKeeperMockRecorder) Slash(ctx, participant, slashFractio
 type MockStreamVestingKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamVestingKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockStreamVestingKeeperMockRecorder is the mock recorder for MockStreamVestingKeeper.
@@ -816,6 +870,7 @@ func (mr *MockStreamVestingKeeperMockRecorder) AdvanceEpoch(ctx, completedEpoch
 type MockParticipantKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockParticipantKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockParticipantKeeperMockRecorder is the mock recorder for MockParticipantKeeper.
@@ -909,6 +964,7 @@ func (mr *MockParticipantKeeperMockRecorder) SetParticipant(ctx, participant any
 type MockHardwareNodeKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockHardwareNodeKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockHardwareNodeKeeperMockRecorder is the mock recorder for MockHardwareNodeKeeper.
@@ -947,6 +1003,7 @@ func (mr *MockHardwareNodeKeeperMockRecorder) GetHardwareNodes(ctx, address any)
 type MockEpochGroupDataKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockEpochGroupDataKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockEpochGroupDataKeeperMockRecorder is the mock recorder for MockEpochGroupDataKeeper.
@@ -1023,6 +1080,7 @@ func (mr *MockEpochGroupDataKeeperMockRecorder) SetEpochGroupData(ctx, epochGrou
 type MockBookkeepingBankKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockBookkeepingBankKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockBookkeepingBankKeeperMockRecorder is the mock recorder for MockBookkeepingBankKeeper.
@@ -1128,6 +1186,7 @@ func (mr *MockBookkeepingBankKeeperMockRecorder) SendCoinsFromModuleToModule(ctx
 type MockModelKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockModelKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockModelKeeperMockRecorder is the mock recorder for MockModelKeeper.
@@ -1181,6 +1240,7 @@ func (mr *MockModelKeeperMockRecorder) GetGovernanceModels(ctx any) *gomock.Call
 type MockAuthzKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockAuthzKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockAuthzKeeperMockRecorder is the mock recorder for MockAuthzKeeper.
@@ -1234,6 +1294,7 @@ func (mr *MockAuthzKeeperMockRecorder) Grants(ctx, req any) *gomock.Call {
 type MockBlsKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockBlsKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockBlsKeeperMockRecorder is the mock recorder for MockBlsKeeper.
@@ -1413,6 +1474,7 @@ func (mr *MockBlsKeeperMockRecorder) SetCurrentSigningEpochID(ctx, epochID any)
 type MockUpgradeKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockUpgradeKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockUpgradeKeeperMockRecorder is the mock recorder for MockUpgradeKeeper.
@@ -1451,6 +1513,7 @@ func (mr *MockUpgradeKeeperMockRecorder) GetUpgradePlan(ctx any) *gomock.Call {
 type MockWasmKeeper struct {
 	ctrl     *gomock.Controller
 	recorder *MockWasmKeeperMockRecorder
+	isgomock struct{}
 }
 
 // MockWasmKeeperMockRecorder is the mock recorder for MockWasmKeeper.
diff --git a/inference-chain/testutil/keeper/inference.go b/inference-chain/testutil/keeper/inference.go
index 063a060240..4008b6687a 100644
--- a/inference-chain/testutil/keeper/inference.go
+++ b/inference-chain/testutil/keeper/inference.go
@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"context"
+	"sync"
 	"testing"
 	"time"
 
@@ -35,6 +36,17 @@ import (
 	"github.com/productscience/inference/x/inference/types"
 )
 
+var bech32ConfigOnce sync.Once
+
+func ensureBech32Config() {
+	bech32ConfigOnce.Do(func() {
+		cfg := sdk.GetConfig()
+		cfg.SetBech32PrefixForAccount("gonka", "gonkapub")
+		cfg.SetBech32PrefixForValidator("gonkavaloper", "gonkavaloperpub")
+		cfg.SetBech32PrefixForConsensusNode("gonkavalcons", "gonkavalconspub")
+	})
+}
+
 func InferenceKeeper(t testing.TB) (keeper.Keeper, sdk.Context) {
 	ctrl := gomock.NewController(t)
 	bankKeeper := NewMockBookkeepingBankKeeper(ctrl)
@@ -186,7 +198,7 @@ func InferenceKeeperWithMock(
 	authzKeeper types.AuthzKeeper,
 	upgradeKeeper types.UpgradeKeeper,
 ) (keeper.Keeper, sdk.Context) {
-	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
+	ensureBech32Config()
 	storeKey := storetypes.NewKVStoreKey(types.StoreKey)
 	transientStoreKey := storetypes.NewTransientStoreKey(types.TransientStoreKey)
 	blsStoreKey := storetypes.NewKVStoreKey(blstypes.StoreKey)
diff --git a/inference-chain/x/bls/keeper/msg_server_threshold_signing.go b/inference-chain/x/bls/keeper/msg_server_threshold_signing.go
index 09087b044b..dc40e55d8b 100644
--- a/inference-chain/x/bls/keeper/msg_server_threshold_signing.go
+++ b/inference-chain/x/bls/keeper/msg_server_threshold_signing.go
@@ -4,20 +4,11 @@ import (
 	"context"
 	"fmt"
 
+	sdkerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/productscience/inference/x/bls/types"
-	"golang.org/x/crypto/sha3"
 )
 
-// Note: We do this for security, so that none can mimic module originated signatures
-// Domain separation constant for external threshold signature requests
-var CUSTOM_SIGNATURE_DOMAIN = func() []byte {
-	hash := sha3.NewLegacyKeccak256()
-	hash.Write([]byte("CUSTOM_THRESHOLD_SIGNATURE"))
-	result := hash.Sum(nil)
-	return result[:32] // Return 32 bytes for bytes32 compatibility
-}()
-
 // SubmitPartialSignature handles the submission of partial signatures for threshold signing
 func (ms msgServer) SubmitPartialSignature(ctx context.Context, msg *types.MsgSubmitPartialSignature) (*types.MsgSubmitPartialSignatureResponse, error) {
 	// Convert to SDK context
@@ -39,49 +30,5 @@ func (ms msgServer) SubmitPartialSignature(ctx context.Context, msg *types.MsgSu
 
 // RequestThresholdSignature handles requests for threshold signatures from external users
 func (ms msgServer) RequestThresholdSignature(ctx context.Context, msg *types.MsgRequestThresholdSignature) (*types.MsgRequestThresholdSignatureResponse, error) {
-	// Convert to SDK context
-	sdkCtx := sdk.UnwrapSDKContext(ctx)
-
-	// External callers must request signatures against the current signing epoch only.
-	currentSigningEpochID, found := ms.GetCurrentSigningEpochID(sdkCtx)
-	if !found {
-		return nil, fmt.Errorf("current signing epoch is not set")
-	}
-	if msg.CurrentEpochId != currentSigningEpochID {
-		return nil, fmt.Errorf("current_epoch_id mismatch: expected %d, got %d", currentSigningEpochID, msg.CurrentEpochId)
-	}
-
-	// Namespace the RequestId: keccak256(creator || request_id)
-	// This prevents external users from front-running and colliding with internal module requests
-	hash := sha3.NewLegacyKeccak256()
-	hash.Write([]byte(msg.Creator))
-	hash.Write(msg.RequestId)
-	namespacedRequestId := hash.Sum(nil)
-
-	// Add domain separation for external requests by prepending CUSTOM_SIGNATURE_DOMAIN
-	// This prevents unauthorized signatures from being created for unintended operations
-	customData := make([][]byte, 0, len(msg.Data)+1)
-	customData = append(customData, CUSTOM_SIGNATURE_DOMAIN)
-	customData = append(customData, msg.Data...)
-
-	// Create SigningData struct from the message with custom domain prefix
-	signingData := types.SigningData{
-		CurrentEpochId: msg.CurrentEpochId,
-		ChainId:        msg.ChainId,
-		RequestId:      namespacedRequestId,
-		Data:           customData,
-	}
-
-	// Call the core RequestThresholdSignature function which handles:
-	// 1. Validates the request (epoch, uniqueness, etc.)
-	// 2. Creates and stores the ThresholdSigningRequest
-	// 3. Emits EventThresholdSigningRequested for controllers
-	err := ms.Keeper.RequestThresholdSignature(sdkCtx, signingData)
-	if err != nil {
-		return nil, fmt.Errorf("failed to request threshold signature: %w", err)
-	}
-
-	return &types.MsgRequestThresholdSignatureResponse{
-		DerivedRequestId: namespacedRequestId,
-	}, nil
+	return nil, sdkerrors.Wrap(types.ErrDeprecated, "threshold signature request message is deprecated")
 }
diff --git a/inference-chain/x/bls/keeper/msg_server_threshold_signing_test.go b/inference-chain/x/bls/keeper/msg_server_threshold_signing_test.go
index e6d276bfab..e442988bab 100644
--- a/inference-chain/x/bls/keeper/msg_server_threshold_signing_test.go
+++ b/inference-chain/x/bls/keeper/msg_server_threshold_signing_test.go
@@ -3,109 +3,32 @@ package keeper_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"cosmossdk.io/errors"
 	"github.com/stretchr/testify/require"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	keepertest "github.com/productscience/inference/testutil/keeper"
 	"github.com/productscience/inference/x/bls/keeper"
 	"github.com/productscience/inference/x/bls/types"
-	"golang.org/x/crypto/sha3"
 )
 
-func setupMsgServerThresholdSigning(t testing.TB) (keeper.Keeper, types.MsgServer, sdk.Context) {
+func TestRequestThresholdSignatureMsgDeprecated(t *testing.T) {
 	k, ctx := keepertest.BlsKeeper(t)
-	return k, keeper.NewMsgServerImpl(k), ctx
-}
-
-func setCompletedEpoch(t testing.TB, k keeper.Keeper, ctx sdk.Context, epochID uint64) {
-	t.Helper()
-	err := k.SetEpochBLSData(ctx, types.EpochBLSData{
-		EpochId:        epochID,
-		DkgPhase:       types.DKGPhase_DKG_PHASE_COMPLETED,
-		GroupPublicKey: []byte{1, 2, 3},
-	})
-	require.NoError(t, err)
-}
-
-func TestCurrentSigningEpochID_SetGet(t *testing.T) {
-	k, ctx := keepertest.BlsKeeper(t)
-
-	epochID, found := k.GetCurrentSigningEpochID(ctx)
-	require.False(t, found)
-	require.Equal(t, uint64(0), epochID)
-
-	k.SetCurrentSigningEpochID(ctx, 7)
-
-	epochID, found = k.GetCurrentSigningEpochID(ctx)
-	require.True(t, found)
-	require.Equal(t, uint64(7), epochID)
-}
-
-func TestRequestThresholdSignature_RejectsWhenCurrentSigningEpochUnset(t *testing.T) {
-	k, ms, sdkCtx := setupMsgServerThresholdSigning(t)
-	setCompletedEpoch(t, k, sdkCtx, 1)
+	ms := keeper.NewMsgServerImpl(k)
 
 	msg := &types.MsgRequestThresholdSignature{
-		Creator:        "gonka1externaluser",
+		Creator:        "gonka1hgt9lxxxwpsnc3yn2nheqqy9a8vlcjwvgzpve2",
 		CurrentEpochId: 1,
-		ChainId:        []byte("chain"),
-		RequestId:      []byte("req-unset"),
-		Data:           [][]byte{[]byte("payload")},
-	}
-
-	_, err := ms.RequestThresholdSignature(sdkCtx, msg)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "current signing epoch is not set")
-}
-
-func TestRequestThresholdSignature_RejectsStaleEpoch(t *testing.T) {
-	k, ms, sdkCtx := setupMsgServerThresholdSigning(t)
-	setCompletedEpoch(t, k, sdkCtx, 1)
-	k.SetCurrentSigningEpochID(sdkCtx, 2)
-
-	msg := &types.MsgRequestThresholdSignature{
-		Creator:        "gonka1externaluser",
-		CurrentEpochId: 1,
-		ChainId:        []byte("chain"),
-		RequestId:      []byte("req-stale"),
-		Data:           [][]byte{[]byte("payload")},
-	}
-
-	_, err := ms.RequestThresholdSignature(sdkCtx, msg)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "current_epoch_id mismatch")
-	assert.Contains(t, err.Error(), "expected 2, got 1")
-}
-
-func TestRequestThresholdSignature_AcceptsCurrentEpoch(t *testing.T) {
-	k, ms, sdkCtx := setupMsgServerThresholdSigning(t)
-	// Signing is allowed immediately for DKG_PHASE_SIGNED. DKG_PHASE_COMPLETED without
-	// DisputingPhaseDeadlineBlock / fallback timing is rejected (see threshold_signing_test.go).
-	require.NoError(t, k.SetEpochBLSData(sdkCtx, types.EpochBLSData{
-		EpochId:        2,
-		DkgPhase:       types.DKGPhase_DKG_PHASE_SIGNED,
-		GroupPublicKey: []byte{1, 2, 3},
-	}))
-	k.SetCurrentSigningEpochID(sdkCtx, 2)
-
-	msg := &types.MsgRequestThresholdSignature{
-		Creator:        "gonka1externaluser",
-		CurrentEpochId: 2,
-		ChainId:        []byte("chain"),
-		RequestId:      []byte("req-current"),
-		Data:           [][]byte{[]byte("payload")},
+		ChainId:        make([]byte, 32),
+		RequestId:      []byte("request-id-32-bytes-----------"),
+		Data:           [][]byte{make([]byte, 32)},
 	}
 
-	_, err := ms.RequestThresholdSignature(sdkCtx, msg)
-	require.NoError(t, err)
+	resp, err := ms.RequestThresholdSignature(ctx, msg)
 
-	hash := sha3.NewLegacyKeccak256()
-	hash.Write([]byte(msg.Creator))
-	hash.Write(msg.RequestId)
-	namespacedRequestId := hash.Sum(nil)
+	require.Nil(t, resp)
+	require.True(t, errors.IsOf(err, types.ErrDeprecated), "err=%v", err)
+	require.Contains(t, err.Error(), "threshold signature request message is deprecated")
 
-	stored, err := k.GetSigningStatus(sdkCtx, namespacedRequestId)
-	require.NoError(t, err)
-	require.Equal(t, uint64(2), stored.CurrentEpochId)
+	_, statusErr := k.GetSigningStatus(ctx, msg.RequestId)
+	require.Error(t, statusErr)
 }
diff --git a/inference-chain/x/bls/types/errors.go b/inference-chain/x/bls/types/errors.go
index d7667b9eb6..d7cbf38ee3 100644
--- a/inference-chain/x/bls/types/errors.go
+++ b/inference-chain/x/bls/types/errors.go
@@ -11,4 +11,5 @@ var (
 	ErrInvalidSigner        = sdkerrors.Register(ModuleName, 1100, "expected gov account as only signer for proposal message")
 	ErrSample               = sdkerrors.Register(ModuleName, 1101, "sample error")
 	ErrEpochBLSDataNotFound = sdkerrors.Register(ModuleName, 1102, "epoch BLS data not found")
+	ErrDeprecated           = sdkerrors.Register(ModuleName, 1103, "this message type is deprecated")
 )
diff --git a/inference-chain/x/bls/types/tx.pb.go b/inference-chain/x/bls/types/tx.pb.go
index fc57493f8d..84fa6295f1 100644
--- a/inference-chain/x/bls/types/tx.pb.go
+++ b/inference-chain/x/bls/types/tx.pb.go
@@ -879,6 +879,8 @@ func (m *MsgSubmitPartialSignatureResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_MsgSubmitPartialSignatureResponse proto.InternalMessageInfo
 
 // MsgRequestThresholdSignature allows external users to request a threshold signature via transaction
+//
+// Deprecated: Do not use.
 type MsgRequestThresholdSignature struct {
 	// creator is the address of the user requesting the threshold signature
 	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
@@ -962,6 +964,8 @@ func (m *MsgRequestThresholdSignature) GetData() [][]byte {
 
 // MsgRequestThresholdSignatureResponse defines the response structure for executing a
 // MsgRequestThresholdSignature message.
+//
+// Deprecated: Do not use.
 type MsgRequestThresholdSignatureResponse struct {
 	// derived_request_id is the actual request ID used for KVStore lookups, derived as keccak256(creator || request_id)
 	DerivedRequestId []byte `protobuf:"bytes,1,opt,name=derived_request_id,json=derivedRequestId,proto3" json:"derived_request_id,omitempty"`
@@ -1030,84 +1034,84 @@ func init() {
 func init() { proto.RegisterFile("inference/bls/tx.proto", fileDescriptor_06b0e6f51d329716) }
 
 var fileDescriptor_06b0e6f51d329716 = []byte{
-	// 1217 bytes of a gzipped FileDescriptorProto
+	// 1227 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4f, 0x6f, 0x1b, 0xc5,
 	0x1b, 0xce, 0xda, 0xee, 0x9f, 0xbc, 0x71, 0x9b, 0x64, 0x9b, 0x5f, 0x6d, 0x6f, 0x7f, 0x75, 0x9d,
-	0x6d, 0x69, 0x1d, 0x27, 0xd8, 0xad, 0x53, 0x21, 0xe4, 0xc2, 0x81, 0xb4, 0x01, 0x05, 0x14, 0x11,
-	0x6d, 0x4a, 0x0e, 0x48, 0xb0, 0x5a, 0xef, 0x4e, 0xec, 0x91, 0xec, 0x9d, 0x65, 0x66, 0x9c, 0xc4,
-	0x48, 0x95, 0x10, 0x37, 0x38, 0x21, 0x10, 0xe2, 0x2b, 0x70, 0xe0, 0x10, 0x21, 0x24, 0x0e, 0x7c,
-	0x81, 0x8a, 0x53, 0xc5, 0x89, 0x13, 0x42, 0xc9, 0x21, 0xdf, 0x81, 0x13, 0xda, 0xd9, 0x3f, 0x4e,
-	0xc6, 0x5e, 0x27, 0x84, 0x72, 0x49, 0xbc, 0xef, 0xfb, 0xbc, 0x33, 0xcf, 0xfb, 0xcc, 0x33, 0xaf,
-	0xd7, 0x70, 0x1d, 0xbb, 0xdb, 0x88, 0x22, 0xd7, 0x46, 0xb5, 0x66, 0x87, 0xd5, 0xf8, 0x5e, 0xd5,
-	0xa3, 0x84, 0x13, 0xf5, 0x4a, 0x1c, 0xaf, 0x36, 0x3b, 0x4c, 0x9b, 0xb5, 0xba, 0xd8, 0x25, 0x35,
-	0xf1, 0x37, 0x40, 0x68, 0x39, 0x9b, 0xb0, 0x2e, 0x61, 0xb5, 0x2e, 0x6b, 0xd5, 0x76, 0x1e, 0xf8,
-	0xff, 0xc2, 0x44, 0x21, 0x48, 0x98, 0xe2, 0xa9, 0x16, 0x3c, 0x84, 0xa9, 0xb9, 0x16, 0x69, 0x91,
-	0x20, 0xee, 0x7f, 0x0a, 0xa3, 0xda, 0x49, 0x0e, 0x9e, 0x45, 0xad, 0x6e, 0x54, 0x51, 0x90, 0xf8,
-	0xf5, 0x3d, 0x14, 0xa6, 0xf4, 0x9f, 0x15, 0x98, 0x5e, 0x67, 0xad, 0x0f, 0x3c, 0xc7, 0xe2, 0x68,
-	0x43, 0x14, 0xa9, 0xaf, 0xc1, 0xa4, 0xd5, 0xe3, 0x6d, 0x42, 0x31, 0xef, 0xe7, 0x95, 0x92, 0x52,
-	0x9e, 0x5c, 0xc9, 0xff, 0xf6, 0xd3, 0xab, 0x73, 0x21, 0x8b, 0xb7, 0x1c, 0x87, 0x22, 0xc6, 0x36,
-	0x39, 0xc5, 0x6e, 0xcb, 0x18, 0x40, 0xd5, 0xd7, 0xe1, 0x62, 0xb0, 0x6d, 0x3e, 0x55, 0x52, 0xca,
-	0x53, 0xf5, 0xff, 0x55, 0x4f, 0xf4, 0x5f, 0x0d, 0x96, 0x5f, 0x99, 0x7c, 0xfe, 0xc7, 0xad, 0x89,
-	0xef, 0x8f, 0xf6, 0x2b, 0x8a, 0x11, 0xe2, 0x1b, 0xf5, 0xcf, 0x8f, 0xf6, 0x2b, 0x83, 0x95, 0xbe,
-	0x3c, 0xda, 0xaf, 0xdc, 0x1a, 0x70, 0xde, 0x13, 0xac, 0x25, 0x96, 0x7a, 0x01, 0x72, 0x52, 0xc8,
-	0x40, 0xcc, 0x23, 0x2e, 0x43, 0xfa, 0x2f, 0x29, 0xb8, 0xb6, 0xce, 0x5a, 0x9b, 0xbd, 0x66, 0x17,
-	0xf3, 0x27, 0xc8, 0xea, 0x20, 0xba, 0x61, 0x51, 0xae, 0xd6, 0xe1, 0x92, 0x4d, 0x91, 0xc5, 0x09,
-	0x3d, 0xb5, 0xad, 0x08, 0xa8, 0x16, 0xe0, 0x32, 0xf2, 0x88, 0xdd, 0x36, 0xb1, 0x23, 0xda, 0xca,
-	0x18, 0x97, 0xc4, 0xf3, 0x9a, 0xa3, 0x96, 0x60, 0xca, 0x26, 0xdd, 0x2e, 0xe6, 0x5d, 0xe4, 0x72,
-	0x96, 0x4f, 0x97, 0xd2, 0xe5, 0xac, 0x71, 0x3c, 0xa4, 0x3e, 0x83, 0x79, 0xe4, 0xda, 0xb4, 0xef,
-	0x71, 0xe4, 0x98, 0xac, 0x6d, 0x51, 0xc4, 0xcc, 0x6d, 0x42, 0x4d, 0xcf, 0xa2, 0x1c, 0xdb, 0xd8,
-	0xb3, 0xfc, 0xba, 0x4c, 0x29, 0x5d, 0x9e, 0xaa, 0x2f, 0x49, 0x62, 0xad, 0x46, 0x75, 0x9b, 0xa2,
-	0xec, 0x6d, 0x22, 0x5a, 0x08, 0x8b, 0x56, 0x32, 0xbe, 0x86, 0x46, 0x11, 0x8d, 0x03, 0xb1, 0xc6,
-	0x43, 0x5f, 0xd6, 0xa8, 0x13, 0x5f, 0xd4, 0xdb, 0x23, 0x44, 0x95, 0x55, 0xd2, 0x6f, 0xc2, 0x8d,
-	0x11, 0xe1, 0x58, 0xdc, 0x1f, 0x14, 0xb8, 0xb1, 0x85, 0x28, 0xde, 0xc6, 0xb6, 0xc5, 0x31, 0x71,
-	0x03, 0xc8, 0x63, 0xd2, 0xf5, 0x3a, 0x16, 0x76, 0xb9, 0x3a, 0x0f, 0x59, 0x47, 0x84, 0x4c, 0xec,
-	0x3a, 0x68, 0x4f, 0x28, 0x7d, 0xc5, 0x98, 0x0a, 0x62, 0x6b, 0x7e, 0x48, 0xad, 0xc2, 0x35, 0x07,
-	0x33, 0xaf, 0x27, 0x54, 0xe9, 0x10, 0x1e, 0x22, 0x53, 0x02, 0x39, 0x1b, 0xa5, 0x36, 0x3b, 0x84,
-	0x07, 0xf8, 0x06, 0x14, 0x62, 0xbc, 0x8d, 0xbd, 0x36, 0xa2, 0x1c, 0xed, 0x45, 0x55, 0x69, 0x51,
-	0x95, 0x8b, 0x00, 0x8f, 0xe3, 0xbc, 0xa8, 0xd5, 0x2d, 0xb8, 0x16, 0x30, 0xdc, 0xb2, 0x3a, 0xd8,
-	0xc1, 0xbc, 0xbf, 0x41, 0x09, 0xd9, 0x3e, 0x0b, 0xcb, 0x7b, 0x30, 0xed, 0xf9, 0x58, 0x93, 0xe1,
-	0x96, 0x6b, 0xf1, 0x1e, 0x45, 0x82, 0x61, 0xd6, 0xb8, 0x2a, 0xc2, 0x9b, 0x51, 0x54, 0xff, 0x3a,
-	0x7d, 0x4c, 0xb1, 0xe3, 0xd2, 0x6c, 0x21, 0xdb, 0xb7, 0xd0, 0x4b, 0xb6, 0xdd, 0x3d, 0x98, 0x0e,
-	0xa9, 0xef, 0x84, 0x2d, 0x09, 0xeb, 0x5d, 0x36, 0xae, 0x3a, 0x27, 0x1a, 0x55, 0x3f, 0x82, 0xd9,
-	0x10, 0x68, 0x47, 0xa7, 0x13, 0xb9, 0xad, 0x22, 0xb9, 0x6d, 0xcc, 0x81, 0x86, 0x5e, 0x9b, 0x71,
-	0x4e, 0x86, 0x99, 0xfa, 0x31, 0x5c, 0x97, 0x78, 0x98, 0x42, 0x18, 0x96, 0xbf, 0x20, 0xf6, 0xd0,
-	0xa5, 0x3d, 0x46, 0x1c, 0x43, 0xb8, 0xf6, 0x9c, 0x33, 0x9c, 0x62, 0x8d, 0x37, 0x64, 0xf7, 0x2e,
-	0x26, 0xba, 0x77, 0x58, 0x74, 0xfd, 0x15, 0xb8, 0x3d, 0x26, 0x1d, 0xbb, 0xf9, 0x47, 0x05, 0x72,
-	0x52, 0xc3, 0x51, 0x4e, 0x5d, 0x80, 0x99, 0x48, 0x38, 0xc9, 0x27, 0xd3, 0x83, 0x78, 0xe0, 0x95,
-	0xfb, 0x30, 0x47, 0xc3, 0xb2, 0xe0, 0x9e, 0x9b, 0xcd, 0x3e, 0x47, 0x2c, 0x34, 0x8c, 0x1a, 0xe5,
-	0xc4, 0x35, 0x5d, 0xf1, 0x33, 0xbe, 0xa7, 0xe3, 0x0a, 0xe2, 0x21, 0x17, 0xbb, 0x2d, 0xb3, 0x6b,
-	0x71, 0x44, 0xb1, 0xd5, 0x11, 0x9e, 0xce, 0x1a, 0xb9, 0x08, 0xf0, 0x7e, 0x90, 0x5f, 0x0f, 0xd3,
-	0xfa, 0x77, 0x29, 0xd0, 0xd6, 0x59, 0x2b, 0x20, 0xea, 0x3c, 0x91, 0x0f, 0xe6, 0x25, 0xfb, 0x4d,
-	0xbe, 0x2a, 0xe9, 0xe1, 0xab, 0xf2, 0x2e, 0x4c, 0x46, 0x5c, 0x23, 0x87, 0xdd, 0x1d, 0x79, 0xfa,
-	0x43, 0x22, 0x87, 0x0e, 0x18, 0x94, 0x37, 0x1e, 0xc9, 0xc7, 0x5e, 0x19, 0x71, 0xec, 0x09, 0xad,
-	0xeb, 0x77, 0x40, 0x4f, 0xce, 0xc6, 0x87, 0xfe, 0x4d, 0x0a, 0xee, 0xc4, 0xe6, 0x78, 0x87, 0x92,
-	0x9e, 0xf7, 0x1e, 0xea, 0x0b, 0xf7, 0x09, 0x8b, 0xc4, 0x37, 0xfb, 0x5c, 0x4a, 0x96, 0x20, 0xeb,
-	0xa2, 0x5d, 0x53, 0x52, 0x13, 0x5c, 0xb4, 0xbb, 0x3a, 0x10, 0x34, 0x9a, 0x7a, 0xd8, 0x46, 0xc1,
-	0x17, 0xc7, 0x15, 0x63, 0x8a, 0x05, 0xf3, 0xce, 0x0f, 0xa9, 0x8b, 0x30, 0x2b, 0xbe, 0x23, 0xac,
-	0xce, 0xb1, 0xe9, 0x93, 0x11, 0xae, 0x98, 0x09, 0x13, 0x31, 0xcb, 0xc6, 0xaa, 0xac, 0xd8, 0xc3,
-	0xc4, 0x8b, 0x32, 0xa6, 0x59, 0xbd, 0x0a, 0x4b, 0x67, 0xc1, 0xc5, 0x2a, 0xfe, 0xa5, 0x40, 0x21,
-	0x2e, 0xd8, 0x90, 0x48, 0x9d, 0x4b, 0xba, 0x9b, 0x00, 0x14, 0x7d, 0xd2, 0x43, 0x8c, 0x47, 0xc2,
-	0x65, 0x7d, 0x67, 0x88, 0xc8, 0x7f, 0xa0, 0x5b, 0x43, 0xd6, 0x6d, 0x21, 0x51, 0x37, 0xb9, 0x3d,
-	0xfd, 0x36, 0xcc, 0x27, 0x26, 0x63, 0x85, 0xbe, 0x48, 0xc1, 0xff, 0x85, 0x1d, 0x45, 0x07, 0x4f,
-	0xdb, 0x14, 0xb1, 0x36, 0xe9, 0x38, 0xff, 0x4e, 0xa4, 0x32, 0xcc, 0xd8, 0x3d, 0x4a, 0x91, 0xcb,
-	0x65, 0x8f, 0x5d, 0x0d, 0xe3, 0x91, 0xcf, 0x0a, 0x70, 0xd9, 0x6e, 0x5b, 0xd8, 0xf5, 0x11, 0xc1,
-	0x44, 0xb9, 0x24, 0x9e, 0xd7, 0x1c, 0x49, 0xe9, 0x8c, 0xac, 0xb4, 0x0a, 0x19, 0xc7, 0xe2, 0x96,
-	0x18, 0xe4, 0x59, 0x43, 0x7c, 0x6e, 0xbc, 0x29, 0xab, 0xb5, 0x34, 0xf2, 0x5e, 0x26, 0xb4, 0xaa,
-	0x3f, 0x15, 0x57, 0x2e, 0x31, 0x1f, 0x0f, 0xdd, 0x25, 0x50, 0x1d, 0x44, 0xf1, 0x0e, 0x72, 0xcc,
-	0x63, 0x0c, 0x95, 0xe0, 0x08, 0xc3, 0x8c, 0x11, 0x11, 0xad, 0xff, 0x7a, 0x11, 0xd2, 0xeb, 0xac,
-	0xa5, 0x6e, 0x41, 0xf6, 0xc4, 0x2b, 0x6c, 0x51, 0x9a, 0x3e, 0xd2, 0x9b, 0xa2, 0x76, 0x77, 0x7c,
-	0x3e, 0x66, 0xd3, 0x84, 0x99, 0xa1, 0xb7, 0x48, 0x7d, 0xb8, 0x56, 0xc6, 0x68, 0x95, 0xd3, 0x31,
-	0xf1, 0x1e, 0x9f, 0x42, 0x3e, 0xf1, 0xd5, 0x21, 0x71, 0x9d, 0x61, 0xac, 0x56, 0x3f, 0x3b, 0x36,
-	0xde, 0x7b, 0x17, 0x72, 0x49, 0xdf, 0x22, 0x0b, 0xc3, 0xcb, 0x25, 0x40, 0xb5, 0x07, 0x67, 0x86,
-	0xc6, 0x1b, 0x7f, 0xab, 0xc0, 0xfc, 0xe9, 0xf3, 0x77, 0x39, 0xa9, 0xa5, 0x31, 0x45, 0xda, 0xa3,
-	0x73, 0x14, 0xc5, 0xbc, 0x38, 0x5c, 0x4f, 0x18, 0x68, 0xe5, 0xa4, 0x65, 0x65, 0xa4, 0x76, 0xff,
-	0xac, 0xc8, 0x78, 0xd7, 0x67, 0x50, 0x48, 0x1e, 0x12, 0x8b, 0xa3, 0xd4, 0x4d, 0x00, 0x6b, 0xcb,
-	0xff, 0x00, 0x1c, 0x6d, 0xaf, 0x5d, 0xf8, 0xcc, 0xff, 0x35, 0xb6, 0xb2, 0xf6, 0xfc, 0xa0, 0xa8,
-	0xbc, 0x38, 0x28, 0x2a, 0x7f, 0x1e, 0x14, 0x95, 0xaf, 0x0e, 0x8b, 0x13, 0x2f, 0x0e, 0x8b, 0x13,
-	0xbf, 0x1f, 0x16, 0x27, 0x3e, 0xac, 0xb5, 0x30, 0x6f, 0xf7, 0x9a, 0x55, 0x9b, 0x74, 0x6b, 0x1e,
-	0x25, 0x4e, 0xcf, 0xe6, 0xcc, 0xc6, 0xe2, 0xea, 0xcb, 0x43, 0x40, 0xfc, 0xb8, 0x6c, 0x5e, 0x14,
-	0xbf, 0x2e, 0x97, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x13, 0xb6, 0x81, 0x9d, 0x1a, 0x0f, 0x00,
-	0x00,
+	0x6d, 0x69, 0x5d, 0x27, 0xd8, 0xad, 0x53, 0x21, 0xe4, 0x22, 0x21, 0xd2, 0x06, 0x14, 0x50, 0x44,
+	0xb4, 0x81, 0x08, 0x21, 0xc1, 0x6a, 0xbd, 0x3b, 0xb1, 0x47, 0xb2, 0x77, 0x96, 0x99, 0x71, 0x12,
+	0x23, 0x21, 0xa1, 0x9e, 0x10, 0x5c, 0x10, 0x08, 0xf1, 0x15, 0x38, 0x70, 0x88, 0x10, 0x12, 0x07,
+	0xbe, 0x40, 0x8f, 0x11, 0x27, 0x4e, 0x08, 0x25, 0x87, 0x7c, 0x07, 0x4e, 0x68, 0x67, 0xff, 0x38,
+	0x19, 0x7b, 0x9d, 0x10, 0xca, 0x25, 0xf1, 0xbe, 0xef, 0xf3, 0xce, 0x3c, 0xef, 0x33, 0xcf, 0xbc,
+	0x5e, 0xc3, 0x75, 0xec, 0x6e, 0x21, 0x8a, 0x5c, 0x1b, 0xd5, 0x9a, 0x1d, 0x56, 0xe3, 0xbb, 0x55,
+	0x8f, 0x12, 0x4e, 0xd4, 0x2b, 0x71, 0xbc, 0xda, 0xec, 0x30, 0x6d, 0xd6, 0xea, 0x62, 0x97, 0xd4,
+	0xc4, 0xdf, 0x00, 0xa1, 0xe5, 0x6c, 0xc2, 0xba, 0x84, 0xd5, 0xba, 0xac, 0x55, 0xdb, 0x7e, 0xe8,
+	0xff, 0x0b, 0x13, 0x85, 0x20, 0x61, 0x8a, 0xa7, 0x5a, 0xf0, 0x10, 0xa6, 0xe6, 0x5a, 0xa4, 0x45,
+	0x82, 0xb8, 0xff, 0x29, 0x8c, 0x6a, 0x27, 0x39, 0x78, 0x16, 0xb5, 0xba, 0x51, 0x45, 0x41, 0xe2,
+	0xd7, 0xf7, 0x50, 0x98, 0xd2, 0x7f, 0x51, 0x60, 0x7a, 0x8d, 0xb5, 0xde, 0xf7, 0x1c, 0x8b, 0xa3,
+	0x75, 0x51, 0xa4, 0xbe, 0x02, 0x93, 0x56, 0x8f, 0xb7, 0x09, 0xc5, 0xbc, 0x9f, 0x57, 0x4a, 0x4a,
+	0x79, 0x72, 0x39, 0xff, 0xdb, 0xcf, 0x2f, 0xcf, 0x85, 0x2c, 0xde, 0x70, 0x1c, 0x8a, 0x18, 0xdb,
+	0xe0, 0x14, 0xbb, 0x2d, 0x63, 0x00, 0x55, 0x5f, 0x85, 0x8b, 0xc1, 0xb6, 0xf9, 0x54, 0x49, 0x29,
+	0x4f, 0xd5, 0xff, 0x57, 0x3d, 0xd1, 0x7f, 0x35, 0x58, 0x7e, 0x79, 0xf2, 0xf9, 0x1f, 0xb7, 0x26,
+	0x7e, 0x38, 0xda, 0xab, 0x28, 0x46, 0x88, 0x6f, 0xd4, 0x9f, 0x1d, 0xed, 0x55, 0x06, 0x2b, 0x7d,
+	0x79, 0xb4, 0x57, 0xb9, 0x35, 0xe0, 0xbc, 0x2b, 0x58, 0x4b, 0x2c, 0xf5, 0x02, 0xe4, 0xa4, 0x90,
+	0x81, 0x98, 0x47, 0x5c, 0x86, 0xf4, 0x5f, 0x53, 0x70, 0x6d, 0x8d, 0xb5, 0x36, 0x7a, 0xcd, 0x2e,
+	0xe6, 0x4f, 0x91, 0xd5, 0x41, 0x74, 0xdd, 0xa2, 0x5c, 0xad, 0xc3, 0x25, 0x9b, 0x22, 0x8b, 0x13,
+	0x7a, 0x6a, 0x5b, 0x11, 0x50, 0x2d, 0xc0, 0x65, 0xe4, 0x11, 0xbb, 0x6d, 0x62, 0x47, 0xb4, 0x95,
+	0x31, 0x2e, 0x89, 0xe7, 0x55, 0x47, 0x2d, 0xc1, 0x94, 0x4d, 0xba, 0x5d, 0xcc, 0xbb, 0xc8, 0xe5,
+	0x2c, 0x9f, 0x2e, 0xa5, 0xcb, 0x59, 0xe3, 0x78, 0x48, 0xfd, 0x0c, 0xe6, 0x91, 0x6b, 0xd3, 0xbe,
+	0xc7, 0x91, 0x63, 0xb2, 0xb6, 0x45, 0x11, 0x33, 0xb7, 0x08, 0x35, 0x3d, 0x8b, 0x72, 0x6c, 0x63,
+	0xcf, 0xf2, 0xeb, 0x32, 0xa5, 0x74, 0x79, 0xaa, 0xbe, 0x28, 0x89, 0xb5, 0x12, 0xd5, 0x6d, 0x88,
+	0xb2, 0x37, 0x89, 0x68, 0x21, 0x2c, 0x5a, 0xce, 0xf8, 0x1a, 0x1a, 0x45, 0x34, 0x0e, 0xc4, 0x1a,
+	0x8f, 0x7c, 0x59, 0xa3, 0x4e, 0x7c, 0x51, 0x6f, 0x8f, 0x10, 0x55, 0x56, 0x49, 0xbf, 0x09, 0x37,
+	0x46, 0x84, 0x63, 0x71, 0x7f, 0x54, 0xe0, 0xc6, 0x26, 0xa2, 0x78, 0x0b, 0xdb, 0x16, 0xc7, 0xc4,
+	0x0d, 0x20, 0x4f, 0x48, 0xd7, 0xeb, 0x58, 0xd8, 0xe5, 0xea, 0x3c, 0x64, 0x1d, 0x11, 0x32, 0xb1,
+	0xeb, 0xa0, 0x5d, 0xa1, 0xf4, 0x15, 0x63, 0x2a, 0x88, 0xad, 0xfa, 0x21, 0xb5, 0x0a, 0xd7, 0x1c,
+	0xcc, 0xbc, 0x9e, 0x50, 0xa5, 0x43, 0x78, 0x88, 0x4c, 0x09, 0xe4, 0x6c, 0x94, 0xda, 0xe8, 0x10,
+	0x1e, 0xe0, 0x1b, 0x50, 0x88, 0xf1, 0x36, 0xf6, 0xda, 0x88, 0x72, 0xb4, 0x1b, 0x55, 0xa5, 0x45,
+	0x55, 0x2e, 0x02, 0x3c, 0x89, 0xf3, 0xa2, 0x56, 0xb7, 0xe0, 0x5a, 0xc0, 0x70, 0xd3, 0xea, 0x60,
+	0x07, 0xf3, 0xfe, 0x3a, 0x25, 0x64, 0xeb, 0x2c, 0x2c, 0xef, 0xc1, 0xb4, 0xe7, 0x63, 0x4d, 0x86,
+	0x5b, 0xae, 0xc5, 0x7b, 0x14, 0x09, 0x86, 0x59, 0xe3, 0xaa, 0x08, 0x6f, 0x44, 0x51, 0xfd, 0x9b,
+	0xf4, 0x31, 0xc5, 0x8e, 0x4b, 0xb3, 0x89, 0x6c, 0xdf, 0x42, 0x2f, 0xd8, 0x76, 0xf7, 0x60, 0x3a,
+	0xa4, 0xbe, 0x1d, 0xb6, 0x24, 0xac, 0x77, 0xd9, 0xb8, 0xea, 0x9c, 0x68, 0x54, 0xfd, 0x08, 0x66,
+	0x43, 0xa0, 0x1d, 0x9d, 0x4e, 0xe4, 0xb6, 0x8a, 0xe4, 0xb6, 0x31, 0x07, 0x1a, 0x7a, 0x6d, 0xc6,
+	0x39, 0x19, 0x66, 0xea, 0xc7, 0x70, 0x5d, 0xe2, 0x61, 0x0a, 0x61, 0x58, 0xfe, 0x82, 0xd8, 0x43,
+	0x97, 0xf6, 0x18, 0x71, 0x0c, 0xe1, 0xda, 0x73, 0xce, 0x70, 0x8a, 0x35, 0x5e, 0x93, 0xdd, 0xbb,
+	0x90, 0xe8, 0xde, 0x61, 0xd1, 0xf5, 0x97, 0xe0, 0xf6, 0x98, 0x74, 0xec, 0xe6, 0x9f, 0x14, 0xc8,
+	0x49, 0x0d, 0x47, 0x39, 0xf5, 0x3e, 0xcc, 0x44, 0xc2, 0x49, 0x3e, 0x99, 0x1e, 0xc4, 0x03, 0xaf,
+	0x3c, 0x80, 0x39, 0x1a, 0x96, 0x05, 0xf7, 0xdc, 0x6c, 0xf6, 0x39, 0x62, 0xa1, 0x61, 0xd4, 0x28,
+	0x27, 0xae, 0xe9, 0xb2, 0x9f, 0xf1, 0x3d, 0x1d, 0x57, 0x10, 0x0f, 0xb9, 0xd8, 0x6d, 0x99, 0x5d,
+	0x8b, 0x23, 0x8a, 0xad, 0x8e, 0xf0, 0x74, 0xd6, 0xc8, 0x45, 0x80, 0x77, 0x83, 0xfc, 0x5a, 0x98,
+	0xd6, 0xbf, 0x4f, 0x81, 0xb6, 0xc6, 0x5a, 0x01, 0x51, 0xe7, 0xa9, 0x7c, 0x30, 0x2f, 0xd8, 0x6f,
+	0xf2, 0x55, 0x49, 0x0f, 0x5f, 0x95, 0xb7, 0x61, 0x32, 0xe2, 0x1a, 0x39, 0xec, 0xee, 0xc8, 0xd3,
+	0x1f, 0x12, 0x39, 0x74, 0xc0, 0xa0, 0xbc, 0xf1, 0x58, 0x3e, 0xf6, 0xca, 0x88, 0x63, 0x4f, 0x68,
+	0x5d, 0xbf, 0x03, 0x7a, 0x72, 0x36, 0x3e, 0xf4, 0x6f, 0x53, 0x70, 0x27, 0x36, 0xc7, 0x5b, 0x94,
+	0xf4, 0xbc, 0x77, 0x50, 0x5f, 0xb8, 0x4f, 0x58, 0x24, 0xbe, 0xd9, 0xe7, 0x52, 0xb2, 0x04, 0x59,
+	0x17, 0xed, 0x98, 0x92, 0x9a, 0xe0, 0xa2, 0x9d, 0x95, 0x81, 0xa0, 0xd1, 0xd4, 0xc3, 0x36, 0x0a,
+	0xbe, 0x38, 0xae, 0x18, 0x53, 0x2c, 0x98, 0x77, 0x7e, 0x48, 0x5d, 0x80, 0x59, 0xf1, 0x1d, 0x61,
+	0x75, 0x8e, 0x4d, 0x9f, 0x8c, 0x70, 0xc5, 0x4c, 0x98, 0x88, 0x59, 0x36, 0x56, 0x64, 0xc5, 0x1e,
+	0x25, 0x5e, 0x94, 0x31, 0xcd, 0xea, 0x55, 0x58, 0x3c, 0x0b, 0x2e, 0x56, 0xf1, 0x2f, 0x05, 0x0a,
+	0x71, 0xc1, 0xba, 0x44, 0xea, 0x5c, 0xd2, 0xdd, 0x04, 0xa0, 0xe8, 0x93, 0x1e, 0x62, 0x3c, 0x12,
+	0x2e, 0xeb, 0x3b, 0x43, 0x44, 0xfe, 0x03, 0xdd, 0x1a, 0xb2, 0x6e, 0xf7, 0x13, 0x75, 0x93, 0xdb,
+	0xd3, 0x6f, 0xc3, 0x7c, 0x62, 0x32, 0x56, 0xe8, 0xab, 0x14, 0xfc, 0x5f, 0xd8, 0x51, 0x74, 0xf0,
+	0x5e, 0x9b, 0x22, 0xd6, 0x26, 0x1d, 0xe7, 0xdf, 0x89, 0x54, 0x86, 0x19, 0xbb, 0x47, 0x29, 0x72,
+	0xb9, 0xec, 0xb1, 0xab, 0x61, 0x3c, 0xf2, 0x59, 0x01, 0x2e, 0xdb, 0x6d, 0x0b, 0xbb, 0x3e, 0x22,
+	0x98, 0x28, 0x97, 0xc4, 0xf3, 0xaa, 0x23, 0x29, 0x9d, 0x91, 0x95, 0x56, 0x21, 0xe3, 0x58, 0xdc,
+	0x12, 0x83, 0x3c, 0x6b, 0x88, 0xcf, 0x8d, 0xd7, 0x65, 0xb5, 0x16, 0x47, 0xde, 0xcb, 0x84, 0x56,
+	0xf3, 0x8a, 0xfe, 0x81, 0xb8, 0x74, 0x89, 0x88, 0x78, 0xec, 0x2e, 0x82, 0xea, 0x20, 0x8a, 0xb7,
+	0x91, 0x63, 0x1e, 0xe3, 0xa8, 0x04, 0x87, 0x18, 0x66, 0x8c, 0x88, 0x6a, 0x23, 0x95, 0x57, 0xea,
+	0xfb, 0x17, 0x21, 0xbd, 0xc6, 0x5a, 0xea, 0x26, 0x64, 0x4f, 0xbc, 0xc8, 0x16, 0xa5, 0x19, 0x24,
+	0xbd, 0x2f, 0x6a, 0x77, 0xc7, 0xe7, 0x63, 0x46, 0x4d, 0x98, 0x19, 0x7a, 0x97, 0xd4, 0x87, 0x6b,
+	0x65, 0x8c, 0x56, 0x39, 0x1d, 0x13, 0xef, 0xf1, 0x29, 0xe4, 0x13, 0x5f, 0x20, 0x12, 0xd7, 0x19,
+	0xc6, 0x6a, 0xf5, 0xb3, 0x63, 0xe3, 0xbd, 0x77, 0x20, 0x97, 0xf4, 0x5d, 0x72, 0x7f, 0x78, 0xb9,
+	0x04, 0xa8, 0xf6, 0xf0, 0xcc, 0xd0, 0x78, 0xe3, 0xef, 0x14, 0x98, 0x3f, 0x7d, 0x0a, 0x2f, 0x25,
+	0xb5, 0x34, 0xa6, 0x48, 0x7b, 0x7c, 0x8e, 0xa2, 0x98, 0x17, 0x87, 0xeb, 0x09, 0x63, 0xad, 0x9c,
+	0xb4, 0xac, 0x8c, 0xd4, 0x1e, 0x9c, 0x15, 0x19, 0xef, 0xfa, 0x4c, 0x81, 0x42, 0xf2, 0xac, 0x58,
+	0x18, 0x25, 0x6f, 0x02, 0x58, 0x5b, 0xfa, 0x07, 0xe0, 0x78, 0x5c, 0xa5, 0xbf, 0x48, 0x29, 0xda,
+	0x85, 0xcf, 0xfd, 0x5f, 0x66, 0xcb, 0xab, 0xcf, 0x0f, 0x8a, 0xca, 0xfe, 0x41, 0x51, 0xf9, 0xf3,
+	0xa0, 0xa8, 0x7c, 0x7d, 0x58, 0x9c, 0xd8, 0x3f, 0x2c, 0x4e, 0xfc, 0x7e, 0x58, 0x9c, 0xf8, 0xb0,
+	0xd6, 0xc2, 0xbc, 0xdd, 0x6b, 0x56, 0x6d, 0xd2, 0xad, 0x79, 0x94, 0x38, 0x3d, 0x9b, 0x33, 0x1b,
+	0x8b, 0x31, 0x20, 0x0f, 0x04, 0xf1, 0x43, 0xb3, 0x79, 0x51, 0xfc, 0xd2, 0x5c, 0xfa, 0x3b, 0x00,
+	0x00, 0xff, 0xff, 0x9a, 0x48, 0x04, 0x5b, 0x26, 0x0f, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1201,6 +1205,7 @@ func (c *msgClient) SubmitPartialSignature(ctx context.Context, in *MsgSubmitPar
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) RequestThresholdSignature(ctx context.Context, in *MsgRequestThresholdSignature, opts ...grpc.CallOption) (*MsgRequestThresholdSignatureResponse, error) {
 	out := new(MsgRequestThresholdSignatureResponse)
 	err := c.cc.Invoke(ctx, "/inference.bls.Msg/RequestThresholdSignature", in, out, opts...)
diff --git a/inference-chain/x/collateral/keeper/epoch_processing_test.go b/inference-chain/x/collateral/keeper/epoch_processing_test.go
index 37a7a2c3fb..878a6a4eec 100644
--- a/inference-chain/x/collateral/keeper/epoch_processing_test.go
+++ b/inference-chain/x/collateral/keeper/epoch_processing_test.go
@@ -7,6 +7,7 @@ import (
 
 	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	"go.uber.org/mock/gomock"
 )
 
@@ -61,3 +62,55 @@ func (s *KeeperTestSuite) TestEpochProcessing_ProcessUnbondingQueue() {
 	_, found = s.k.GetUnbondingCollateral(s.ctx, futureParticipant, futureEpoch)
 	s.Require().True(found, "future-dated unbonding entry should not be processed")
 }
+
+func (s *KeeperTestSuite) TestEpochProcessing_SlashBeforeUnbondingRelease() {
+	participantStr := sample.AccAddress()
+	participant, err := sdk.AccAddressFromBech32(participantStr)
+	s.Require().NoError(err)
+
+	activeAmount := int64(20)
+	unbondingAmount := int64(80)
+	activeCoin := sdk.NewInt64Coin(inftypes.BaseCoin, activeAmount)
+	unbondingCoin := sdk.NewInt64Coin(inftypes.BaseCoin, unbondingAmount)
+	completedEpoch := uint64(7)
+	slashFraction := math.LegacyNewDecWithPrec(50, 2)
+
+	s.Require().NoError(s.k.SetCollateral(s.ctx, participant, activeCoin))
+	s.Require().NoError(s.k.AddUnbondingCollateral(s.ctx, participant, completedEpoch, unbondingCoin))
+
+	expectedSlashed := math.NewInt(50)
+	s.bankKeeper.EXPECT().
+		SendCoinsFromModuleToModule(s.ctx, types.ModuleName, govtypes.ModuleName, gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx sdk.Context, senderModule, recipientModule string, amt sdk.Coins, memo string) error {
+			s.Require().Equal(expectedSlashed, amt.AmountOf(inftypes.BaseCoin))
+			return nil
+		}).
+		Times(1)
+
+	slashed, err := s.k.Slash(s.ctx, participant, slashFraction, inftypes.SlashReasonInvalidation, math.ZeroInt())
+	s.Require().NoError(err)
+	s.Require().Equal(expectedSlashed, slashed.Amount)
+
+	postSlashUnbondingAmount := math.NewInt(unbondingAmount / 2)
+	postSlashUnbonding, found := s.k.GetUnbondingCollateral(s.ctx, participant, completedEpoch)
+	s.Require().True(found)
+	s.Require().Equal(postSlashUnbondingAmount, postSlashUnbonding.Amount.Amount)
+
+	expectedReleasedCoin := sdk.NewCoin(inftypes.BaseCoin, postSlashUnbondingAmount)
+	s.bankKeeper.EXPECT().
+		SendCoinsFromModuleToAccount(s.ctx, types.ModuleName, participant, gomock.Eq(sdk.NewCoins(expectedReleasedCoin)), gomock.Any()).
+		Return(nil).
+		Times(1)
+	s.bankKeeper.EXPECT().
+		LogSubAccountTransaction(s.ctx, participantStr, types.ModuleName, types.SubAccountUnbonding, gomock.Eq(expectedReleasedCoin), gomock.Any()).
+		Times(1)
+
+	s.Require().NoError(s.k.AdvanceEpoch(s.ctx, completedEpoch))
+
+	_, found = s.k.GetUnbondingCollateral(s.ctx, participant, completedEpoch)
+	s.Require().False(found)
+
+	postSlashActive, found := s.k.GetCollateral(s.ctx, participant)
+	s.Require().True(found)
+	s.Require().Equal(math.NewInt(activeAmount/2), postSlashActive.Amount)
+}
diff --git a/inference-chain/x/collateral/keeper/keeper.go b/inference-chain/x/collateral/keeper/keeper.go
index ce076af3a9..bd4ea524ae 100644
--- a/inference-chain/x/collateral/keeper/keeper.go
+++ b/inference-chain/x/collateral/keeper/keeper.go
@@ -23,6 +23,10 @@ type (
 		provider types.RequiredCollateralProvider
 	}
 
+	maintenanceCheckerRef struct {
+		checker types.MaintenanceChecker
+	}
+
 	// UnbondingIndexes groups the secondary indexes for the UnbondingCollateral map
 	UnbondingIndexes struct {
 		// ByParticipant indexes primary keys by participant address, to allow queries by participant
@@ -41,6 +45,7 @@ type (
 		bankViewKeeper        types.BankKeeper
 		bookkeepingBankKeeper types.BookkeepingBankKeeper
 		collateralProviderRef *collateralProviderRef
+		maintenanceRef        *maintenanceCheckerRef
 		params                collections.Item[types.Params]
 		CollateralMap         collections.Map[sdk.AccAddress, sdk.Coin]
 		Schema                collections.Schema
@@ -88,6 +93,7 @@ func NewKeeper(
 		bankViewKeeper:        bankKeeper,
 		bookkeepingBankKeeper: bookkeepingBankKeeper,
 		collateralProviderRef: &collateralProviderRef{},
+		maintenanceRef:        &maintenanceCheckerRef{},
 		params:                collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),
 		CollateralMap:         collections.NewMap(sb, types.CollateralKey, "collateral", sdk.AccAddressKey, codec.CollValue[sdk.Coin](cdc)),
 		CurrentEpoch:          collections.NewItem(sb, types.CurrentEpochKey, "current_epoch", collections.Uint64Value),
@@ -127,6 +133,20 @@ func (k *Keeper) SetRequiredCollateralProvider(collateralProvider types.Required
 	k.collateralProviderRef.provider = collateralProvider
 }
 
+// SetMaintenanceChecker sets the maintenance checker for defense-in-depth hook guards.
+func (k *Keeper) SetMaintenanceChecker(checker types.MaintenanceChecker) {
+	k.maintenanceRef.checker = checker
+}
+
+// IsParticipantInActiveMaintenance returns true if the maintenance checker is set
+// and the participant is currently in an active maintenance window.
+func (k Keeper) IsParticipantInActiveMaintenance(ctx context.Context, participant sdk.AccAddress) bool {
+	if k.maintenanceRef.checker == nil {
+		return false
+	}
+	return k.maintenanceRef.checker.IsParticipantInActiveMaintenance(ctx, participant)
+}
+
 // GetAuthority returns the module's authority.
 func (k Keeper) GetAuthority() string {
 	return k.authority
diff --git a/inference-chain/x/collateral/module/hooks.go b/inference-chain/x/collateral/module/hooks.go
index b7e7867a48..14ea39b7f1 100644
--- a/inference-chain/x/collateral/module/hooks.go
+++ b/inference-chain/x/collateral/module/hooks.go
@@ -43,8 +43,31 @@ func (h StakingHooks) AfterValidatorBonded(ctx context.Context, consAddr sdk.Con
 
 func (h StakingHooks) AfterValidatorBeginUnbonding(ctx context.Context, consAddr sdk.ConsAddress, valAddr sdk.ValAddress) error {
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	accAddr := sdk.AccAddress(valAddr)
+
+	// Defense in depth: do not mark maintenance-covered participants as jailed.
+	// Primary enforcement of liveness exemption lives in the x/slashing fork
+	// (missed-signature counters are frozen during active maintenance), which
+	// suppresses the jailing path that fires this hook. This guardrail covers
+	// the failure mode where the slashing exemption misses for any reason.
+	//
+	// Trade-off: this hook also fires on *voluntary* unbonding (e.g., the
+	// validator drops below the minimum self-delegation). A maintenance-
+	// covered participant who voluntarily unbonds during their window will
+	// not be marked jailed here. That is acceptable: voluntary unbonding is
+	// rare during a short maintenance window, and the participant's status
+	// will reconcile via AfterValidatorBonded / RemoveJailed once unbonding
+	// completes or the validator is rebonded. We accept the rare false-negative
+	// in exchange for closing the more impactful false-positive (a maintenance-
+	// covered validator silently jailed by a slashing-fork bug).
+	if h.k.IsParticipantInActiveMaintenance(ctx, accAddr) {
+		h.k.Logger().Info("Staking hook: AfterValidatorBeginUnbonding skipped for maintenance-covered participant",
+			"validator_address", valAddr.String(), "height", sdkCtx.BlockHeight())
+		return nil
+	}
+
 	// When a validator is jailed, we mark their corresponding participant as jailed in our module.
-	h.k.SetJailed(sdkCtx, sdk.AccAddress(valAddr))
+	h.k.SetJailed(sdkCtx, accAddr)
 	h.k.Logger().Debug("Staking hook: AfterValidatorBeginUnbonding, set jailed status", "validator_address", valAddr.String(), "height", sdkCtx.BlockHeight())
 	return nil
 }
@@ -74,6 +97,15 @@ func (h StakingHooks) BeforeValidatorSlashed(ctx context.Context, valAddr sdk.Va
 
 	accAddr := sdk.AccAddress(valAddr)
 
+	// Note: do NOT short-circuit here for maintenance. The SDK's
+	// staking.Slash() call site invokes this hook for ALL slash reasons
+	// (downtime AND double-sign / equivocation). Skipping here would let an
+	// attacker schedule a maintenance window and double-sign without losing
+	// collateral. Downtime exemption is enforced upstream in x/slashing's
+	// liveness accounting (the SDK fork freezes missed-signature counters
+	// during active maintenance), so by the time we reach this hook the
+	// remaining slash is genuinely punitive and must be applied.
+
 	h.k.Logger().Debug("Staking hook: Slashing collateral for validator",
 		"validator_address", valAddr.String(),
 		"participant_address", accAddr.String(),
diff --git a/inference-chain/x/collateral/types/expected_keepers.go b/inference-chain/x/collateral/types/expected_keepers.go
index ff8c28ffc1..2d680e189c 100644
--- a/inference-chain/x/collateral/types/expected_keepers.go
+++ b/inference-chain/x/collateral/types/expected_keepers.go
@@ -39,3 +39,11 @@ type ParamSubspace interface {
 type RequiredCollateralProvider interface {
 	GetRequiredCollateralForSlash(ctx context.Context, participantAddress sdk.AccAddress) math.Int
 }
+
+// MaintenanceChecker provides a read-only check for whether a participant
+// is currently in an active maintenance window. Used as defense-in-depth
+// by collateral hooks to suppress downtime-driven collateral side effects
+// for maintenance-covered participants.
+type MaintenanceChecker interface {
+	IsParticipantInActiveMaintenance(ctx context.Context, participant sdk.AccAddress) bool
+}
diff --git a/inference-chain/x/inference/calculations/should_validate.go b/inference-chain/x/inference/calculations/should_validate.go
index ff11f335d7..ced5a1279b 100644
--- a/inference-chain/x/inference/calculations/should_validate.go
+++ b/inference-chain/x/inference/calculations/should_validate.go
@@ -14,9 +14,9 @@ import (
 func ShouldValidate(
 	seed int64,
 	inferenceDetails *types.InferenceValidationDetails,
-	totalPower uint32,
-	validatorPower uint32,
-	executorPower uint32,
+	totalPower uint64,
+	validatorPower uint64,
+	executorPower uint64,
 	validationParams *types.ValidationParams,
 	debug bool,
 ) (bool, string) {
@@ -31,7 +31,7 @@ func ShouldValidate(
 	// algebraic simplification/removal of temp variables
 	targetValidations := maxValidationAverage.Sub(rangeSize.Mul(executorReputation))
 	// 100% rep will be minValidationAverage, 0% rep will be maxValidationAverage
-	ourProbability := targetValidations.Mul(decimal.NewFromInt(int64(validatorPower))).Div(decimal.NewFromInt(int64(totalPower - executorPower)))
+	ourProbability := targetValidations.Mul(decimal.NewFromUint64(validatorPower)).Div(decimal.NewFromUint64(totalPower - executorPower))
 	if ourProbability.GreaterThan(one) {
 		ourProbability = one
 	}
diff --git a/inference-chain/x/inference/calculations/should_validate_test.go b/inference-chain/x/inference/calculations/should_validate_test.go
index 460c885b35..b9fab07990 100644
--- a/inference-chain/x/inference/calculations/should_validate_test.go
+++ b/inference-chain/x/inference/calculations/should_validate_test.go
@@ -18,9 +18,9 @@ func TestShouldValidate(t *testing.T) {
 		name                 string
 		seed                 int64
 		inferenceDetails     *types.InferenceValidationDetails
-		totalPower           uint32
-		validatorPower       uint32
-		executorPower        uint32
+		totalPower           uint64
+		validatorPower       uint64
+		executorPower        uint64
 		expectedResult       bool
 		expectedProbability  float64
 		minValidationAverage float64
diff --git a/inference-chain/x/inference/keeper/account_helpers.go b/inference-chain/x/inference/keeper/account_helpers.go
new file mode 100644
index 0000000000..457fbdb4cc
--- /dev/null
+++ b/inference-chain/x/inference/keeper/account_helpers.go
@@ -0,0 +1,81 @@
+package keeper
+
+import (
+	"context"
+	"encoding/base64"
+	"math"
+
+	sdkerrors "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	authztypes "github.com/cosmos/cosmos-sdk/x/authz"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func ensureParticipantEpochStats(participant *types.Participant) {
+	if participant.CurrentEpochStats == nil {
+		participant.CurrentEpochStats = types.NewCurrentEpochStats()
+	}
+}
+
+func (k msgServer) AddToCoinBalance(ctx context.Context, participant *types.Participant, amount uint64, memo string) error {
+	if amount > uint64(math.MaxInt64) {
+		return sdkerrors.Wrapf(types.ErrArithmeticOverflow, "amount %d exceeds int64 max", amount)
+	}
+	ensureParticipantEpochStats(participant)
+	participant.CoinBalance += int64(amount)
+	participant.CurrentEpochStats.EarnedCoins += amount
+	k.SafeLogSubAccountTransactionUint(ctx, types.ModuleName, participant.Address, types.OwedSubAccount, amount, memo)
+	return nil
+}
+
+func (k msgServer) GetAccountPubKey(ctx context.Context, address string) (string, error) {
+	accAddr, err := sdk.AccAddressFromBech32(address)
+	if err != nil {
+		return "", err
+	}
+	acc := k.AccountKeeper.GetAccount(ctx, accAddr)
+	if acc == nil || acc.GetPubKey() == nil {
+		return "", types.ErrPubKeyUnavailable
+	}
+	return base64.StdEncoding.EncodeToString(acc.GetPubKey().Bytes()), nil
+}
+
+func (k msgServer) GetAccountPubKeysWithGrantees(ctx context.Context, granterAddress string) ([]string, error) {
+	pubkeys := make([]string, 0, 1)
+	granterPubKey, err := k.GetAccountPubKey(ctx, granterAddress)
+	if err != nil {
+		return nil, err
+	}
+	pubkeys = append(pubkeys, granterPubKey)
+
+	nextKey := []byte(nil)
+	for {
+		resp, err := k.AuthzKeeper.GranterGrants(ctx, &authztypes.QueryGranterGrantsRequest{
+			Granter: granterAddress,
+			Pagination: &query.PageRequest{
+				Key: nextKey,
+			},
+		})
+		if err != nil {
+			return nil, err
+		}
+		for _, grant := range resp.Grants {
+			if grant.Authorization == nil {
+				continue
+			}
+			if _, ok := grant.Authorization.GetCachedValue().(*authztypes.GenericAuthorization); !ok {
+				continue
+			}
+			granteePubKey, err := k.GetAccountPubKey(ctx, grant.Grantee)
+			if err == nil {
+				pubkeys = append(pubkeys, granteePubKey)
+			}
+		}
+		if resp.Pagination == nil || len(resp.Pagination.NextKey) == 0 {
+			break
+		}
+		nextKey = resp.Pagination.NextKey
+	}
+	return pubkeys, nil
+}
diff --git a/inference-chain/x/inference/keeper/accountsettle.go b/inference-chain/x/inference/keeper/accountsettle.go
index 2b57ffe18f..c36dfe6ca7 100644
--- a/inference-chain/x/inference/keeper/accountsettle.go
+++ b/inference-chain/x/inference/keeper/accountsettle.go
@@ -3,6 +3,7 @@ package keeper
 import (
 	"context"
 	"fmt"
+	"math/bits"
 
 	"cosmossdk.io/log"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -34,6 +35,77 @@ func (k *Keeper) GetSettleParameters(ctx context.Context) (*SettleParameters, er
 	}, nil
 }
 
+type bitcoinRewardInputs struct {
+	Participants       []types.Participant
+	EpochGroupData     types.EpochGroupData
+	Params             types.Params
+	ValidationParams   *types.ValidationParams
+	SettleParameters   *SettleParameters
+	ParticipantMLNodes map[string]map[string][]*types.MLNodeInfo
+	RewardTransfers    []*types.DelegationRewardTransfer
+	RewardPenalties    []*types.DelegationRewardPenalty
+}
+
+func (k *Keeper) loadBitcoinRewardInputs(ctx context.Context, epochIndex uint64) (*bitcoinRewardInputs, bool, error) {
+	activeParticipants, found := k.GetActiveParticipants(ctx, epochIndex)
+	if !found {
+		return nil, false, nil
+	}
+	activeParticipantAddresses := make([]string, len(activeParticipants.Participants))
+	for i, participant := range activeParticipants.Participants {
+		activeParticipantAddresses[i] = participant.Index
+	}
+	allParticipants := k.GetParticipants(ctx, activeParticipantAddresses)
+
+	data, found := k.GetEpochGroupData(ctx, epochIndex, "")
+	if !found {
+		return nil, true, types.ErrCurrentEpochGroupNotFound
+	}
+
+	params, err := k.GetParams(ctx)
+	if err != nil {
+		return nil, true, err
+	}
+
+	settleParameters, err := k.GetSettleParameters(ctx)
+	if err != nil {
+		return nil, true, err
+	}
+
+	participantMLNodes := k.AggregateMLNodesFromModelSubgroups(ctx, epochIndex, data.ValidationWeights)
+	rewardTransfers, err := k.GetDelegationRewardTransfersForEpoch(ctx, epochIndex)
+	if err != nil {
+		return nil, true, err
+	}
+	rewardPenalties, err := k.GetDelegationRewardPenaltiesForEpoch(ctx, epochIndex)
+	if err != nil {
+		return nil, true, err
+	}
+	validationParams := params.ValidationParams
+	if validationParams == nil {
+		validationParams = types.DefaultValidationParams()
+		k.LogWarn("ValidationParams not found, using default ones", types.Settle)
+	}
+
+	if graceParams, ok := k.GetPunishmentGraceEpoch(ctx, epochIndex); ok && graceParams.BinomTestP0 != nil {
+		graceValidationParams := *validationParams
+		graceValidationParams.BinomTestP0 = graceParams.BinomTestP0
+		validationParams = &graceValidationParams
+		k.LogInfo("using grace BinomTestP0", types.Settle, "epoch", epochIndex)
+	}
+
+	return &bitcoinRewardInputs{
+		Participants:       allParticipants,
+		EpochGroupData:     data,
+		Params:             params,
+		ValidationParams:   validationParams,
+		SettleParameters:   settleParameters,
+		ParticipantMLNodes: participantMLNodes,
+		RewardTransfers:    rewardTransfers,
+		RewardPenalties:    rewardPenalties,
+	}, true, nil
+}
+
 func CheckAndPunishForDowntimeForParticipants(participants []types.Participant, rewards map[string]uint64, p0 *types.Decimal, logger log.Logger) {
 	for _, participant := range participants {
 		rewards[participant.Address] = CheckAndPunishForDowntimeForParticipant(participant, rewards[participant.Address], p0, logger)
@@ -101,75 +173,48 @@ func (k *Keeper) SettleAccounts(ctx context.Context, currentEpochIndex uint64, p
 	k.LogInfo("SettleAccounts", types.Settle, "currentEpochIndex", currentEpochIndex)
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
 	blockHeight := sdkCtx.BlockHeight()
-	activeParticipants, found := k.GetActiveParticipants(ctx, currentEpochIndex)
+	inputs, found, err := k.loadBitcoinRewardInputs(ctx, currentEpochIndex)
 	if !found {
 		k.LogError("Active participants not found", types.Settle, "currentEpochIndex", currentEpochIndex)
 		return nil
 	}
-	activeParticipantAddresses := make([]string, len(activeParticipants.Participants))
-	for i, participant := range activeParticipants.Participants {
-		activeParticipantAddresses[i] = participant.Index
+	if err != nil {
+		k.LogError("Error loading bitcoin reward inputs", types.Settle, "error", err)
+		return err
 	}
-	allParticipants := k.GetParticipants(ctx, activeParticipantAddresses)
+	allParticipants := inputs.Participants
 
 	k.LogInfo("Block height", types.Settle, "height", blockHeight)
 	k.LogInfo("Got all participants", types.Settle, "participants", len(allParticipants))
 
-	data, found := k.GetEpochGroupData(ctx, currentEpochIndex, "")
+	data := inputs.EpochGroupData
 	k.LogInfo("Settling for block", types.Settle, "height", currentEpochIndex)
-	if !found {
-		k.LogError("Epoch group data not found", types.Settle, "height", currentEpochIndex)
-		return types.ErrCurrentEpochGroupNotFound
-	}
 	seedSigMap := make(map[string]string)
 	for _, seedSig := range data.MemberSeedSignatures {
 		seedSigMap[seedSig.MemberAddress] = seedSig.Signature
 	}
 
 	// Check governance flag to determine which reward system to use
-	params, err := k.GetParams(ctx)
-	if err != nil {
-		k.LogError("Error getting params", types.Settle, "error", err)
-		return err
-	}
+	params := inputs.Params
 	var amounts []*SettleResult
 	var rewardAmount int64
 	var governanceRewardAmount int64
-	settleParameters, err := k.GetSettleParameters(ctx)
-	if err != nil {
-		k.LogError("Error getting settle parameters", types.Settle, "error", err)
-		return err
-	}
+	settleParameters := inputs.SettleParameters
 	k.LogInfo("Settle parameters", types.Settle, "parameters", settleParameters)
 
 	// Use Bitcoin-style fixed reward system with its own parameters
 	k.LogInfo("Using Bitcoin-style reward system", types.Settle)
 
-	// Aggregate MLNodes from model-specific subgroups for collateral weight normalization.
-	participantMLNodes := k.AggregateMLNodesFromModelSubgroups(ctx, currentEpochIndex, data.ValidationWeights)
-
-	// Check if this is a grace epoch and override BinomTestP0 if so
-	validationParams := params.ValidationParams
-	if validationParams == nil {
-		validationParams = types.DefaultValidationParams()
-		k.LogWarn("ValidationParams not found, using default ones", types.Settle)
-	}
-
-	if graceParams, ok := k.GetPunishmentGraceEpoch(ctx, currentEpochIndex); ok && graceParams.BinomTestP0 != nil {
-		graceValidationParams := *validationParams
-		graceValidationParams.BinomTestP0 = graceParams.BinomTestP0
-		validationParams = &graceValidationParams
-		k.LogInfo("using grace BinomTestP0", types.Settle, "epoch", currentEpochIndex)
-	}
-
 	var bitcoinResult BitcoinResult
-	amounts, bitcoinResult, err = GetBitcoinSettleAmounts(
+	amounts, bitcoinResult, err = GetBitcoinSettleAmountsWithTransfers(
 		allParticipants,
 		&data,
 		params.BitcoinRewardParams,
-		validationParams,
+		inputs.ValidationParams,
 		settleParameters,
-		participantMLNodes,
+		inputs.ParticipantMLNodes,
+		inputs.RewardTransfers,
+		inputs.RewardPenalties,
 		k.Logger(),
 	)
 	if err != nil {
@@ -256,8 +301,9 @@ func (k *Keeper) SettleAccounts(ctx context.Context, currentEpochIndex uint64, p
 			k.LogError("Error calculating settle amounts", types.Settle, "error", amount.Error, "participant", amount.Settle.Participant)
 			continue
 		}
-		totalPayment := amount.Settle.WorkCoins + amount.Settle.RewardCoins
-		if totalPayment == 0 {
+		// checked add: a wrapping sum to 0 would skip a real payout
+		paymentSum, paymentCarry := bits.Add64(amount.Settle.WorkCoins, amount.Settle.RewardCoins, 0)
+		if paymentCarry == 0 && paymentSum == 0 {
 			k.LogDebug("No payment needed for participant", types.Settle, "address", amount.Settle.Participant)
 			continue
 		}
@@ -314,6 +360,9 @@ func (rc *DistributedCoinInfo) calculateDistribution(participantWorkDone int64)
 }
 
 type SettleResult struct {
-	Settle *types.SettleAmount
-	Error  error
+	Settle                  *types.SettleAmount
+	Error                   error
+	ParticipantRewardWeight uint64
+	ParticipantFullWeight   uint64
+	TotalRewardWeight       uint64
 }
diff --git a/inference-chain/x/inference/keeper/bitcoin_rewards.go b/inference-chain/x/inference/keeper/bitcoin_rewards.go
index 513523ecdd..257fb7249d 100644
--- a/inference-chain/x/inference/keeper/bitcoin_rewards.go
+++ b/inference-chain/x/inference/keeper/bitcoin_rewards.go
@@ -34,6 +34,30 @@ func GetBitcoinSettleAmounts(
 	settleParams *SettleParameters,
 	participantMLNodes map[string]map[string][]*types.MLNodeInfo,
 	logger log.Logger,
+) ([]*SettleResult, BitcoinResult, error) {
+	return GetBitcoinSettleAmountsWithTransfers(
+		participants,
+		epochGroupData,
+		bitcoinParams,
+		validationParams,
+		settleParams,
+		participantMLNodes,
+		nil,
+		nil,
+		logger,
+	)
+}
+
+func GetBitcoinSettleAmountsWithTransfers(
+	participants []types.Participant,
+	epochGroupData *types.EpochGroupData,
+	bitcoinParams *types.BitcoinRewardParams,
+	validationParams *types.ValidationParams,
+	settleParams *SettleParameters,
+	participantMLNodes map[string]map[string][]*types.MLNodeInfo,
+	delegationRewardTransfers []*types.DelegationRewardTransfer,
+	delegationRewardPenalties []*types.DelegationRewardPenalty,
+	logger log.Logger,
 ) ([]*SettleResult, BitcoinResult, error) {
 	if participants == nil {
 		return nil, BitcoinResult{Amount: 0}, fmt.Errorf("participants cannot be nil")
@@ -55,12 +79,14 @@ func GetBitcoinSettleAmounts(
 	// 3. Complete distribution with remainder handling
 	// 4. Invalid participant handling
 	// 5. Error management
-	settleResults, bitcoinResult, err := CalculateParticipantBitcoinRewards(
+	settleResults, bitcoinResult, err := CalculateParticipantBitcoinRewardsWithTransfers(
 		participants,
 		epochGroupData,
 		bitcoinParams,
 		validationParams,
 		participantMLNodes,
+		delegationRewardTransfers,
+		delegationRewardPenalties,
 		logger,
 	)
 	if err != nil {
@@ -126,6 +152,115 @@ func saturatingAddUint64Max(a int64, b uint64) int64 {
 	return a + int64(b) // safe because b < headroom <= MaxInt64
 }
 
+func positiveUint64(v int64) uint64 {
+	if v <= 0 {
+		return 0
+	}
+	return uint64(v)
+}
+
+func addUint64Saturating(a, b uint64) uint64 {
+	sum, carry := bits.Add64(a, b, 0)
+	if carry != 0 {
+		return math.MaxUint64
+	}
+	return sum
+}
+
+func delegationShareOfWeight(share *types.Decimal, weight uint64) uint64 {
+	if share == nil || weight == 0 || weight > math.MaxInt64 {
+		return 0
+	}
+	shareDec, err := share.ToLegacyDec()
+	if err != nil || shareDec.IsZero() {
+		return 0
+	}
+	amount := shareDec.MulInt64(int64(weight)).TruncateInt64()
+	return positiveUint64(amount)
+}
+
+func applyDelegationRewardPenalties(
+	participantWeights map[string]uint64,
+	penalties []*types.DelegationRewardPenalty,
+	logger log.Logger,
+) {
+	if len(penalties) == 0 {
+		return
+	}
+
+	baseRewardable := make(map[string]uint64, len(participantWeights))
+	for addr, w := range participantWeights {
+		baseRewardable[addr] = w
+	}
+
+	for _, penalty := range penalties {
+		if penalty == nil || penalty.Participant == "" {
+			continue
+		}
+		if _, ok := participantWeights[penalty.Participant]; !ok {
+			continue
+		}
+		removed := delegationShareOfWeight(penalty.PenaltyFraction, baseRewardable[penalty.Participant])
+		if removed > participantWeights[penalty.Participant] {
+			removed = participantWeights[penalty.Participant]
+		}
+		if removed == 0 {
+			continue
+		}
+		participantWeights[penalty.Participant] -= removed
+		logger.Info("Bitcoin Rewards: applied reward-only penalty",
+			"participant", penalty.Participant,
+			"removed", removed)
+	}
+}
+
+// applyDelegationRewardTransfers makes delegation reward sharing source-aware so
+// an excluded or downtimed delegator cannot inflate a delegatee's reward.
+//
+// All delegator-side reads use baseRewardable, a snapshot taken before any
+// transfer mutates the map. The current source balance clamps cumulative
+// outgoing transfers to the source's surviving rewardable weight.
+func applyDelegationRewardTransfers(
+	participantWeights map[string]uint64,
+	transfers []*types.DelegationRewardTransfer,
+	logger log.Logger,
+) {
+	if len(transfers) == 0 {
+		return
+	}
+
+	baseRewardable := make(map[string]uint64, len(participantWeights))
+	for addr, w := range participantWeights {
+		baseRewardable[addr] = w
+	}
+
+	for _, transfer := range transfers {
+		if transfer == nil || transfer.From == "" {
+			continue
+		}
+		if _, ok := participantWeights[transfer.From]; !ok {
+			continue
+		}
+
+		amount := delegationShareOfWeight(transfer.Share, baseRewardable[transfer.From])
+		if amount > participantWeights[transfer.From] {
+			amount = participantWeights[transfer.From]
+		}
+		if amount == 0 {
+			continue
+		}
+		participantWeights[transfer.From] -= amount
+		if transfer.To != "" && participantWeights[transfer.To] > 0 {
+			participantWeights[transfer.To] = addUint64Saturating(participantWeights[transfer.To], amount)
+		}
+		logger.Info("Bitcoin Rewards: applied reward-only delegation transfer",
+			"from", transfer.From,
+			"to", transfer.To,
+			"modelId", transfer.ModelId,
+			"amount", amount)
+	}
+}
+
 // CalculateFixedEpochReward implements the exponential decay reward calculation
 // Uses the formula: current_reward = initial_reward × exp(decay_rate × epochs_elapsed)
 func CalculateFixedEpochReward(epochsSinceGenesis uint64, initialReward uint64, decayRate *types.Decimal) (uint64, error) {
@@ -267,19 +402,43 @@ func ApplyPowerCappingForWeights(participants []*types.ActiveParticipant) ([]*ty
 		return participants, false
 	}
 
-	// Calculate total weight
+	// Calculate total weight and count participants that actually hold power.
+	// Non-positive weights are invisible to all capping math for consistency:
+	// zero/negative entries are excluded from the cap threshold scan in
+	// CalculateOptimalCap, so they must not influence the cap percentage
+	// selection or the total passed to the cap<=0 degeneracy guard either.
+	//
+	// Weight == 0 is a real, reachable state: a participant whose entire PoC
+	// weight sits on a model group that failed eligibility (VMin etc.) stays
+	// in activeParticipants with consensus weight 0 (gonka-testnet-4 epoch 15
+	// incident). If counted, such an entry forces the stricter 30% cap onto
+	// e.g. 3 real hosts, which is mathematically infeasible and would disable
+	// capping entirely.
+	//
+	// Weight < 0 is NOT produced by any current caller (both the epoch
+	// pipeline and settlement clamp weights to >= 0 upstream); excluding
+	// negatives here is defense in depth only, so a hypothetical negative
+	// weight cannot drag the total to <=0 and defeat the cap<=0 guard while
+	// positive power still exists.
 	totalWeight := int64(0)
+	positiveCount := 0
 	for _, p := range participants {
-		totalWeight += p.Weight
+		if p.Weight > 0 {
+			totalWeight += p.Weight
+			positiveCount++
+		}
+	}
+
+	if positiveCount <= 1 {
+		return participants, false
 	}
 
 	// Use standard 30% cap
 	maxPercentageDecimal := types.DecimalFromFloat(0.30)
 
 	// Apply dynamic limits for small networks
-	participantCount := len(participants)
-	if participantCount < 4 {
-		adjustedLimit := getSmallNetworkLimit(participantCount)
+	if positiveCount < 4 {
+		adjustedLimit := getSmallNetworkLimit(positiveCount)
 		if adjustedLimit.ToDecimal().GreaterThan(maxPercentageDecimal.ToDecimal()) {
 			maxPercentageDecimal = adjustedLimit
 		}
@@ -304,13 +463,21 @@ func CalculateOptimalCap(participants []*types.ActiveParticipant, totalPower int
 		Index       int
 	}
 
-	participantPowers := make([]ParticipantPowerInfo, participantCount)
+	participantPowers := make([]ParticipantPowerInfo, 0, participantCount)
 	for i, participant := range participants {
-		participantPowers[i] = ParticipantPowerInfo{
+		if participant.Weight <= 0 {
+			continue
+		}
+		participantPowers = append(participantPowers, ParticipantPowerInfo{
 			Participant: participant,
 			Power:       participant.Weight,
 			Index:       i,
-		}
+		})
+	}
+
+	positiveCount := len(participantPowers)
+	if positiveCount <= 1 {
+		return participants, totalPower, false
 	}
 
 	// Sort by power (smallest to largest) - simple bubble sort for small arrays
@@ -325,9 +492,9 @@ func CalculateOptimalCap(participants []*types.ActiveParticipant, totalPower int
 	// Iterate through sorted powers to find threshold
 	cap := int64(-1)
 	sumPrev := int64(0)
-	for k := 0; k < participantCount; k++ {
+	for k := 0; k < positiveCount; k++ {
 		currentPower := participantPowers[k].Power
-		weightedTotal := sumPrev + currentPower*int64(participantCount-k)
+		weightedTotal := sumPrev + currentPower*int64(positiveCount-k)
 
 		weightedTotalDecimal := decimal.NewFromInt(weightedTotal)
 		threshold := maxPercentageDecimal.Mul(weightedTotalDecimal)
@@ -337,7 +504,7 @@ func CalculateOptimalCap(participants []*types.ActiveParticipant, totalPower int
 			sumPrevDecimal := decimal.NewFromInt(sumPrev)
 			numerator := maxPercentageDecimal.Mul(sumPrevDecimal)
 
-			remainingParticipants := decimal.NewFromInt(int64(participantCount - k))
+			remainingParticipants := decimal.NewFromInt(int64(positiveCount - k))
 			maxPercentageTimesRemaining := maxPercentageDecimal.Mul(remainingParticipants)
 			denominator := one.Sub(maxPercentageTimesRemaining)
 
@@ -358,6 +525,18 @@ func CalculateOptimalCap(participants []*types.ActiveParticipant, totalPower int
 	if cap == -1 {
 		return participants, totalPower, false
 	}
+	// A non-positive cap is never a valid outcome: applying it would zero
+	// every participant (the gonka-testnet-4 epoch 15 failure mode), so skip
+	// capping instead. This branch is unreachable when called through
+	// ApplyPowerCappingForWeights -- its percentage is matched to the
+	// positive-participant count (50%/2, 40%/3, 30%/4+), which makes the
+	// formula always yield cap >= 1 for integer weights. It remains as a
+	// last-resort brake for direct callers of this exported function, where
+	// an arbitrary maxPercentage with percentage*count < 1 degenerates the
+	// formula to zero.
+	if cap <= 0 {
+		return participants, totalPower, false
+	}
 
 	// Apply cap to all participants in original order
 	cappedParticipants := make([]*types.ActiveParticipant, len(participants))
@@ -544,6 +723,28 @@ func CalculateParticipantBitcoinRewards(
 	validationParams *types.ValidationParams,
 	participantMLNodes map[string]map[string][]*types.MLNodeInfo,
 	logger log.Logger,
+) ([]*SettleResult, BitcoinResult, error) {
+	return CalculateParticipantBitcoinRewardsWithTransfers(
+		participants,
+		epochGroupData,
+		bitcoinParams,
+		validationParams,
+		participantMLNodes,
+		nil,
+		nil,
+		logger,
+	)
+}
+
+func CalculateParticipantBitcoinRewardsWithTransfers(
+	participants []types.Participant,
+	epochGroupData *types.EpochGroupData,
+	bitcoinParams *types.BitcoinRewardParams,
+	validationParams *types.ValidationParams,
+	participantMLNodes map[string]map[string][]*types.MLNodeInfo,
+	delegationRewardTransfers []*types.DelegationRewardTransfer,
+	delegationRewardPenalties []*types.DelegationRewardPenalty,
+	logger log.Logger,
 ) ([]*SettleResult, BitcoinResult, error) {
 	// Parameter validation
 	if participants == nil {
@@ -695,6 +896,9 @@ func CalculateParticipantBitcoinRewards(
 		logger.Info("Bitcoin Rewards: Skipping downtime punishment (outage circuit breaker)", "epoch", currentEpoch)
 	}
 	logger.Info("Bitcoin Rewards: weights after downtime check", "participants", participantWeights)
+	applyDelegationRewardPenalties(participantWeights, delegationRewardPenalties, logger)
+	applyDelegationRewardTransfers(participantWeights, delegationRewardTransfers, logger)
+	logger.Info("Bitcoin Rewards: weights after delegation reward transfers", "participants", participantWeights)
 	// IMPORTANT: We intentionally DO NOT renormalize totalPoCWeightBeforeDowntime after downtime punishment,
 	// invalidation, or CPoC reductions. Any "missed" share becomes undistributed and transferred to governance.
 
@@ -739,8 +943,13 @@ func CalculateParticipantBitcoinRewards(
 				if result.IsUint64() {
 					rewardCoins = result.Uint64()
 				} else {
-					// If still too large, participant gets maximum possible uint64
-					rewardCoins = ^uint64(0) // Max uint64
+					// cap to MaxInt64 — MaxUint64 sentinel would wrap to 0 when summed with WorkCoins downstream
+					logger.Error("bitcoin reward division exceeded uint64; capping to MaxInt64",
+						"participant", participant.Address,
+						"participantWeight", participantWeight,
+						"fixedEpochReward", fixedEpochReward,
+						"totalFullWeight", totalPoCWeightBeforeDowntime)
+					rewardCoins = uint64(math.MaxInt64)
 				}
 				totalDistributed += rewardCoins
 			}
@@ -762,8 +971,11 @@ func CalculateParticipantBitcoinRewards(
 
 		// Create SettleResult
 		settleResults = append(settleResults, &SettleResult{
-			Settle: settleAmount,
-			Error:  settleError,
+			Settle:                  settleAmount,
+			Error:                   settleError,
+			ParticipantRewardWeight: participantWeights[participant.Address],
+			ParticipantFullWeight:   participantFullWeights[participant.Address],
+			TotalRewardWeight:       totalPoCWeightBeforeDowntime,
 		})
 	}
 
diff --git a/inference-chain/x/inference/keeper/bitcoin_rewards_test.go b/inference-chain/x/inference/keeper/bitcoin_rewards_test.go
index 193776340e..6c1e5229b7 100644
--- a/inference-chain/x/inference/keeper/bitcoin_rewards_test.go
+++ b/inference-chain/x/inference/keeper/bitcoin_rewards_test.go
@@ -61,6 +61,161 @@ func createTestValidationWeight(memberAddress string, weight int64, reputation i
 	}
 }
 
+func TestApplyDelegationRewardTransfers_RewardOnlyTransfer(t *testing.T) {
+	weights := map[string]uint64{
+		"alice": 1000,
+		"bob":   500,
+	}
+	transfers := []*types.DelegationRewardTransfer{
+		{
+			ModelId: "model1",
+			From:    "alice",
+			To:      "bob",
+			Share:   types.DecimalFromFloat(0.1),
+		},
+	}
+
+	applyDelegationRewardTransfers(weights, transfers, createTestLogger(t))
+
+	require.Equal(t, uint64(900), weights["alice"])
+	require.Equal(t, uint64(600), weights["bob"])
+}
+
+func TestApplyDelegationRewardPenalties_ReducesSourceOnly(t *testing.T) {
+	weights := map[string]uint64{
+		"alice": 1000,
+		"bob":   500,
+	}
+	penalties := []*types.DelegationRewardPenalty{
+		{
+			Participant:     "alice",
+			PenaltyFraction: types.DecimalFromFloat(0.1),
+		},
+	}
+
+	applyDelegationRewardPenalties(weights, penalties, createTestLogger(t))
+
+	require.Equal(t, uint64(900), weights["alice"])
+	require.Equal(t, uint64(500), weights["bob"])
+}
+
+func TestApplyDelegationRewardTransfers_RewardOnlyDoesNotReviveZeroWeightDelegatee(t *testing.T) {
+	weights := map[string]uint64{
+		"alice": 1000,
+		"bob":   0,
+	}
+	transfers := []*types.DelegationRewardTransfer{
+		{
+			ModelId: "model1",
+			From:    "alice",
+			To:      "bob",
+			Share:   types.DecimalFromFloat(0.1),
+		},
+	}
+
+	applyDelegationRewardTransfers(weights, transfers, createTestLogger(t))
+
+	require.Equal(t, uint64(900), weights["alice"])
+	require.Equal(t, uint64(0), weights["bob"])
+}
+
+func TestApplyDelegationRewardTransfers_RewardOnlyMultipleTransfersUseSourceSnapshot(t *testing.T) {
+	// Two 10% delegations from the same source must each be computed from the
+	// pre-transfer snapshot (1000), not the already-mutated weight, so both pay
+	// 100 rather than 100 + 90.
+	weights := map[string]uint64{
+		"alice": 1000,
+		"bob":   500,
+		"carol": 500,
+	}
+	transfers := []*types.DelegationRewardTransfer{
+		{ModelId: "model1", From: "alice", To: "bob", Share: types.DecimalFromFloat(0.1)},
+		{ModelId: "model2", From: "alice", To: "carol", Share: types.DecimalFromFloat(0.1)},
+	}
+
+	applyDelegationRewardTransfers(weights, transfers, createTestLogger(t))
+
+	require.Equal(t, uint64(800), weights["alice"])
+	require.Equal(t, uint64(600), weights["bob"])
+	require.Equal(t, uint64(600), weights["carol"])
+}
+
+func TestApplyDelegationRewardPenalties_DuplicateEntriesAreAdditiveAndClamped(t *testing.T) {
+	weights := map[string]uint64{
+		"alice": 1000,
+		"bob":   400,
+	}
+	penalties := []*types.DelegationRewardPenalty{
+		{Participant: "alice", PenaltyFraction: types.DecimalFromFloat(0.5)},
+		{Participant: "alice", PenaltyFraction: types.DecimalFromFloat(0.7)},
+	}
+
+	applyDelegationRewardPenalties(weights, penalties, createTestLogger(t))
+
+	require.Equal(t, uint64(0), weights["alice"])
+	require.Equal(t, uint64(400), weights["bob"])
+}
+
+func TestApplyDelegationRewardPenaltiesThenTransfers_PenaltyReducesTransferBase(t *testing.T) {
+	weights := map[string]uint64{
+		"alice": 1000,
+		"bob":   500,
+	}
+	penalties := []*types.DelegationRewardPenalty{
+		{Participant: "alice", PenaltyFraction: types.DecimalFromFloat(0.8)},
+	}
+	transfers := []*types.DelegationRewardTransfer{
+		{ModelId: "model1", From: "alice", To: "bob", Share: types.DecimalFromFloat(0.3)},
+	}
+
+	applyDelegationRewardPenalties(weights, penalties, createTestLogger(t))
+	applyDelegationRewardTransfers(weights, transfers, createTestLogger(t))
+
+	require.Equal(t, uint64(140), weights["alice"])
+	require.Equal(t, uint64(560), weights["bob"])
+}
+
+func TestCalculateBitcoinRewards_PenaltyDoesNotRenormalizeDenominator(t *testing.T) {
+	bitcoinParams := &types.BitcoinRewardParams{
+		GenesisEpoch:       1,
+		InitialEpochReward: 1000,
+		DecayRate:          types.DecimalFromFloat(0),
+	}
+	epochGroupData := &types.EpochGroupData{
+		EpochIndex: 1,
+		ValidationWeights: []*types.ValidationWeight{
+			createTestValidationWeight("alice", 1000, 0),
+			createTestValidationWeight("bob", 1000, 0),
+		},
+	}
+	participants := []types.Participant{
+		{Address: "alice", Status: types.ParticipantStatus_ACTIVE, CurrentEpochStats: &types.CurrentEpochStats{InferenceCount: 100, MissedRequests: 0}},
+		{Address: "bob", Status: types.ParticipantStatus_ACTIVE, CurrentEpochStats: &types.CurrentEpochStats{InferenceCount: 100, MissedRequests: 0}},
+	}
+	penalties := []*types.DelegationRewardPenalty{
+		{Participant: "alice", PenaltyFraction: types.DecimalFromFloat(0.5)},
+	}
+
+	results, bitcoinResult, err := CalculateParticipantBitcoinRewardsWithTransfers(
+		participants,
+		epochGroupData,
+		bitcoinParams,
+		nil,
+		modelNodesAndScales(epochGroupData),
+		nil,
+		penalties,
+		createTestLogger(t),
+	)
+	require.NoError(t, err)
+	require.Len(t, results, 2)
+
+	require.Equal(t, uint64(250), results[0].Settle.RewardCoins)
+	require.Equal(t, uint64(500), results[1].Settle.RewardCoins)
+	require.Equal(t, uint64(500), results[0].ParticipantRewardWeight)
+	require.Equal(t, uint64(2000), results[0].TotalRewardWeight)
+	require.Equal(t, int64(250), bitcoinResult.GovernanceAmount)
+}
+
 func TestExponent(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -2200,3 +2355,87 @@ func TestGetDynamicP0(t *testing.T) {
 		require.Equal(t, int32(-3), p0.Exponent)
 	})
 }
+
+// Regression: one zero-weight participant in a multi-model settlement must not
+// collapse the entire network to zero capped power (gonka-testnet-4 epoch 15).
+func TestApplyPowerCappingForWeights_SkipsZeroWeightParticipants(t *testing.T) {
+	participants := []*types.ActiveParticipant{
+		{Index: "guardian", Weight: 0},
+		{Index: "host-a", Weight: 10238},
+		{Index: "host-b", Weight: 34658},
+		{Index: "host-c", Weight: 36806},
+	}
+
+	capped, wasCapped := ApplyPowerCappingForWeights(participants)
+
+	total := int64(0)
+	for _, p := range capped {
+		total += p.Weight
+	}
+	require.Positive(t, total, "zero-weight bystander must not zero the network")
+	require.Equal(t, int64(0), capped[0].Weight, "zero-weight participant stays zero")
+	if wasCapped {
+		require.LessOrEqual(t, capped[1].Weight, int64(10238))
+	} else {
+		require.Equal(t, int64(81702), total)
+	}
+}
+
+// Capping must still be effective when zero-weight bystanders are present:
+// the small-network cap percentage is chosen from the positive-weight count,
+// so 3 real hosts get the 40% limit instead of an infeasible 30% one.
+func TestApplyPowerCappingForWeights_ZeroWeightBystanderKeepsCappingEffective(t *testing.T) {
+	participants := []*types.ActiveParticipant{
+		{Index: "guardian", Weight: 0},
+		{Index: "host-a", Weight: 10238},
+		{Index: "host-b", Weight: 34658},
+		{Index: "host-c", Weight: 36806},
+	}
+
+	capped, wasCapped := ApplyPowerCappingForWeights(participants)
+
+	require.True(t, wasCapped, "capping must still apply with a zero-weight bystander")
+	require.Equal(t, int64(0), capped[0].Weight)
+	require.Equal(t, int64(10238), capped[1].Weight)
+	// cap = 0.40 * 10238 / (1 - 0.40*2) = 20476; both large hosts hit it,
+	// each ending at exactly 40% of the new total (10238 + 2*20476 = 51190).
+	require.Equal(t, int64(20476), capped[2].Weight)
+	require.Equal(t, int64(20476), capped[3].Weight)
+}
+
+// A hypothetical negative-weight participant must behave exactly like a
+// zero-weight one: invisible to the capping math, unable to drag the total
+// power to <=0 and defeat the cap<=0 degeneracy guard, and left unmodified.
+func TestApplyPowerCappingForWeights_NegativeWeightIsInvisible(t *testing.T) {
+	participants := []*types.ActiveParticipant{
+		{Index: "broken", Weight: -1_000_000},
+		{Index: "host-a", Weight: 10238},
+		{Index: "host-b", Weight: 34658},
+		{Index: "host-c", Weight: 36806},
+	}
+
+	capped, wasCapped := ApplyPowerCappingForWeights(participants)
+
+	require.True(t, wasCapped, "capping must still apply with a negative-weight entry")
+	require.Equal(t, int64(-1_000_000), capped[0].Weight, "negative entry passes through unmodified")
+	// Identical outcome to the zero-weight bystander case: 3 positive hosts
+	// get the 40% small-network limit, large hosts capped to 20476.
+	require.Equal(t, int64(10238), capped[1].Weight)
+	require.Equal(t, int64(20476), capped[2].Weight)
+	require.Equal(t, int64(20476), capped[3].Weight)
+}
+
+// A single positive-weight participant among zero-weight bystanders must not
+// be capped (nothing to balance against) and must not be zeroed.
+func TestApplyPowerCappingForWeights_SinglePositiveAmongZeros(t *testing.T) {
+	participants := []*types.ActiveParticipant{
+		{Index: "zero-a", Weight: 0},
+		{Index: "zero-b", Weight: 0},
+		{Index: "host", Weight: 12345},
+	}
+
+	capped, wasCapped := ApplyPowerCappingForWeights(participants)
+
+	require.False(t, wasCapped)
+	require.Equal(t, int64(12345), capped[2].Weight)
+}
diff --git a/inference-chain/x/inference/keeper/claim_recipient_schedule.go b/inference-chain/x/inference/keeper/claim_recipient_schedule.go
new file mode 100644
index 0000000000..582436eff1
--- /dev/null
+++ b/inference-chain/x/inference/keeper/claim_recipient_schedule.go
@@ -0,0 +1,104 @@
+package keeper
+
+import (
+	"context"
+	"errors"
+
+	"cosmossdk.io/collections"
+	errorsmod "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// MaxClaimRecipientLookahead caps how far into the future a participant may
+// schedule a recipient override. Bounds per-participant state to ~40 entries,
+// preventing cheap state bloat via dumping thousands of future entries.
+const MaxClaimRecipientLookahead uint64 = 40
+
+// GetClaimRecipientForEpoch returns the scheduled recipient address for the
+// given (participant, epoch). Returns ("", false, nil) if no override exists,
+// in which case the caller should pay the participant directly.
+func (k Keeper) GetClaimRecipientForEpoch(ctx context.Context, participant sdk.AccAddress, epoch uint64) (string, bool, error) {
+	v, err := k.ClaimRecipients.Get(ctx, collections.Join(participant, epoch))
+	if err != nil {
+		if errors.Is(err, collections.ErrNotFound) {
+			return "", false, nil
+		}
+		return "", false, err
+	}
+	return v, true, nil
+}
+
+// ResolveClaimRecipientAddress returns the payout address configured for
+// (participant, epoch), or the participant address when no override exists.
+func (k Keeper) ResolveClaimRecipientAddress(ctx context.Context, participant string, epoch uint64) (sdk.AccAddress, error) {
+	participantAddr, err := sdk.AccAddressFromBech32(participant)
+	if err != nil {
+		return nil, err
+	}
+	recipient, found, err := k.GetClaimRecipientForEpoch(ctx, participantAddr, epoch)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return participantAddr, nil
+	}
+	return sdk.AccAddressFromBech32(recipient)
+}
+
+// SetClaimRecipientForEpoch writes the primary schedule entry and pruning index
+// atomically. All claim-recipient writes must use this helper to keep the two
+// collections in sync.
+func (k Keeper) SetClaimRecipientForEpoch(ctx sdk.Context, participant sdk.AccAddress, epoch uint64, recipient string) error {
+	cacheCtx, writeFn := ctx.CacheContext()
+	if err := k.ClaimRecipients.Set(cacheCtx, collections.Join(participant, epoch), recipient); err != nil {
+		return errorsmod.Wrapf(err, "failed to set claim recipient for epoch %d", epoch)
+	}
+	if err := k.ClaimRecipientsByEpoch.Set(cacheCtx, collections.Join(epoch, participant)); err != nil {
+		return errorsmod.Wrapf(err, "failed to set claim recipient epoch index for epoch %d", epoch)
+	}
+	writeFn()
+	return nil
+}
+
+// RemoveClaimRecipientForEpoch removes the primary schedule entry and pruning
+// index atomically. Missing rows are treated as already removed so cleanup paths
+// can be idempotent.
+func (k Keeper) RemoveClaimRecipientForEpoch(ctx sdk.Context, participant sdk.AccAddress, epoch uint64) error {
+	cacheCtx, writeFn := ctx.CacheContext()
+	if err := k.ClaimRecipients.Remove(cacheCtx, collections.Join(participant, epoch)); err != nil && !errors.Is(err, collections.ErrNotFound) {
+		return errorsmod.Wrapf(err, "failed to remove claim recipient for epoch %d", epoch)
+	}
+	if err := k.ClaimRecipientsByEpoch.Remove(cacheCtx, collections.Join(epoch, participant)); err != nil && !errors.Is(err, collections.ErrNotFound) {
+		return errorsmod.Wrapf(err, "failed to remove claim recipient epoch index for epoch %d", epoch)
+	}
+	writeFn()
+	return nil
+}
+
+// GetClaimRecipientsByParticipant returns every (epoch, recipient) override
+// currently scheduled for the given participant, ordered by epoch.
+func (k Keeper) GetClaimRecipientsByParticipant(ctx context.Context, participant sdk.AccAddress) ([]types.ClaimRecipientEntry, error) {
+	it, err := k.ClaimRecipients.Iterate(ctx, collections.NewPrefixedPairRange[sdk.AccAddress, uint64](participant))
+	if err != nil {
+		return nil, err
+	}
+	defer it.Close()
+
+	var out []types.ClaimRecipientEntry
+	for ; it.Valid(); it.Next() {
+		key, err := it.Key()
+		if err != nil {
+			return nil, err
+		}
+		recipient, err := it.Value()
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, types.ClaimRecipientEntry{
+			Epoch:     key.K2(),
+			Recipient: recipient,
+		})
+	}
+	return out, nil
+}
diff --git a/inference-chain/x/inference/keeper/claim_rewards_weight_overflow_test.go b/inference-chain/x/inference/keeper/claim_rewards_weight_overflow_test.go
new file mode 100644
index 0000000000..58f26d4283
--- /dev/null
+++ b/inference-chain/x/inference/keeper/claim_rewards_weight_overflow_test.go
@@ -0,0 +1,57 @@
+package keeper_test
+
+import (
+	"math"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/testutil"
+	"github.com/productscience/inference/x/inference/keeper"
+	"github.com/productscience/inference/x/inference/types"
+	"github.com/stretchr/testify/require"
+)
+
+// Validation sampling must not silently drop an inference when summed epoch weights exceed uint32.
+func TestClaimRewards_WeightAggregationAboveUint32_StillSamples(t *testing.T) {
+	k, ms, ctx, _ := setupKeeperWithMocks(t)
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	epochIndex := uint64(100)
+	epoch := types.Epoch{Index: epochIndex, PocStartBlockHeight: 1000}
+	k.SetEpoch(sdkCtx, &epoch)
+	require.NoError(t, k.SetParams(sdkCtx, types.DefaultParams()))
+
+	const each = int64(2_200_000_000)
+	require.LessOrEqual(t, each, int64(math.MaxUint32))
+	require.Greater(t, each+each, int64(math.MaxUint32))
+
+	epochData := types.EpochGroupData{
+		EpochIndex:          epochIndex,
+		EpochGroupId:        100,
+		PocStartBlockHeight: epochIndex,
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: testutil.Creator, Weight: each},
+			{MemberAddress: testutil.Executor, Weight: each},
+		},
+	}
+	k.SetEpochGroupData(sdkCtx, epochData)
+
+	inf := types.InferenceValidationDetails{
+		EpochId:              epochIndex,
+		InferenceId:          "inf-weight-sum-above-uint32",
+		ExecutorId:           testutil.Executor,
+		ExecutorReputation:   50,
+		TrafficBasis:         1000,
+		Model:                "",
+		CreatedAtBlockHeight: 0,
+	}
+	k.SetInferenceValidationDetails(sdkCtx, inf)
+
+	got, err := keeper.GetMustBeValidatedInferencesForTesting(ms, sdkCtx, &types.MsgClaimRewards{
+		Creator:    testutil.Creator,
+		EpochIndex: epochIndex,
+		Seed:       42,
+	})
+	require.NoError(t, err)
+	require.NotEmpty(t, got, "validation sampling must not silently drop the inference when summed weights exceed uint32")
+	require.Contains(t, got, "inf-weight-sum-above-uint32")
+}
diff --git a/inference-chain/x/inference/keeper/classic_inference_deprecated.go b/inference-chain/x/inference/keeper/classic_inference_deprecated.go
new file mode 100644
index 0000000000..36467645d6
--- /dev/null
+++ b/inference-chain/x/inference/keeper/classic_inference_deprecated.go
@@ -0,0 +1,12 @@
+package keeper
+
+import (
+	sdkerrors "cosmossdk.io/errors"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+const classicInferenceDeprecatedMessage = "classic inference is deprecated; use devshard"
+
+func classicInferenceDeprecatedError() error {
+	return sdkerrors.Wrap(types.ErrDeprecated, classicInferenceDeprecatedMessage)
+}
diff --git a/inference-chain/x/inference/keeper/collateral_integration_test.go b/inference-chain/x/inference/keeper/collateral_integration_test.go
deleted file mode 100644
index e813b33936..0000000000
--- a/inference-chain/x/inference/keeper/collateral_integration_test.go
+++ /dev/null
@@ -1,469 +0,0 @@
-package keeper_test
-
-import (
-	"testing"
-
-	"cosmossdk.io/math"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-
-	keepertest "github.com/productscience/inference/testutil/keeper"
-	"github.com/productscience/inference/testutil/sample"
-	blskeeper "github.com/productscience/inference/x/bls/keeper"
-	blstypes "github.com/productscience/inference/x/bls/types"
-	collateralKeeper "github.com/productscience/inference/x/collateral/keeper"
-	collateralTypes "github.com/productscience/inference/x/collateral/types"
-	"github.com/productscience/inference/x/inference/keeper"
-	"github.com/productscience/inference/x/inference/types"
-
-	"cosmossdk.io/log"
-	"cosmossdk.io/store"
-	"cosmossdk.io/store/metrics"
-	storetypes "cosmossdk.io/store/types"
-	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
-	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
-	dbm "github.com/cosmos/cosmos-db"
-	"github.com/cosmos/cosmos-sdk/codec"
-	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
-	"github.com/cosmos/cosmos-sdk/runtime"
-	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
-	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
-)
-
-// This file is for integration-style tests that involve message servers and complex state.
-// For simpler keeper tests, see keeper_test.go.
-
-func setupKeeperWithMocksForIntegration(t testing.TB) (keeper.Keeper, types.MsgServer, sdk.Context, *keepertest.InferenceMocks) {
-	k, ctx, mock := keepertest.InferenceKeeperReturningMocks(t)
-	return k, keeper.NewMsgServerImpl(k), ctx, &mock
-}
-
-func seedSlashBaseForParticipant(t testing.TB, ctx sdk.Context, k keeper.Keeper, participantAddr string, weight int64, mocks *keepertest.InferenceMocks) math.Int {
-	t.Helper()
-
-	effectiveEpoch, found := k.GetEffectiveEpoch(ctx)
-	if !found || effectiveEpoch == nil || effectiveEpoch.Index != 1 {
-		err := setEffectiveEpoch(ctx, k, 1, mocks)
-		require.NoError(t, err)
-	}
-
-	k.SetEpochGroupData(ctx, types.EpochGroupData{
-		EpochIndex: 1,
-		ModelId:    "",
-		ValidationWeights: []*types.ValidationWeight{
-			{
-				MemberAddress: participantAddr,
-				Weight:        weight,
-			},
-		},
-	})
-
-	participantAcc, err := sdk.AccAddressFromBech32(participantAddr)
-	require.NoError(t, err)
-
-	return k.GetRequiredCollateralForSlash(ctx, participantAcc)
-}
-
-func setupRealKeepers(t testing.TB) (sdk.Context, keeper.Keeper, collateralKeeper.Keeper, types.MsgServer, collateralTypes.MsgServer, *keepertest.InferenceMocks) {
-	// --- Store and Codec Setup ---
-	inferenceStoreKey := storetypes.NewKVStoreKey(types.StoreKey)
-	transientStoreKey := storetypes.NewTransientStoreKey(types.TransientStoreKey)
-	collateralStoreKey := storetypes.NewKVStoreKey(collateralTypes.StoreKey)
-	blsStoreKey := storetypes.NewKVStoreKey(blstypes.StoreKey)
-
-	db := dbm.NewMemDB()
-	stateStore := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics())
-	stateStore.MountStoreWithDB(inferenceStoreKey, storetypes.StoreTypeIAVL, db)
-	stateStore.MountStoreWithDB(transientStoreKey, storetypes.StoreTypeTransient, db)
-	stateStore.MountStoreWithDB(collateralStoreKey, storetypes.StoreTypeIAVL, db)
-	stateStore.MountStoreWithDB(blsStoreKey, storetypes.StoreTypeIAVL, db)
-	require.NoError(t, stateStore.LoadLatestVersion())
-
-	registry := codectypes.NewInterfaceRegistry()
-	cdc := codec.NewProtoCodec(registry)
-	ctx := sdk.NewContext(stateStore, cmtproto.Header{}, false, log.NewNopLogger())
-	authority := authtypes.NewModuleAddress(govtypes.ModuleName)
-	authorityBech32, err := sdk.Bech32ifyAddressBytes(sdk.GetConfig().GetBech32AccountAddrPrefix(), authority)
-	require.NoError(t, err)
-
-	// --- Mock Keepers ---
-	ctrl := gomock.NewController(t)
-	bookkepingBankMock := keepertest.NewMockBookkeepingBankKeeper(ctrl)
-	bankViewMock := keepertest.NewMockBankKeeper(ctrl)
-	accountMock := keepertest.NewMockAccountKeeper(ctrl)
-	validatorSetMock := keepertest.NewMockValidatorSet(ctrl)
-	groupMock := keepertest.NewMockGroupMessageKeeper(ctrl)
-	stakingMock := keepertest.NewMockStakingKeeper(ctrl)
-	streamvestingMock := keepertest.NewMockStreamVestingKeeper(ctrl)
-	authzMock := keepertest.NewMockAuthzKeeper(ctrl)
-	mocks := &keepertest.InferenceMocks{
-		BankKeeper:          bookkepingBankMock,
-		AccountKeeper:       accountMock,
-		GroupKeeper:         groupMock,
-		StakingKeeper:       stakingMock,
-		StreamVestingKeeper: streamvestingMock,
-		BankViewKeeper:      bankViewMock,
-		AuthzKeeper:         authzMock,
-	}
-
-	// --- Real Keepers ---
-	cKeeper := collateralKeeper.NewKeeper(
-		cdc,
-		runtime.NewKVStoreService(collateralStoreKey),
-		keepertest.PrintlnLogger{},
-		authorityBech32,
-		nil,                // bank keeper
-		bookkepingBankMock, // bookkeeping bank keeper
-	)
-
-	// Create a BLS keeper for testing (similar to testutil/keeper/inference.go)
-	blsKeeper := blskeeper.NewKeeper(
-		cdc,
-		runtime.NewKVStoreService(blsStoreKey),
-		keepertest.PrintlnLogger{},
-		authorityBech32,
-	)
-
-	upgradeMock := keepertest.NewMockUpgradeKeeper(ctrl)
-	inferenceKeeper := keeper.NewKeeper(
-		cdc,
-		runtime.NewKVStoreService(inferenceStoreKey),
-		runtime.NewTransientStoreService(transientStoreKey),
-		keepertest.PrintlnLogger{},
-		authorityBech32,
-		bookkepingBankMock,
-		bankViewMock,
-		groupMock,
-		validatorSetMock,
-		stakingMock,
-		accountMock,
-		blsKeeper,
-		cKeeper,
-		streamvestingMock,
-		authzMock,
-		func() wasmkeeper.Keeper { return wasmkeeper.Keeper{} },
-		upgradeMock,
-	)
-
-	// Initialize default params for both keepers
-	require.NoError(t, cKeeper.SetParams(ctx, collateralTypes.DefaultParams()))
-	require.NoError(t, inferenceKeeper.SetParams(ctx, types.DefaultParams()))
-
-	inferenceMsgSrv := keeper.NewMsgServerImpl(inferenceKeeper)
-	collateralMsgSrv := collateralKeeper.NewMsgServerImpl(cKeeper)
-
-	// Mock necessary bank calls
-	bookkepingBankMock.EXPECT().SendCoinsFromAccountToModule(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
-	bookkepingBankMock.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
-	bookkepingBankMock.EXPECT().SendCoinsFromModuleToModule(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
-	bookkepingBankMock.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
-	return ctx, inferenceKeeper, cKeeper, inferenceMsgSrv, collateralMsgSrv, mocks
-}
-
-func TestSlashingForInvalidStatus_Integration(t *testing.T) {
-	k, _, ctx, mocks := setupKeeperWithMocksForIntegration(t)
-
-	// Set parameters for slashing
-	params := types.DefaultParams()
-	slashFraction := types.DecimalFromFloat(0.2)
-	params.CollateralParams.SlashFractionInvalid = slashFraction
-	params.CollateralParams.GracePeriodEndEpoch = 0
-	k.SetParams(ctx, params)
-
-	// Setup participant
-	participantAddrStr := sample.AccAddress()
-	participantAcc, err := sdk.AccAddressFromBech32(participantAddrStr)
-	require.NoError(t, err)
-
-	participant := &types.Participant{
-		Address: participantAddrStr,
-		Status:  types.ParticipantStatus_INVALID, // The new status
-	}
-	expectedRequiredCollateral := seedSlashBaseForParticipant(t, ctx, k, participantAddrStr, 100, mocks)
-
-	// Mock the slash call on the collateral keeper
-	expectedSlashFraction, err := slashFraction.ToLegacyDec()
-	require.NoError(t, err)
-	mocks.CollateralKeeper.EXPECT().
-		Slash(gomock.Any(), participantAcc, expectedSlashFraction, types.SlashReasonInvalidation, expectedRequiredCollateral).
-		Return(sdk.NewCoin(types.BaseCoin, math.NewInt(0)), nil).Times(1)
-
-	// Execute the function under test directly
-	k.SlashForInvalidStatus(ctx, participant, params)
-}
-
-func TestSlashingForDowntime_Integration(t *testing.T) {
-	k, _, ctx, mocks := setupKeeperWithMocksForIntegration(t)
-
-	// Set parameters for slashing
-	params := types.DefaultParams()
-	downtimeThreshold := types.DecimalFromFloat(0.5) // 50%
-	slashFraction := types.DecimalFromFloat(0.1)     // 10%
-	params.CollateralParams.DowntimeMissedPercentageThreshold = downtimeThreshold
-	params.CollateralParams.SlashFractionDowntime = slashFraction
-	params.CollateralParams.GracePeriodEndEpoch = 0
-	k.SetParams(ctx, params)
-
-	// Setup participant
-	participantAddrStr := sample.AccAddress()
-	participantAcc, err := sdk.AccAddressFromBech32(participantAddrStr)
-	require.NoError(t, err)
-
-	participant := &types.Participant{
-		Address: participantAddrStr,
-		CurrentEpochStats: &types.CurrentEpochStats{
-			InferenceCount: 5,
-			MissedRequests: 6, // 6 out of 11 total = ~54.5% > 50% threshold
-		},
-	}
-	expectedRequiredCollateral := seedSlashBaseForParticipant(t, ctx, k, participantAddrStr, 150, mocks)
-
-	// Mock the slash call on the collateral keeper
-	expectedSlashFraction, err := slashFraction.ToLegacyDec()
-	require.NoError(t, err)
-	mocks.CollateralKeeper.EXPECT().
-		Slash(gomock.Any(), participantAcc, expectedSlashFraction, types.SlashReasonDowntime, expectedRequiredCollateral).
-		Return(sdk.NewCoin(types.BaseCoin, math.NewInt(0)), nil).Times(1)
-
-	// Execute the function under test directly
-	k.SlashForDowntime(ctx, participant, params)
-}
-
-func TestSlashingForInvalidStatus_Integration_GracePeriodUsesZeroRequiredCollateral(t *testing.T) {
-	k, _, ctx, mocks := setupKeeperWithMocksForIntegration(t)
-
-	params := types.DefaultParams()
-	params.CollateralParams.SlashFractionInvalid = types.DecimalFromFloat(0.2)
-	params.CollateralParams.GracePeriodEndEpoch = 10
-	k.SetParams(ctx, params)
-
-	participantAddrStr := sample.AccAddress()
-	participantAcc, err := sdk.AccAddressFromBech32(participantAddrStr)
-	require.NoError(t, err)
-
-	participant := &types.Participant{
-		Address: participantAddrStr,
-		Status:  types.ParticipantStatus_INVALID,
-	}
-	expectedRequiredCollateral := seedSlashBaseForParticipant(t, ctx, k, participantAddrStr, 100, mocks)
-
-	expectedSlashFraction, err := params.CollateralParams.SlashFractionInvalid.ToLegacyDec()
-	require.NoError(t, err)
-	mocks.CollateralKeeper.EXPECT().
-		Slash(gomock.Any(), participantAcc, expectedSlashFraction, types.SlashReasonInvalidation, expectedRequiredCollateral).
-		Return(sdk.NewCoin(types.BaseCoin, math.NewInt(0)), nil).Times(1)
-	require.True(t, expectedRequiredCollateral.IsZero())
-
-	k.SlashForInvalidStatus(ctx, participant, params)
-}
-
-func TestInvalidateInference_FullFlow_WithStatefulMock(t *testing.T) {
-	k, ms, ctx, mocks := setupKeeperWithMocksForIntegration(t)
-
-	// --- Test Setup ---
-	// Set the epoch, which is critical for many keeper functions
-	ee := setEffectiveEpoch(ctx, k, 1, mocks)
-	require.NoError(t, ee)
-
-	// Set parameters for slashing and validation
-	params := types.DefaultParams()
-	slashFraction := types.DecimalFromFloat(0.2)
-	params.CollateralParams.SlashFractionInvalid = slashFraction
-	params.CollateralParams.GracePeriodEndEpoch = 0
-	params.ValidationParams.FalsePositiveRate = types.DecimalFromFloat(0.05)
-	k.SetParams(ctx, params)
-
-	// Setup participant and authority
-	participantAddrStr := sample.AccAddress()
-	participantAcc, err := sdk.AccAddressFromBech32(participantAddrStr)
-	require.NoError(t, err)
-	authority := k.GetAuthority()
-	expectedRequiredCollateral := seedSlashBaseForParticipant(t, ctx, k, participantAddrStr, 100, mocks)
-
-	// --- Stateful Mock Logic ---
-	fakeCollateralAmount := math.NewInt(1000)
-
-	// Mock GetCollateral to return the current value of our fake collateral
-	mocks.CollateralKeeper.EXPECT().GetCollateral(gomock.Any(), participantAcc).DoAndReturn(
-		func(ctx sdk.Context, pa sdk.AccAddress) (sdk.Coin, bool) {
-			return sdk.NewCoin(types.BaseCoin, fakeCollateralAmount), true
-		}).AnyTimes()
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
-
-	// Mock Slash to modify our fake collateral
-	expectedSlashFraction, err := slashFraction.ToLegacyDec()
-	require.NoError(t, err)
-	mocks.CollateralKeeper.EXPECT().Slash(gomock.Any(), participantAcc, expectedSlashFraction, types.SlashReasonInvalidation, gomock.Any()).DoAndReturn(
-		func(ctx sdk.Context, pa sdk.AccAddress, fraction math.LegacyDec, reason string, requiredCollateral math.Int) (sdk.Coin, error) {
-			require.Equal(t, expectedRequiredCollateral, requiredCollateral)
-			base := math.MinInt(requiredCollateral, fakeCollateralAmount)
-			slashedAmount := math.LegacyNewDecFromInt(base).Mul(fraction).TruncateInt()
-			fakeCollateralAmount = fakeCollateralAmount.Sub(slashedAmount)
-			return sdk.NewCoin(types.BaseCoin, slashedAmount), nil
-		}).Times(1)
-	// --- End Stateful Mock Logic ---
-
-	// Set up the participant with 4 consecutive failures, just under the threshold
-	participant := types.Participant{
-		Index:                        participantAddrStr,
-		Address:                      participantAddrStr,
-		Status:                       types.ParticipantStatus_ACTIVE,
-		ConsecutiveInvalidInferences: 4,
-		CurrentEpochStats:            &types.CurrentEpochStats{},
-	}
-	k.SetParticipant(ctx, participant)
-	// The authority also needs to be a registered participant to invalidate
-	authorityParticipant := types.Participant{Index: authority, Address: authority, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, authorityParticipant)
-
-	// Mock bank keeper for the refund logic, even though cost is 0
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
-	mocks.GroupKeeper.EXPECT().UpdateGroupMembers(gomock.Any(), gomock.Any())
-	mocks.GroupKeeper.EXPECT().UpdateGroupMetadata(gomock.Any(), gomock.Any())
-	k.SetActiveParticipants(ctx, ParticipantsToActive(1, participant, authorityParticipant))
-	// Setup the inference object that will be invalidated
-	inferenceId := "test-inference-to-trigger-invalid"
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceId,
-		InferenceId:     inferenceId,
-		ExecutedBy:      participantAddrStr,
-		RequestedBy:     authority,
-		Status:          types.InferenceStatus_FINISHED,
-		ActualCost:      0,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: authority},
-	})
-
-	// Get initial collateral (will use our mock)
-	initialCollateral, found := k.GetCollateralKeeper().GetCollateral(ctx, participantAcc)
-	require.True(t, found)
-	require.Equal(t, math.NewInt(1000), initialCollateral.Amount)
-
-	// Execute the invalidation. This should increment ConsecutiveInvalidInferences to 5,
-	// which will trigger calculateStatus to return INVALID, and then trigger the slash.
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{
-		Creator:     authority,
-		InferenceId: inferenceId,
-	})
-	require.NoError(t, err)
-
-	// Final check on participant status
-	finalParticipant, found := k.GetParticipant(ctx, participantAddrStr)
-	require.True(t, found)
-	require.Equal(t, types.ParticipantStatus_INVALID, finalParticipant.Status)
-
-	// Get final collateral (will also use our mock)
-	finalCollateral, found := k.GetCollateralKeeper().GetCollateral(ctx, participantAcc)
-	require.True(t, found)
-
-	// Calculate expected result and assert
-	expectedSlashedAmount := math.LegacyNewDecFromInt(math.MinInt(expectedRequiredCollateral, math.NewInt(1000))).Mul(expectedSlashFraction).TruncateInt()
-	expectedAmount := math.NewInt(1000).Sub(expectedSlashedAmount)
-	require.Equal(t, expectedAmount, finalCollateral.Amount)
-	// And also check the fake variable directly for good measure
-	require.Equal(t, expectedAmount, fakeCollateralAmount)
-}
-
-func TestDoubleJeopardy_DowntimeThenInvalidSlash(t *testing.T) {
-	ctx, k, ck, ms, collateralMsgSrv, mocks := setupRealKeepers(t)
-	authority := k.GetAuthority()
-
-	// --- Setup Parameters ---
-	params := types.DefaultParams()
-	params.CollateralParams.DowntimeMissedPercentageThreshold = types.DecimalFromFloat(0.5) // 50%
-	params.CollateralParams.SlashFractionDowntime = types.DecimalFromFloat(0.1)             // 10%
-	params.CollateralParams.SlashFractionInvalid = types.DecimalFromFloat(0.2)              // 20%
-	params.ValidationParams.FalsePositiveRate = types.DecimalFromFloat(0.05)
-	k.SetParams(ctx, params)
-	participantAddrStr := sample.AccAddress()
-	participantAcc, err := sdk.AccAddressFromBech32(participantAddrStr)
-	require.NoError(t, err)
-
-	initialCollateralAmount := math.NewInt(1000)
-	_, err = collateralMsgSrv.DepositCollateral(ctx, &collateralTypes.MsgDepositCollateral{
-		Participant: participantAddrStr,
-		Amount:      sdk.NewCoin(types.BaseCoin, initialCollateralAmount),
-	})
-	require.NoError(t, err)
-	ee := setEffectiveEpoch(ctx, k, 1, mocks)
-	require.NoError(t, ee)
-
-	// --- 1. First Jeopardy: Downtime Slash ---
-	// Set the participant's epoch stats to trigger downtime slashing.
-	k.SetParticipant(ctx, types.Participant{
-		Index:   participantAddrStr,
-		Address: participantAddrStr,
-		Status:  types.ParticipantStatus_ACTIVE,
-		CurrentEpochStats: &types.CurrentEpochStats{
-			InferenceCount: 10,
-			MissedRequests: 90, // 90% missed requests
-		},
-	})
-	participant, found := k.GetParticipant(ctx, participantAddrStr)
-	require.True(t, found)
-
-	// Manually call the downtime slashing logic.
-	k.SlashForDowntime(ctx, &participant, params)
-
-	// Verify collateral was slashed for downtime
-	collateralAfterDowntimeCoin, found := ck.GetCollateral(ctx, participantAcc)
-	require.True(t, found)
-
-	downtimeSlash, err := params.CollateralParams.SlashFractionDowntime.ToLegacyDec()
-	require.NoError(t, err)
-	expectedAfterDowntime := initialCollateralAmount.ToLegacyDec().Mul(math.LegacyOneDec().Sub(downtimeSlash)).TruncateInt()
-
-	require.Equal(t, expectedAfterDowntime, collateralAfterDowntimeCoin.Amount, "Collateral should be slashed for downtime")
-	// expectedAfterDowntime is now 900
-
-	// --- 2. Second Jeopardy: Invalid Status Slash ---
-	// Update participant state for the next test stage. We fetch it again to get the
-	// latest version after the potential downtime slash logic modified it.
-	participant, found = k.GetParticipant(ctx, participantAddrStr)
-	require.True(t, found)
-	participant.Status = types.ParticipantStatus_ACTIVE
-	participant.ConsecutiveInvalidInferences = 4
-	participant.CurrentEpochStats = &types.CurrentEpochStats{} // Reset for the new epoch
-	k.SetParticipant(ctx, participant)
-
-	// The authority also needs to be a registered participant to invalidate
-	authorityP := types.Participant{Index: authority, Address: authority, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, authorityP)
-
-	k.SetActiveParticipants(ctx, ParticipantsToActive(1, participant, authorityP))
-	// Setup the inference object to be invalidated
-	inferenceId := "double-jeopardy-inference"
-	k.SetInference(ctx, types.Inference{
-		Index:       inferenceId,
-		InferenceId: inferenceId,
-		ExecutedBy:  participantAddrStr,
-		RequestedBy: authority,
-		Status:      types.InferenceStatus_FINISHED,
-		ProposalDetails: &types.ProposalDetails{
-			PolicyAddress: authority,
-		},
-	})
-
-	mocks.GroupKeeper.EXPECT().UpdateGroupMembers(gomock.Any(), gomock.Any())
-	mocks.GroupKeeper.EXPECT().UpdateGroupMetadata(gomock.Any(), gomock.Any())
-	// Execute the invalidation to trigger the second slash
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{
-		Creator:     authority,
-		InferenceId: inferenceId,
-	})
-	require.NoError(t, err)
-
-	// Verify the final collateral amount
-	finalCollateralCoin, found := ck.GetCollateral(ctx, participantAcc)
-	require.True(t, found)
-
-	invalidSlash, err := params.CollateralParams.SlashFractionInvalid.ToLegacyDec()
-	require.NoError(t, err)
-	expectedFinalAmount := expectedAfterDowntime.ToLegacyDec().Mul(math.LegacyOneDec().Sub(invalidSlash)).TruncateInt()
-
-	require.Equal(t, expectedFinalAmount, finalCollateralCoin.Amount, "Collateral should be slashed again for invalid status")
-	// 900 * 0.8 = 720
-
-	// For clarity, check the final value is 720
-	require.Equal(t, math.NewInt(720), finalCollateralCoin.Amount)
-}
diff --git a/inference-chain/x/inference/keeper/delegation_reward_transfer.go b/inference-chain/x/inference/keeper/delegation_reward_transfer.go
new file mode 100644
index 0000000000..5c56614755
--- /dev/null
+++ b/inference-chain/x/inference/keeper/delegation_reward_transfer.go
@@ -0,0 +1,44 @@
+package keeper
+
+import (
+	"context"
+
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func (k Keeper) SetDelegationRewardTransferSnapshot(ctx context.Context, snapshot types.DelegationRewardTransferSnapshot) error {
+	return k.DelegationRewardTransferSnapshot.Set(ctx, snapshot)
+}
+
+func (k Keeper) GetDelegationRewardTransferSnapshot(ctx context.Context) (types.DelegationRewardTransferSnapshot, bool) {
+	snapshot, err := k.DelegationRewardTransferSnapshot.Get(ctx)
+	if err != nil {
+		return types.DelegationRewardTransferSnapshot{}, false
+	}
+	return snapshot, true
+}
+
+// The reward snapshot is intentionally a singleton. Settlement is one-shot:
+// SettleAccounts runs only during the epoch transition for the effective epoch,
+// and failed settlement is not recomputed later. The epoch guard prevents callers
+// from applying the currently stored snapshot to a different epoch; historical
+// reward estimates are available only while that epoch's snapshot is stored.
+func (k Keeper) GetDelegationRewardTransfersForEpoch(ctx context.Context, epochIndex uint64) ([]*types.DelegationRewardTransfer, error) {
+	snapshot, found := k.GetDelegationRewardTransferSnapshot(ctx)
+	if !found || snapshot.EpochIndex != epochIndex {
+		return nil, nil
+	}
+	transfers := make([]*types.DelegationRewardTransfer, len(snapshot.Transfers))
+	copy(transfers, snapshot.Transfers)
+	return transfers, nil
+}
+
+func (k Keeper) GetDelegationRewardPenaltiesForEpoch(ctx context.Context, epochIndex uint64) ([]*types.DelegationRewardPenalty, error) {
+	snapshot, found := k.GetDelegationRewardTransferSnapshot(ctx)
+	if !found || snapshot.EpochIndex != epochIndex {
+		return nil, nil
+	}
+	penalties := make([]*types.DelegationRewardPenalty, len(snapshot.Penalties))
+	copy(penalties, snapshot.Penalties)
+	return penalties, nil
+}
diff --git a/inference-chain/x/inference/keeper/delegation_reward_transfer_test.go b/inference-chain/x/inference/keeper/delegation_reward_transfer_test.go
new file mode 100644
index 0000000000..de62a76049
--- /dev/null
+++ b/inference-chain/x/inference/keeper/delegation_reward_transfer_test.go
@@ -0,0 +1,110 @@
+package keeper_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	keepertest "github.com/productscience/inference/testutil/keeper"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func TestDelegationRewardTransferSnapshotForEpoch(t *testing.T) {
+	k, ctx := keepertest.InferenceKeeper(t)
+
+	require.NoError(t, k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: 7,
+		Transfers: []*types.DelegationRewardTransfer{
+			{
+				ModelId: "model-a",
+				From:    "alice",
+				To:      "bob",
+				Share:   types.DecimalFromFloat(0.05),
+			},
+		},
+		Penalties: []*types.DelegationRewardPenalty{
+			{
+				Participant:     "carol",
+				PenaltyFraction: types.DecimalFromFloat(0.2),
+			},
+		},
+	}))
+	transfers, err := k.GetDelegationRewardTransfersForEpoch(ctx, 7)
+	require.NoError(t, err)
+	require.Len(t, transfers, 1)
+	require.Equal(t, "alice", transfers[0].From)
+	require.Equal(t, "bob", transfers[0].To)
+
+	penalties, err := k.GetDelegationRewardPenaltiesForEpoch(ctx, 7)
+	require.NoError(t, err)
+	require.Len(t, penalties, 1)
+	require.Equal(t, "carol", penalties[0].Participant)
+
+	transfers, err = k.GetDelegationRewardTransfersForEpoch(ctx, 8)
+	require.NoError(t, err)
+	require.Empty(t, transfers)
+
+	penalties, err = k.GetDelegationRewardPenaltiesForEpoch(ctx, 8)
+	require.NoError(t, err)
+	require.Empty(t, penalties)
+}
+
+func TestDelegationRewardTransferSnapshotOverwritesPreviousEpoch(t *testing.T) {
+	k, ctx := keepertest.InferenceKeeper(t)
+
+	require.NoError(t, k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: 7,
+		Transfers:  []*types.DelegationRewardTransfer{{ModelId: "m", From: "a", To: "b", Share: types.DecimalFromFloat(0.1)}},
+	}))
+	require.NoError(t, k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: 8,
+		Transfers:  []*types.DelegationRewardTransfer{{ModelId: "m", From: "c", To: "d", Share: types.DecimalFromFloat(0.2)}},
+	}))
+
+	transfers7, err := k.GetDelegationRewardTransfersForEpoch(ctx, 7)
+	require.NoError(t, err)
+	require.Empty(t, transfers7)
+
+	transfers8, err := k.GetDelegationRewardTransfersForEpoch(ctx, 8)
+	require.NoError(t, err)
+	require.Len(t, transfers8, 1)
+	require.Equal(t, "c", transfers8[0].From)
+}
+
+func BenchmarkDelegationRewardTransferSnapshot1000Participants10Models(b *testing.B) {
+	k, ctx := keepertest.InferenceKeeper(b)
+	const (
+		epoch        = uint64(7)
+		participants = 1000
+		models       = 10
+	)
+
+	transfers := make([]*types.DelegationRewardTransfer, 0, participants*models)
+	for model := 0; model < models; model++ {
+		for participant := 0; participant < participants; participant++ {
+			transfers = append(transfers, &types.DelegationRewardTransfer{
+				ModelId: fmt.Sprintf("model-%02d", model),
+				From:    fmt.Sprintf("participant-%04d", participant),
+				To:      fmt.Sprintf("delegate-%04d", participant),
+				Share:   types.DecimalFromFloat(0.05),
+			})
+		}
+	}
+	require.NoError(b, k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: epoch,
+		Transfers:  transfers,
+	}))
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		got, err := k.GetDelegationRewardTransfersForEpoch(ctx, epoch)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if len(got) != participants*models {
+			b.Fatalf("expected %d transfers, got %d", participants*models, len(got))
+		}
+	}
+}
diff --git a/inference-chain/x/inference/keeper/devshard_pruning.go b/inference-chain/x/inference/keeper/devshard_pruning.go
index ffc30da224..8924f47da9 100644
--- a/inference-chain/x/inference/keeper/devshard_pruning.go
+++ b/inference-chain/x/inference/keeper/devshard_pruning.go
@@ -3,50 +3,47 @@ package keeper
 import (
 	"context"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/productscience/inference/x/inference/types"
 )
 
 const DevshardPruningThreshold = uint64(2)
 const DevshardPruningMax = int64(100)
 
-// distributeUnsettledEscrow splits the escrowed funds equally among unique validators in the group.
+// distributeUnsettledEscrow splits the escrowed funds across the group's slots: each slot
+// receives an equal share, so a validator occupying N slots receives N shares. This matches
+// how settlement pays per slot; distributing per unique address instead under-pays
+// validators that hold more than one slot in the group.
 // Integer division remainder stays in the module account.
 func (k Keeper) distributeUnsettledEscrow(ctx context.Context, escrow types.DevshardEscrow) error {
-	// Count unique addresses (first pass)
-	seen := make(map[string]bool)
-	var uniqueCount uint64
-	for _, addr := range escrow.Slots {
-		if !seen[addr] {
-			seen[addr] = true
-			uniqueCount++
-		}
-	}
-
-	if uniqueCount == 0 {
+	slotCount := uint64(len(escrow.Slots))
+	if slotCount == 0 {
 		return nil
 	}
 
-	share := escrow.Amount / uniqueCount
+	share := escrow.Amount / slotCount
 	if share == 0 {
 		return nil
 	}
 
-	// Pay in slot order (deterministic iteration over escrow.Slots)
-	paid := make(map[string]bool)
+	// Aggregate the per-slot share by recipient (a validator in N slots is owed N shares),
+	// preserving deterministic slot order for the first appearance of each address.
+	amountByAddr := make(map[string]uint64)
+	order := make([]string, 0, len(escrow.Slots))
 	for _, addr := range escrow.Slots {
-		if paid[addr] {
-			continue
+		if _, seen := amountByAddr[addr]; !seen {
+			order = append(order, addr)
 		}
-		paid[addr] = true
+		amountByAddr[addr] += share
+	}
 
-		recipient, err := sdk.AccAddressFromBech32(addr)
+	for _, addr := range order {
+		recipient, err := k.ResolveClaimRecipientAddress(ctx, addr, escrow.EpochIndex)
 		if err != nil {
-			k.LogError("invalid address in unsettled escrow", types.Pruning,
-				"escrow_id", escrow.Id, "address", addr)
+			k.LogError("failed to resolve unsettled escrow recipient", types.Pruning,
+				"escrow_id", escrow.Id, "address", addr, "epoch", escrow.EpochIndex, "error", err)
 			continue
 		}
-		coins, err := types.GetCoins(int64(share))
+		coins, err := types.GetCoins(int64(amountByAddr[addr]))
 		if err != nil {
 			continue
 		}
diff --git a/inference-chain/x/inference/keeper/devshard_pruning_test.go b/inference-chain/x/inference/keeper/devshard_pruning_test.go
index fb9aa58b00..43b861133a 100644
--- a/inference-chain/x/inference/keeper/devshard_pruning_test.go
+++ b/inference-chain/x/inference/keeper/devshard_pruning_test.go
@@ -220,6 +220,41 @@ func TestPruneDevshardData_UnsettledDistributionAmounts(t *testing.T) {
 	require.NoError(t, pruneDevshard(k, ctx, 5))
 }
 
+func TestPruneDevshardData_UnsettledDistributionUsesClaimRecipient(t *testing.T) {
+	k, ctx, mock := keepertest.InferenceKeeperReturningMocks(t)
+	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
+	require.NoError(t, k.PruningState.Set(ctx, types.PruningState{}))
+
+	participant := sdk.AccAddress(make([]byte, 20))
+	participant[0] = 0x01
+	recipient := sdk.AccAddress(make([]byte, 20))
+	recipient[0] = 0x09
+
+	slots := make([]string, keeper.DevshardGroupSize)
+	for i := range slots {
+		slots[i] = participant.String()
+	}
+
+	escrow := &types.DevshardEscrow{
+		Creator:    "gonka1creator",
+		Amount:     8_000_000_000,
+		Slots:      slots,
+		EpochIndex: 3,
+		Settled:    false,
+	}
+	_, err := k.StoreDevshardEscrow(ctx, escrow, 1)
+	require.NoError(t, err)
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, participant, escrow.EpochIndex, recipient.String()))
+
+	expectedShare, err := types.GetCoins(8_000_000_000)
+	require.NoError(t, err)
+	mock.BankKeeper.EXPECT().
+		SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, recipient, expectedShare, gomock.Eq("devshard_escrow_unsettled_distribution")).
+		Return(nil)
+
+	require.NoError(t, pruneDevshard(k, ctx, 5))
+}
+
 func TestPruneDevshardData_TracksProgress(t *testing.T) {
 	k, ctx, mock := keepertest.InferenceKeeperReturningMocks(t)
 	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
@@ -263,3 +298,52 @@ func TestPruneDevshardData_TracksProgress(t *testing.T) {
 	_, found = k.GetDevshardEscrow(ctx, 3)
 	require.False(t, found)
 }
+
+// TestPruneDevshardData_UnequalSlotsPaidPerSlot verifies unsettled-escrow funds are split per
+// slot: a validator holding 12 of 16 slots receives 12/16 of the escrow and one holding 4 of 16
+// receives 4/16, rather than an equal split across the two unique addresses.
+func TestPruneDevshardData_UnequalSlotsPaidPerSlot(t *testing.T) {
+	k, ctx, mock := keepertest.InferenceKeeperReturningMocks(t)
+	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
+	require.NoError(t, k.PruningState.Set(ctx, types.PruningState{}))
+
+	addrA := sdk.AccAddress(make([]byte, 20))
+	addrA[0] = 0x0A
+	addrB := sdk.AccAddress(make([]byte, 20))
+	addrB[0] = 0x0B
+
+	slots := make([]string, keeper.DevshardGroupSize) // 16
+	for i := 0; i < 12; i++ {
+		slots[i] = addrA.String()
+	}
+	for i := 12; i < keeper.DevshardGroupSize; i++ {
+		slots[i] = addrB.String()
+	}
+
+	escrow := &types.DevshardEscrow{
+		Creator:    "gonka1creator",
+		Amount:     16_000_000_000, // 16 GNK -> per-slot share = 1 GNK
+		Slots:      slots,
+		EpochIndex: 3,
+		Settled:    false,
+	}
+	_, err := k.StoreDevshardEscrow(ctx, escrow, 1)
+	require.NoError(t, err)
+
+	shareA, err := types.GetCoins(12_000_000_000) // 12 slots
+	require.NoError(t, err)
+	shareB, err := types.GetCoins(4_000_000_000) // 4 slots
+	require.NoError(t, err)
+
+	mock.BankKeeper.EXPECT().
+		SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, addrA, shareA, gomock.Eq("devshard_escrow_unsettled_distribution")).
+		Return(nil)
+	mock.BankKeeper.EXPECT().
+		SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, addrB, shareB, gomock.Eq("devshard_escrow_unsettled_distribution")).
+		Return(nil)
+
+	require.NoError(t, pruneDevshard(k, ctx, 5))
+
+	_, found := k.GetDevshardEscrow(ctx, 1)
+	require.False(t, found)
+}
diff --git a/inference-chain/x/inference/keeper/export_test.go b/inference-chain/x/inference/keeper/export_test.go
new file mode 100644
index 0000000000..63dcfc4a16
--- /dev/null
+++ b/inference-chain/x/inference/keeper/export_test.go
@@ -0,0 +1,12 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// GetMustBeValidatedInferencesForTesting exposes the unexported handler method
+// for direct unit testing of validation-sampling overflow behaviour.
+func GetMustBeValidatedInferencesForTesting(ms types.MsgServer, ctx sdk.Context, msg *types.MsgClaimRewards) ([]string, error) {
+	return ms.(*msgServer).getMustBeValidatedInferences(ctx, msg)
+}
diff --git a/inference-chain/x/inference/keeper/keeper.go b/inference-chain/x/inference/keeper/keeper.go
index 05cda72328..523d46bb2a 100644
--- a/inference-chain/x/inference/keeper/keeper.go
+++ b/inference-chain/x/inference/keeper/keeper.go
@@ -78,7 +78,7 @@ type (
 		// Confirmation PoC collections
 		ConfirmationPoCEvents          collections.Map[collections.Pair[uint64, uint64], types.ConfirmationPoCEvent]
 		ActiveConfirmationPoCEventItem collections.Item[types.ConfirmationPoCEvent]
-		LastUpgradeHeight              collections.Item[int64]
+		LastUpgradeHeightItem          collections.Item[int64]
 		PocV2EnabledEpoch              collections.Item[uint64]
 		// Bridge & Wrapped Token collections
 		BridgeContractAddresses collections.Map[collections.Pair[string, string], types.BridgeContractAddress]
@@ -113,12 +113,35 @@ type (
 		DevshardEscrowEpochCount  collections.Map[uint64, uint64]
 		DevshardHostEpochStatsMap collections.Map[collections.Pair[uint64, sdk.AccAddress], types.DevshardHostEpochStats]
 		DevshardEscrowsByEpoch    collections.Map[collections.Pair[uint64, uint64], collections.NoValue]
+		// Maintenance window collections
+		MaintenanceReservations       collections.Map[uint64, types.MaintenanceReservation]
+		MaintenanceReservationCounter collections.Item[uint64]
+		MaintenanceStates             collections.Map[sdk.AccAddress, types.MaintenanceState]
+		MaintenanceTransitions        collections.Map[collections.Pair[int64, uint64], uint32]
+		// MaintenanceActiveIndex is a KeySet of reservation IDs that are
+		// currently in the ACTIVE state. Lets MaintenanceActive query iterate
+		// only the active set instead of scanning every participant's state.
+		MaintenanceActiveIndex collections.KeySet[uint64]
+		// MaintenanceScheduledIndex is a KeySet of reservation IDs that are
+		// currently in the SCHEDULED state. Lets concurrency/schedulability
+		// queries iterate only the bounded set of scheduled reservations
+		// instead of every participant's MaintenanceState (DoS protection).
+		MaintenanceScheduledIndex collections.KeySet[uint64]
 		// PoC delegation collections
-		PoCDelegations              collections.Map[collections.Pair[string, string], types.PoCDelegation]
-		PoCRefusals                 collections.KeySet[collections.Pair[string, string]]
-		PoCDirectIntents            collections.KeySet[collections.Pair[string, string]]
-		DelegationSnapshot          collections.Item[types.DelegationSnapshot]
-		BootstrapDelegationSnapshot collections.Item[types.BootstrapDelegationSnapshot]
+		PoCDelegations                   collections.Map[collections.Pair[string, string], types.PoCDelegation]
+		PoCRefusals                      collections.KeySet[collections.Pair[string, string]]
+		PoCDirectIntents                 collections.KeySet[collections.Pair[string, string]]
+		DelegationSnapshot               collections.Item[types.DelegationSnapshot]
+		BootstrapDelegationSnapshot      collections.Item[types.BootstrapDelegationSnapshot]
+		DelegationRewardTransferSnapshot collections.Item[types.DelegationRewardTransferSnapshot]
+		// Per-participant, per-epoch recipient overrides for MsgClaimRewards.
+		// Set by cold key via MsgSetClaimRecipients; retained after claim so
+		// late same-epoch payouts can resolve the same recipient, then pruned
+		// once the epoch is safely stale.
+		ClaimRecipients collections.Map[collections.Pair[sdk.AccAddress, uint64], string]
+		// Secondary index for pruning stale recipient overrides by epoch.
+		// Must be updated atomically with ClaimRecipients.
+		ClaimRecipientsByEpoch collections.KeySet[collections.Pair[uint64, sdk.AccAddress]]
 	}
 )
 
@@ -408,7 +431,7 @@ func NewKeeper(
 			"active_confirmation_poc_event",
 			codec.CollValue[types.ConfirmationPoCEvent](cdc),
 		),
-		LastUpgradeHeight: collections.NewItem(
+		LastUpgradeHeightItem: collections.NewItem(
 			sb,
 			types.LastUpgradeHeightPrefix,
 			"last_upgrade_height",
@@ -562,6 +585,46 @@ func NewKeeper(
 			collections.PairKeyCodec(collections.Uint64Key, collections.Uint64Key),
 			collections.NoValue{},
 		),
+		// Maintenance window collections
+		MaintenanceReservations: collections.NewMap(
+			sb,
+			types.MaintenanceReservationsPrefix,
+			"maintenance_reservations",
+			collections.Uint64Key,
+			codec.CollValue[types.MaintenanceReservation](cdc),
+		),
+		MaintenanceReservationCounter: collections.NewItem(
+			sb,
+			types.MaintenanceReservationCounterPrefix,
+			"maintenance_reservation_counter",
+			collections.Uint64Value,
+		),
+		MaintenanceStates: collections.NewMap(
+			sb,
+			types.MaintenanceStatesPrefix,
+			"maintenance_states",
+			sdk.AccAddressKey,
+			codec.CollValue[types.MaintenanceState](cdc),
+		),
+		MaintenanceTransitions: collections.NewMap(
+			sb,
+			types.MaintenanceTransitionsPrefix,
+			"maintenance_transitions",
+			collections.PairKeyCodec(collections.Int64Key, collections.Uint64Key),
+			collections.Uint32Value,
+		),
+		MaintenanceActiveIndex: collections.NewKeySet(
+			sb,
+			types.MaintenanceActiveIndexPrefix,
+			"maintenance_active_index",
+			collections.Uint64Key,
+		),
+		MaintenanceScheduledIndex: collections.NewKeySet(
+			sb,
+			types.MaintenanceScheduledIndexPrefix,
+			"maintenance_scheduled_index",
+			collections.Uint64Key,
+		),
 		// PoC delegation collections
 		PoCDelegations: collections.NewMap(
 			sb,
@@ -594,6 +657,25 @@ func NewKeeper(
 			"bootstrap_delegation_snapshot",
 			codec.CollValue[types.BootstrapDelegationSnapshot](cdc),
 		),
+		DelegationRewardTransferSnapshot: collections.NewItem(
+			sb,
+			types.DelegationRewardTransferSnapshotPrefix,
+			"delegation_reward_transfer_snapshot",
+			codec.CollValue[types.DelegationRewardTransferSnapshot](cdc),
+		),
+		ClaimRecipients: collections.NewMap(
+			sb,
+			types.ClaimRecipientsPrefix,
+			"claim_recipients",
+			collections.PairKeyCodec(sdk.AccAddressKey, collections.Uint64Key),
+			collections.StringValue,
+		),
+		ClaimRecipientsByEpoch: collections.NewKeySet(
+			sb,
+			types.ClaimRecipientsByEpochPrefix,
+			"claim_recipients_by_epoch",
+			collections.PairKeyCodec(collections.Uint64Key, sdk.AccAddressKey),
+		),
 	}
 	// Build the collections schema
 	schema, err := sb.Build()
diff --git a/inference-chain/x/inference/keeper/maintenance.go b/inference-chain/x/inference/keeper/maintenance.go
new file mode 100644
index 0000000000..c77ac714f5
--- /dev/null
+++ b/inference-chain/x/inference/keeper/maintenance.go
@@ -0,0 +1,419 @@
+package keeper
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math"
+
+	"cosmossdk.io/collections"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/group"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// --- Reservation CRUD ---
+
+// NextMaintenanceReservationID returns the next reservation ID and increments the counter.
+func (k Keeper) NextMaintenanceReservationID(ctx context.Context) (uint64, error) {
+	counter, err := k.MaintenanceReservationCounter.Get(ctx)
+	if err != nil {
+		if !errors.Is(err, collections.ErrNotFound) {
+			return 0, fmt.Errorf("failed to get maintenance reservation counter: %w", err)
+		}
+		counter = 0
+	}
+	nextID := counter + 1
+	if err := k.MaintenanceReservationCounter.Set(ctx, nextID); err != nil {
+		return 0, fmt.Errorf("failed to set maintenance reservation counter: %w", err)
+	}
+	return nextID, nil
+}
+
+// SetMaintenanceReservation stores a reservation by its ID.
+func (k Keeper) SetMaintenanceReservation(ctx context.Context, r types.MaintenanceReservation) error {
+	if err := k.MaintenanceReservations.Set(ctx, r.ReservationId, r); err != nil {
+		return fmt.Errorf("failed to set maintenance reservation %d: %w", r.ReservationId, err)
+	}
+	return nil
+}
+
+// GetMaintenanceReservation retrieves a reservation by ID.
+func (k Keeper) GetMaintenanceReservation(ctx context.Context, id uint64) (types.MaintenanceReservation, bool) {
+	v, err := k.MaintenanceReservations.Get(ctx, id)
+	if err != nil {
+		return types.MaintenanceReservation{}, false
+	}
+	return v, true
+}
+
+// --- MaintenanceState CRUD ---
+
+// SetMaintenanceState stores the per-participant maintenance state.
+func (k Keeper) SetMaintenanceState(ctx context.Context, state types.MaintenanceState) error {
+	addr, err := sdk.AccAddressFromBech32(state.Participant)
+	if err != nil {
+		return err
+	}
+	return k.MaintenanceStates.Set(ctx, addr, state)
+}
+
+// GetMaintenanceState retrieves per-participant maintenance state.
+func (k Keeper) GetMaintenanceState(ctx context.Context, participant sdk.AccAddress) (types.MaintenanceState, bool) {
+	v, err := k.MaintenanceStates.Get(ctx, participant)
+	if err != nil {
+		return types.MaintenanceState{}, false
+	}
+	return v, true
+}
+
+// GetOrCreateMaintenanceState retrieves or initializes maintenance state for a participant.
+func (k Keeper) GetOrCreateMaintenanceState(ctx context.Context, participant sdk.AccAddress) types.MaintenanceState {
+	state, found := k.GetMaintenanceState(ctx, participant)
+	if !found {
+		return types.MaintenanceState{
+			Participant: participant.String(),
+		}
+	}
+	return state
+}
+
+// --- Transition Schedule ---
+
+// SetMaintenanceTransition stores a transition entry for exact block-height lookup in BeginBlock.
+// transitionType: 1 = activate, 2 = complete (maps to MaintenanceTransitionType enum values).
+func (k Keeper) SetMaintenanceTransition(ctx context.Context, blockHeight int64, reservationID uint64, transitionType uint32) error {
+	if err := k.MaintenanceTransitions.Set(ctx, collections.Join(blockHeight, reservationID), transitionType); err != nil {
+		return fmt.Errorf("failed to set maintenance transition at height %d for reservation %d: %w", blockHeight, reservationID, err)
+	}
+	return nil
+}
+
+// DeleteMaintenanceTransition removes a consumed transition entry.
+func (k Keeper) DeleteMaintenanceTransition(ctx context.Context, blockHeight int64, reservationID uint64) error {
+	return k.MaintenanceTransitions.Remove(ctx, collections.Join(blockHeight, reservationID))
+}
+
+// IterateMaintenanceTransitionsAtHeight iterates over all transitions scheduled for the exact given height.
+func (k Keeper) IterateMaintenanceTransitionsAtHeight(ctx context.Context, blockHeight int64, fn func(reservationID uint64, transitionType uint32) (stop bool, err error)) error {
+	rng := collections.NewPrefixedPairRange[int64, uint64](blockHeight)
+	iter, err := k.MaintenanceTransitions.Iterate(ctx, rng)
+	if err != nil {
+		return err
+	}
+	defer iter.Close()
+
+	for ; iter.Valid(); iter.Next() {
+		kv, err := iter.KeyValue()
+		if err != nil {
+			return err
+		}
+		reservationID := kv.Key.K2()
+		transitionType := kv.Value
+		stop, err := fn(reservationID, transitionType)
+		if err != nil {
+			return err
+		}
+		if stop {
+			return nil
+		}
+	}
+	return nil
+}
+
+// maxMaintenanceIterationLimit is a hard upper bound on the number of entries
+// any maintenance index iteration will process. Defends against DoS via
+// public queries: even if an attacker could somehow bypass the governance
+// concurrency cap and create many scheduled reservations, queries will not
+// burn unbounded CPU/IO. In normal operation this limit is never reached
+// (active is bounded by MaintenanceMaxConcurrentValidators, scheduled is
+// bounded by participant count which is small in practice).
+const maxMaintenanceIterationLimit = 10000
+
+// collectActiveAndScheduledReservations returns all reservations that are
+// currently in ACTIVE or SCHEDULED state by iterating the dedicated indexes
+// (MaintenanceActiveIndex + MaintenanceScheduledIndex). This avoids a full
+// scan of MaintenanceStates and bounds iteration to actual maintenance
+// activity rather than total participant count — important for DoS resistance
+// on the public concurrency / schedulability queries.
+func (k Keeper) collectActiveAndScheduledReservations(ctx context.Context) ([]types.MaintenanceReservation, error) {
+	var reservations []types.MaintenanceReservation
+
+	if err := k.iterateIndexedReservations(ctx, k.MaintenanceActiveIndex, func(r types.MaintenanceReservation) {
+		reservations = append(reservations, r)
+	}); err != nil {
+		return nil, fmt.Errorf("failed to iterate active maintenance index: %w", err)
+	}
+
+	if err := k.iterateIndexedReservations(ctx, k.MaintenanceScheduledIndex, func(r types.MaintenanceReservation) {
+		reservations = append(reservations, r)
+	}); err != nil {
+		return nil, fmt.Errorf("failed to iterate scheduled maintenance index: %w", err)
+	}
+
+	return reservations, nil
+}
+
+// iterateIndexedReservations walks a reservation-id index, applying fn to each
+// resolved MaintenanceReservation. Returns an error if iter.Key() fails — the
+// caller cannot otherwise tell that the result set is incomplete, and silently
+// proceeding would corrupt downstream concurrency / exemption decisions. Stops
+// after maxMaintenanceIterationLimit entries as a hard DoS safeguard. Stale
+// index entries (where the underlying reservation has been deleted) are logged
+// at warn level and skipped — that condition is recoverable and bounded.
+func (k Keeper) iterateIndexedReservations(
+	ctx context.Context,
+	index collections.KeySet[uint64],
+	fn func(types.MaintenanceReservation),
+) error {
+	iter, err := index.Iterate(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer iter.Close()
+
+	count := 0
+	for ; iter.Valid(); iter.Next() {
+		if count >= maxMaintenanceIterationLimit {
+			k.LogWarn("Maintenance index iteration truncated at safety limit",
+				types.Maintenance, "limit", maxMaintenanceIterationLimit)
+			break
+		}
+		count++
+		reservationID, err := iter.Key()
+		if err != nil {
+			return fmt.Errorf("failed to read maintenance index key: %w", err)
+		}
+		r, found := k.GetMaintenanceReservation(ctx, reservationID)
+		if !found {
+			// Indicates index drift (an entry pointing at a deleted reservation).
+			// Log so it surfaces in monitoring; continue so a single stale entry
+			// does not break callers like filterOutMaintenanceParticipants or
+			// the concurrency check.
+			k.LogWarn("Maintenance index references missing reservation; skipping entry",
+				types.Maintenance, "reservation_id", reservationID)
+			continue
+		}
+		fn(r)
+	}
+	return nil
+}
+
+// activeReservationCoversEpoch reports whether the given ACTIVE reservation's
+// block range overlaps any block belonging to epochIndex. Used to suppress
+// credit accrual for a granted epoch while the participant's maintenance is
+// in-progress.
+//
+// The epoch's block range is approximated as
+// [PocStartBlockHeight(epochIndex), PocStartBlockHeight(epochIndex+1) - 1].
+// If the next epoch is not yet recorded (the granted epoch is the latest),
+// we treat the epoch as extending indefinitely on the right — this is safe
+// for credit suppression: an unbounded right edge can only widen the overlap,
+// erring toward more suppression rather than missed suppression.
+func (k Keeper) activeReservationCoversEpoch(ctx context.Context, r types.MaintenanceReservation, epochIndex uint64) bool {
+	epoch, found := k.GetEpoch(ctx, epochIndex)
+	if !found {
+		// Without epoch metadata we cannot bound the overlap; fall back to a
+		// permissive suppression so credit cannot leak through an unrecognized
+		// epoch index.
+		return true
+	}
+	epochStart := epoch.PocStartBlockHeight
+
+	epochEnd := int64(math.MaxInt64)
+	if next, ok := k.GetEpoch(ctx, epochIndex+1); ok && next.PocStartBlockHeight > 0 {
+		epochEnd = next.PocStartBlockHeight - 1
+	}
+
+	resStart := r.StartHeight
+	resEnd := r.StartHeight + int64(r.DurationBlocks) - 1
+
+	return resStart <= epochEnd && resEnd >= epochStart
+}
+
+// maintenanceStateCoversEpoch reports whether the participant's MaintenanceState
+// indicates the given epoch is covered by a maintenance window. Single source of
+// truth for credit accrual (GrantMaintenanceCredit) and claim-time validation
+// exemption (hasSignificantMissedValidations); both must agree, otherwise a
+// multi-epoch window's mid/end epochs could be exempted from credit but not
+// from missed-validation checks (or vice versa).
+//
+// Two branches, in order:
+//
+//  1. In-progress window: state.ActiveReservationId points at an ACTIVE
+//     reservation whose block range overlaps the granted epoch's blocks.
+//     Catches mid-window epochs where the historical [start,end] range is
+//     not yet finalized (LastMaintenanceEndEpoch is provisional until COMPLETE).
+//
+//  2. Historical window: epochIndex falls in
+//     [LastMaintenanceEpoch, LastMaintenanceEndEpoch] inclusive. The end epoch
+//     is overwritten at COMPLETE in BeginBlock with the epoch in which the
+//     window's last block fell, so this closed range correctly covers
+//     multi-epoch windows after they finish.
+//
+// `epochIndex != 0` guard: proto-default LastMaintenanceEpoch is 0 for
+// participants that have never activated maintenance, so without the guard
+// every fresh participant would have credit suppressed at epoch 0. A
+// participant who genuinely activates maintenance during epoch 0 still earns
+// credit at the epoch-0 settlement; epoch 0 is the bootstrap epoch and
+// short-lived, so this edge case is accepted.
+//
+// Tracks only the most recent window; out-of-order claims spanning multiple
+// historical windows would require per-epoch tracking and are not covered.
+func (k Keeper) maintenanceStateCoversEpoch(ctx context.Context, state types.MaintenanceState, epochIndex uint64) bool {
+	if state.ActiveReservationId != 0 {
+		if r, ok := k.GetMaintenanceReservation(ctx, state.ActiveReservationId); ok &&
+			r.Status == types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE &&
+			k.activeReservationCoversEpoch(ctx, r, epochIndex) {
+			return true
+		}
+	}
+	return epochIndex != 0 &&
+		state.LastMaintenanceEpoch <= epochIndex &&
+		epochIndex <= state.LastMaintenanceEndEpoch
+}
+
+// --- Credit accrual ---
+
+// GrantMaintenanceCredit grants maintenance credit to a participant after a
+// successful reward claim. Credit is not granted if maintenance was activated
+// for that participant in the claimed epoch.
+//
+// Idempotency: the only caller (msgServer.finishSettle) runs inside a
+// cached context that is committed atomically with the claim. The claim
+// flow's validateRequest rejects when no SettleAmount exists, and
+// finishSettle removes the SettleAmount before invoking this function — so
+// a duplicate call within the same epoch cannot reach here. If the call
+// graph ever expands, add a per-epoch guard (likely a new state field).
+//
+// Lives on Keeper (not msgServer) so other modules and BeginBlock/EndBlock
+// hooks can reuse it. Returns the bech32 decode error to the caller instead
+// of swallowing it — the caller is responsible for logging.
+func (k Keeper) GrantMaintenanceCredit(ctx context.Context, participant string, epochIndex uint64) error {
+	mp := k.GetMaintenanceParams(ctx)
+	if mp == nil || !mp.MaintenanceEnabled || mp.MaintenanceCreditEarnPerSuccessfulEpochBlocks == 0 {
+		return nil
+	}
+
+	participantAddr, err := sdk.AccAddressFromBech32(participant)
+	if err != nil {
+		return fmt.Errorf("invalid participant address %q: %w", participant, err)
+	}
+
+	state := k.GetOrCreateMaintenanceState(ctx, participantAddr)
+
+	// Suppress credit accrual for any epoch covered by a maintenance window.
+	// Shared with hasSignificantMissedValidations so both paths give the same
+	// answer to "is this epoch covered by maintenance?" — see helper docs.
+	if k.maintenanceStateCoversEpoch(ctx, state, epochIndex) {
+		k.LogDebug("Maintenance credit skipped: epoch covered by maintenance window",
+			types.Maintenance, "participant", participant, "epoch", epochIndex,
+			"active_reservation_id", state.ActiveReservationId,
+			"window_start_epoch", state.LastMaintenanceEpoch,
+			"window_end_epoch", state.LastMaintenanceEndEpoch)
+		return nil
+	}
+
+	state.CreditBlocks += mp.MaintenanceCreditEarnPerSuccessfulEpochBlocks
+	if state.CreditBlocks > mp.MaintenanceCreditCapBlocks {
+		state.CreditBlocks = mp.MaintenanceCreditCapBlocks
+	}
+
+	if err := k.SetMaintenanceState(ctx, state); err != nil {
+		return fmt.Errorf("failed to grant maintenance credit: %w", err)
+	}
+	return nil
+}
+
+// --- Convenience: check if a participant is in active maintenance ---
+
+// IsParticipantInActiveMaintenance returns true if the participant has an active
+// maintenance window.
+//
+// Intentionally consults only the reservation state machine, not
+// MaintenanceParams.MaintenanceEnabled: an in-flight ACTIVE window keeps its
+// slashing exemption until its natural COMPLETE fires, even if governance
+// disables the feature mid-window. The disable flag is interpreted as
+// "no new windows" (enforced at Schedule and at ACTIVATE-on-disabled via
+// cancelScheduledReservationOnDisabled), not as a kill switch that revokes
+// in-flight protections — that would silently punish honest validators who
+// pre-committed their downtime in good faith.
+func (k Keeper) IsParticipantInActiveMaintenance(ctx context.Context, participant sdk.AccAddress) bool {
+	state, found := k.GetMaintenanceState(ctx, participant)
+	if !found {
+		return false
+	}
+	if state.ActiveReservationId == 0 {
+		return false
+	}
+	r, found := k.GetMaintenanceReservation(ctx, state.ActiveReservationId)
+	if !found {
+		return false
+	}
+	return r.Status == types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE
+}
+
+// IsParticipantAddressInActiveMaintenance is a convenience wrapper that accepts
+// a bech32 address string instead of sdk.AccAddress.
+func (k Keeper) IsParticipantAddressInActiveMaintenance(ctx context.Context, address string) bool {
+	addr, err := sdk.AccAddressFromBech32(address)
+	if err != nil {
+		return false
+	}
+	return k.IsParticipantInActiveMaintenance(ctx, addr)
+}
+
+// filterOutMaintenanceParticipants removes group members that are currently in
+// an active maintenance window. Used by GetRandomExecutor to prevent assigning
+// new inference work to maintenance-covered participants.
+//
+// Implementation: build a single set of currently-active maintenance addresses
+// (bounded by MaintenanceMaxConcurrentValidators) up-front, then O(1) lookup
+// per member. This avoids one collection read per member.
+func (k Keeper) filterOutMaintenanceParticipants(ctx context.Context, members []*group.GroupMember) []*group.GroupMember {
+	mp := k.GetMaintenanceParams(ctx)
+	if mp == nil || !mp.MaintenanceEnabled {
+		return members
+	}
+
+	activeAddrs := k.CollectActiveMaintenanceAddresses(ctx)
+	if len(activeAddrs) == 0 {
+		return members
+	}
+
+	filtered := make([]*group.GroupMember, 0, len(members))
+	for _, member := range members {
+		if member == nil || member.Member == nil {
+			continue
+		}
+		if _, inMaintenance := activeAddrs[member.Member.Address]; inMaintenance {
+			k.LogDebug("Excluding maintenance-covered participant from assignment",
+				types.Maintenance, "participant", member.Member.Address)
+			continue
+		}
+		filtered = append(filtered, member)
+	}
+	return filtered
+}
+
+// CollectActiveMaintenanceAddresses returns the bech32 addresses of every
+// participant currently in an ACTIVE maintenance window. The result size is
+// bounded by MaintenanceMaxConcurrentValidators.
+//
+// The status check is intentionally omitted: MaintenanceActiveIndex is the
+// authority for "active" and is kept in lockstep with the reservation lifecycle
+// (added on activate, removed on complete/cancel). Re-checking r.Status here
+// would mask index/state drift instead of surfacing it. Iterator errors are
+// logged but not returned: callers (filterOutMaintenanceParticipants, CPoC,
+// inference-expiry) want a fail-open default — an empty/partial set widens
+// participation rather than masking maintenance, which is the safer error mode.
+func (k Keeper) CollectActiveMaintenanceAddresses(ctx context.Context) map[string]struct{} {
+	addrs := make(map[string]struct{})
+	if err := k.iterateIndexedReservations(ctx, k.MaintenanceActiveIndex, func(r types.MaintenanceReservation) {
+		addrs[r.Participant] = struct{}{}
+	}); err != nil {
+		k.LogError("Failed to iterate active maintenance index; result may be incomplete",
+			types.Maintenance, "error", err)
+	}
+	return addrs
+}
diff --git a/inference-chain/x/inference/keeper/maintenance_export_test.go b/inference-chain/x/inference/keeper/maintenance_export_test.go
new file mode 100644
index 0000000000..dc3caba594
--- /dev/null
+++ b/inference-chain/x/inference/keeper/maintenance_export_test.go
@@ -0,0 +1,12 @@
+package keeper
+
+import (
+	"context"
+
+	"github.com/cosmos/cosmos-sdk/x/group"
+)
+
+// FilterOutMaintenanceParticipants exposes the unexported method for tests.
+func (k Keeper) FilterOutMaintenanceParticipants(ctx context.Context, members []*group.GroupMember) []*group.GroupMember {
+	return k.filterOutMaintenanceParticipants(ctx, members)
+}
diff --git a/inference-chain/x/inference/keeper/maintenance_lifecycle.go b/inference-chain/x/inference/keeper/maintenance_lifecycle.go
new file mode 100644
index 0000000000..6855a5d561
--- /dev/null
+++ b/inference-chain/x/inference/keeper/maintenance_lifecycle.go
@@ -0,0 +1,368 @@
+package keeper
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+
+	cosmossdk_math "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// ProcessMaintenanceTransitions processes all maintenance lifecycle transitions
+// scheduled for the exact current block height. Called from BeginBlock.
+//
+// Access pattern:
+//  1. One prefix lookup for transition rows at the exact current block height
+//  2. Iterate only the rows returned for that exact height
+//  3. One direct reservation lookup per returned row
+//  4. Apply transition (Scheduled->Active or Active->Completed)
+//  5. Update the participant's MaintenanceState references
+//  6. Delete consumed transition row
+func (k Keeper) ProcessMaintenanceTransitions(ctx context.Context) error {
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	blockHeight := sdkCtx.BlockHeight()
+
+	// Always run, regardless of the MaintenanceEnabled flag. Transition rows
+	// are keyed by exact block height — a flag flip mid-window would otherwise
+	// strand the COMPLETE row at the scheduled height, leaving the reservation
+	// in ACTIVE forever and (via state.ActiveReservationId) permanently
+	// exempting the participant from slashing. The flag is interpreted as
+	// "no new windows can be scheduled or activated"; in-flight windows wind
+	// down through the normal state machine, and any SCHEDULED reservation
+	// whose ACTIVATE fires after a disable gets canceled and refunded.
+	mp := k.GetMaintenanceParams(ctx)
+	maintenanceEnabled := mp != nil && mp.MaintenanceEnabled
+
+	// Collect transitions to process (we must not modify during iteration)
+	type pendingTransition struct {
+		reservationID  uint64
+		transitionType uint32
+	}
+	var transitions []pendingTransition
+
+	err := k.IterateMaintenanceTransitionsAtHeight(ctx, blockHeight, func(reservationID uint64, transitionType uint32) (bool, error) {
+		transitions = append(transitions, pendingTransition{
+			reservationID:  reservationID,
+			transitionType: transitionType,
+		})
+		return false, nil
+	})
+	if err != nil {
+		return fmt.Errorf("failed to iterate maintenance transitions at height %d: %w", blockHeight, err)
+	}
+
+	for _, t := range transitions {
+		switch types.MaintenanceTransitionType(t.transitionType) {
+		case types.MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_ACTIVATE:
+			if !maintenanceEnabled {
+				if err := k.cancelScheduledReservationOnDisabled(ctx, sdkCtx, t.reservationID); err != nil {
+					k.LogError("Failed to cancel scheduled reservation after maintenance disabled",
+						types.Maintenance, "reservation_id", t.reservationID, "error", err)
+				}
+				break
+			}
+			if err := k.activateMaintenanceReservation(ctx, sdkCtx, t.reservationID, mp); err != nil {
+				k.LogError("Failed to activate maintenance reservation",
+					types.Maintenance, "reservation_id", t.reservationID, "error", err)
+			}
+		case types.MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_COMPLETE:
+			if err := k.completeMaintenanceReservation(ctx, sdkCtx, t.reservationID); err != nil {
+				k.LogError("Failed to complete maintenance reservation",
+					types.Maintenance, "reservation_id", t.reservationID, "error", err)
+			}
+		default:
+			k.LogError("Unknown maintenance transition type",
+				types.Maintenance, "reservation_id", t.reservationID, "type", t.transitionType)
+		}
+
+		// Always delete the transition row, even on error. Transitions are
+		// keyed by exact block height; if we leave a failed row in place, it
+		// will retry on every subsequent block (BeginBlock runs every height
+		// matches), burning CPU and writing logs forever. The failure has
+		// been surfaced in events/logs above; rely on operator monitoring
+		// rather than infinite on-chain retry.
+		if err := k.DeleteMaintenanceTransition(ctx, blockHeight, t.reservationID); err != nil {
+			k.LogError("Failed to delete maintenance transition",
+				types.Maintenance, "reservation_id", t.reservationID, "error", err)
+		}
+	}
+
+	return nil
+}
+
+// cancelScheduledReservationOnDisabled handles the ACTIVATE transition for a
+// SCHEDULED reservation whose activation height arrives after MaintenanceEnabled
+// has been flipped to false. Treats the disable as "no new windows": the
+// reservation never enters ACTIVE, its credit cost is refunded, and its future
+// COMPLETE transition row is deleted so no orphan alarm fires later.
+//
+// The outer ProcessMaintenanceTransitions loop deletes the ACTIVATE transition
+// row after this returns, so this helper only removes the COMPLETE row.
+func (k Keeper) cancelScheduledReservationOnDisabled(ctx context.Context, sdkCtx sdk.Context, reservationID uint64) error {
+	r, found := k.GetMaintenanceReservation(ctx, reservationID)
+	if !found {
+		return fmt.Errorf("reservation %d not found", reservationID)
+	}
+	if r.Status != types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED {
+		return fmt.Errorf("reservation %d is not in scheduled state (status=%d)", reservationID, r.Status)
+	}
+
+	r.Status = types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED
+	if err := k.SetMaintenanceReservation(ctx, r); err != nil {
+		return err
+	}
+	if err := k.MaintenanceScheduledIndex.Remove(ctx, reservationID); err != nil {
+		return err
+	}
+
+	participantAddr, err := sdk.AccAddressFromBech32(r.Participant)
+	if err != nil {
+		return err
+	}
+	state := k.GetOrCreateMaintenanceState(ctx, participantAddr)
+	state.CreditBlocks += r.DurationBlocks
+	if mp := k.GetMaintenanceParams(ctx); mp != nil && state.CreditBlocks > mp.MaintenanceCreditCapBlocks {
+		state.CreditBlocks = mp.MaintenanceCreditCapBlocks
+	}
+	state.ScheduledReservationId = 0
+	if err := k.SetMaintenanceState(ctx, state); err != nil {
+		return err
+	}
+
+	// Remove the future COMPLETE alarm. Mirrors the height arithmetic from
+	// msg_server_schedule_maintenance.go where it was originally written.
+	if r.DurationBlocks > uint64(math.MaxInt64) || r.StartHeight > math.MaxInt64-int64(r.DurationBlocks) {
+		return fmt.Errorf("reservation %d has invalid start/duration that would overflow completion height", reservationID)
+	}
+	completeHeight := r.StartHeight + int64(r.DurationBlocks)
+	if err := k.DeleteMaintenanceTransition(ctx, completeHeight, reservationID); err != nil {
+		return fmt.Errorf("failed to delete orphan complete transition: %w", err)
+	}
+
+	k.LogInfo("Maintenance window canceled because maintenance is disabled",
+		types.Maintenance,
+		"reservation_id", reservationID,
+		"participant", r.Participant,
+		"credit_refunded", r.DurationBlocks,
+	)
+
+	sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+		"maintenance_canceled",
+		sdk.NewAttribute("reservation_id", fmt.Sprint(reservationID)),
+		sdk.NewAttribute("participant", r.Participant),
+		sdk.NewAttribute("credit_refunded", fmt.Sprint(r.DurationBlocks)),
+		sdk.NewAttribute("reason", "maintenance_disabled"),
+	))
+
+	return nil
+}
+
+// activateMaintenanceReservation transitions a reservation from Scheduled to Active.
+func (k Keeper) activateMaintenanceReservation(ctx context.Context, sdkCtx sdk.Context, reservationID uint64, mp *types.MaintenanceParams) error {
+	r, found := k.GetMaintenanceReservation(ctx, reservationID)
+	if !found {
+		return fmt.Errorf("reservation %d not found", reservationID)
+	}
+	if r.Status != types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED {
+		return fmt.Errorf("reservation %d is not in scheduled state (status=%d)", reservationID, r.Status)
+	}
+
+	// Concurrency caps were enforced when the reservation was scheduled. Re-check
+	// at activation time for visibility only: chain conditions (validator set,
+	// other windows, governance params) may have changed in the interim. The
+	// reservation still activates regardless; any breach is recorded as an
+	// advisory ActivationWarning on the reservation and surfaced in the log.
+	warning := k.checkActivationTimeConcurrency(ctx, r, mp)
+	if warning != "" {
+		r.ActivationWarning = warning
+		k.LogInfo("Maintenance reservation activated with concurrency advisory warning",
+			types.Maintenance, "reservation_id", reservationID, "warning", warning)
+	}
+
+	// Transition to Active
+	r.Status = types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE
+	if err := k.SetMaintenanceReservation(ctx, r); err != nil {
+		return err
+	}
+
+	// Add to the active index for O(A) MaintenanceActive query
+	if err := k.MaintenanceActiveIndex.Set(ctx, reservationID); err != nil {
+		return err
+	}
+
+	// Remove from scheduled index now that the reservation is active.
+	if err := k.MaintenanceScheduledIndex.Remove(ctx, reservationID); err != nil {
+		return err
+	}
+
+	// Update participant's MaintenanceState
+	participantAddr, err := sdk.AccAddressFromBech32(r.Participant)
+	if err != nil {
+		return err
+	}
+	state := k.GetOrCreateMaintenanceState(ctx, participantAddr)
+	state.ActiveReservationId = reservationID
+	state.ScheduledReservationId = 0
+
+	// Mark the activation epoch as the start of the credit-suppression range.
+	// LastMaintenanceEndEpoch is provisionally set to the same value and will be
+	// overwritten at completion to reflect the true end epoch. While the window
+	// is still ACTIVE, the active-reservation overlap check in GrantMaintenanceCredit
+	// covers any in-progress epoch regardless of these fields.
+	epochIndex, found := k.GetEffectiveEpochIndex(ctx)
+	if found {
+		state.LastMaintenanceEpoch = epochIndex
+		state.LastMaintenanceEndEpoch = epochIndex
+	}
+
+	if err := k.SetMaintenanceState(ctx, state); err != nil {
+		return err
+	}
+
+	k.LogInfo("Maintenance window activated",
+		types.Maintenance,
+		"reservation_id", reservationID,
+		"participant", r.Participant,
+		"start_height", r.StartHeight,
+		"duration_blocks", r.DurationBlocks,
+	)
+
+	sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+		"maintenance_activated",
+		sdk.NewAttribute("reservation_id", fmt.Sprint(reservationID)),
+		sdk.NewAttribute("participant", r.Participant),
+		sdk.NewAttribute("start_height", fmt.Sprint(r.StartHeight)),
+		sdk.NewAttribute("duration_blocks", fmt.Sprint(r.DurationBlocks)),
+	))
+
+	return nil
+}
+
+// completeMaintenanceReservation transitions a reservation from Active to Completed.
+func (k Keeper) completeMaintenanceReservation(ctx context.Context, sdkCtx sdk.Context, reservationID uint64) error {
+	r, found := k.GetMaintenanceReservation(ctx, reservationID)
+	if !found {
+		return fmt.Errorf("reservation %d not found", reservationID)
+	}
+	if r.Status != types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE {
+		return fmt.Errorf("reservation %d is not in active state (status=%d)", reservationID, r.Status)
+	}
+
+	// Transition to Completed
+	r.Status = types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_COMPLETED
+	if err := k.SetMaintenanceReservation(ctx, r); err != nil {
+		return err
+	}
+
+	// Remove from the active index
+	if err := k.MaintenanceActiveIndex.Remove(ctx, reservationID); err != nil {
+		return err
+	}
+
+	// Clear participant's active reservation reference and record the end
+	// epoch so credit accrual stays suppressed for any past epoch the window
+	// covered, even after the window has finished. Combined with the start
+	// epoch written at activation, this defines a closed [start, end] range
+	// over which GrantMaintenanceCredit will skip — preventing double-dip
+	// when a multi-epoch maintenance ends and a delayed claim arrives for
+	// one of the covered epochs.
+	participantAddr, err := sdk.AccAddressFromBech32(r.Participant)
+	if err != nil {
+		return err
+	}
+	state := k.GetOrCreateMaintenanceState(ctx, participantAddr)
+	state.ActiveReservationId = 0
+	if epochIndex, found := k.GetEffectiveEpochIndex(ctx); found {
+		state.LastMaintenanceEndEpoch = epochIndex
+	}
+	if err := k.SetMaintenanceState(ctx, state); err != nil {
+		return err
+	}
+
+	k.LogInfo("Maintenance window completed",
+		types.Maintenance,
+		"reservation_id", reservationID,
+		"participant", r.Participant,
+	)
+
+	sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+		"maintenance_completed",
+		sdk.NewAttribute("reservation_id", fmt.Sprint(reservationID)),
+		sdk.NewAttribute("participant", r.Participant),
+	))
+
+	return nil
+}
+
+// checkActivationTimeConcurrency re-checks concurrency caps at activation time.
+// Returns a warning string if current caps would reject this reservation; empty string otherwise.
+// The reservation still activates regardless — this is advisory only.
+func (k Keeper) checkActivationTimeConcurrency(ctx context.Context, r types.MaintenanceReservation, mp *types.MaintenanceParams) string {
+	endHeight := r.StartHeight + int64(r.DurationBlocks) - 1
+
+	// Collect all active/scheduled reservations and check overlap
+	reservations, err := k.collectActiveAndScheduledReservations(ctx)
+	if err != nil {
+		return ""
+	}
+
+	concurrentCount := uint32(0)
+	concurrentPower := cosmossdk_math.ZeroInt()
+
+	for _, other := range reservations {
+		if other.ReservationId == r.ReservationId {
+			continue // skip self
+		}
+		otherEnd := other.StartHeight + int64(other.DurationBlocks) - 1
+		if other.StartHeight <= endHeight && otherEnd >= r.StartHeight {
+			concurrentCount++
+			otherAddr, addrErr := sdk.AccAddressFromBech32(other.Participant)
+			if addrErr == nil {
+				concurrentPower = concurrentPower.Add(k.getParticipantPower(ctx, otherAddr))
+			}
+		}
+	}
+
+	var warnings []string
+
+	// Check count cap (including this reservation)
+	if concurrentCount+1 > mp.MaintenanceMaxConcurrentValidators {
+		warnings = append(warnings, fmt.Sprintf(
+			"concurrent count %d exceeds cap %d", concurrentCount+1, mp.MaintenanceMaxConcurrentValidators))
+	}
+
+	// Check power cap (including this participant). All math is integer-only
+	// (math.Int): any string persisted to state must be deterministic across
+	// architectures, and the bps multiplication must not silently overflow.
+	participantAddr, err := sdk.AccAddressFromBech32(r.Participant)
+	if err != nil {
+		return ""
+	}
+	participantPower := k.getParticipantPower(ctx, participantAddr)
+	totalPower := k.getTotalConsensusPower(ctx)
+	if totalPower.IsPositive() && mp.MaintenanceMaxConcurrentPowerBps > 0 {
+		maxPower := totalPower.MulRaw(int64(mp.MaintenanceMaxConcurrentPowerBps)).QuoRaw(10000)
+		used := concurrentPower.Add(participantPower)
+		if used.GT(maxPower) {
+			warnings = append(warnings, fmt.Sprintf(
+				"concurrent power %s exceeds cap %s (cap_bps=%d total=%s)",
+				used.String(), maxPower.String(),
+				mp.MaintenanceMaxConcurrentPowerBps, totalPower.String()))
+		}
+	}
+
+	if len(warnings) == 0 {
+		return ""
+	}
+	// Sort to guarantee deterministic state writes across all validators.
+	// concurrentPower is summed from a non-deterministic iteration order, but
+	// the final sum is order-independent; the warnings slice itself is built
+	// in a fixed order today, but sorting makes the determinism explicit and
+	// future-proof against reordering of the checks above.
+	sort.Strings(warnings)
+	return "activation-time concurrency advisory: " + strings.Join(warnings, "; ")
+}
diff --git a/inference-chain/x/inference/keeper/maintenance_test.go b/inference-chain/x/inference/keeper/maintenance_test.go
new file mode 100644
index 0000000000..7d658f8276
--- /dev/null
+++ b/inference-chain/x/inference/keeper/maintenance_test.go
@@ -0,0 +1,966 @@
+package keeper_test
+
+import (
+	"math"
+	"testing"
+
+	cosmossdk_math "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/group"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
+	keepertest "github.com/productscience/inference/testutil/keeper"
+	"github.com/productscience/inference/testutil/sample"
+	"github.com/productscience/inference/x/inference/keeper"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// createTestGroupMembers builds mock group members for filterOutMaintenanceParticipants tests.
+func createTestGroupMembers(addresses ...string) []*group.GroupMember {
+	members := make([]*group.GroupMember, len(addresses))
+	for i, addr := range addresses {
+		members[i] = &group.GroupMember{
+			Member: &group.Member{
+				Address: addr,
+				Weight:  "1",
+			},
+		}
+	}
+	return members
+}
+
+// --- Test helpers ---
+
+// setupMaintenanceTest creates a keeper, msg server, and context with maintenance enabled.
+// The mock AccountKeeper.HasAccount is configured to always return true.
+func setupMaintenanceTest(t *testing.T) (keeper.Keeper, types.MsgServer, sdk.Context) {
+	t.Helper()
+	k, ctx, mocks := keepertest.InferenceKeeperReturningMocks(t)
+	ms := keeper.NewMsgServerImpl(k)
+
+	// Allow AccountPermission checks to pass
+	mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), gomock.Any()).Return(true).AnyTimes()
+	// Concurrency checks call getParticipantPower (via GetValidator) and
+	// getTotalConsensusPower (via GetLastTotalPower). By returning
+	// ErrNoValidatorFound every participant resolves to zero power, and
+	// total power is also zero. This means the power-based concurrency cap
+	// (MaintenanceMaxConcurrentPowerBps) is effectively skipped (totalPower
+	// is not positive), so only the count-based cap applies. Tests that need
+	// to exercise the power cap should override these mocks.
+	mocks.StakingKeeper.EXPECT().GetValidator(gomock.Any(), gomock.Any()).
+		Return(stakingtypes.Validator{}, stakingtypes.ErrNoValidatorFound).AnyTimes()
+	mocks.StakingKeeper.EXPECT().GetLastTotalPower(gomock.Any()).
+		Return(cosmossdk_math.ZeroInt(), nil).AnyTimes()
+
+	// Set block height so we have room for scheduling
+	ctx = ctx.WithBlockHeight(100)
+
+	// Enable maintenance in params
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	params.MaintenanceParams = &types.MaintenanceParams{
+		MaintenanceEnabled:                            true,
+		MaintenanceMinScheduleLeadBlocks:              50,
+		MaintenanceMaxWindowBlocks:                    200,
+		MaintenanceMaxConcurrentValidators:            3,
+		MaintenanceMaxConcurrentPowerBps:              1000,
+		MaintenanceCreditCapBlocks:                    400,
+		MaintenanceCreditEarnPerSuccessfulEpochBlocks: 20,
+	}
+	require.NoError(t, k.SetParams(ctx, params))
+
+	return k, ms, ctx
+}
+
+// registerParticipant registers a participant with the given address in the keeper.
+func registerParticipant(t *testing.T, k keeper.Keeper, ctx sdk.Context, address string) {
+	t.Helper()
+	participant := types.Participant{
+		Index:   address,
+		Address: address,
+		Status:  types.ParticipantStatus_ACTIVE,
+	}
+	addr, err := sdk.AccAddressFromBech32(address)
+	require.NoError(t, err)
+	require.NoError(t, k.Participants.Set(ctx, addr, participant))
+}
+
+// grantCredit grants maintenance credit to a participant.
+func grantCredit(t *testing.T, k keeper.Keeper, ctx sdk.Context, address string, blocks uint64) {
+	t.Helper()
+	addr, err := sdk.AccAddressFromBech32(address)
+	require.NoError(t, err)
+	state := k.GetOrCreateMaintenanceState(ctx, addr)
+	state.CreditBlocks = blocks
+	require.NoError(t, k.SetMaintenanceState(ctx, state))
+}
+
+// --- 7.1: Scheduling Tests ---
+
+func TestScheduleMaintenance_Success(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.True(t, resp.ReservationId > 0)
+
+	// Verify reservation was created
+	r, found := k.GetMaintenanceReservation(ctx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, participant, r.Participant)
+	require.Equal(t, int64(500), r.StartHeight)
+	require.Equal(t, uint64(50), r.DurationBlocks)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED, r.Status)
+
+	// Verify credit was deducted
+	addr, _ := sdk.AccAddressFromBech32(participant)
+	state, found := k.GetMaintenanceState(ctx, addr)
+	require.True(t, found)
+	require.Equal(t, uint64(50), state.CreditBlocks) // 100 - 50
+	require.Equal(t, resp.ReservationId, state.ScheduledReservationId)
+}
+
+func TestScheduleMaintenance_Failures(t *testing.T) {
+	t.Parallel()
+
+	participant := sample.AccAddress()
+	unknownAddr := sample.AccAddress()
+
+	tests := []struct {
+		name        string
+		setup       func(t *testing.T, k keeper.Keeper, ctx sdk.Context)
+		msg         *types.MsgScheduleMaintenance
+		expectedErr error
+	}{
+		{
+			name: "disabled",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				registerParticipant(t, k, ctx, participant)
+				grantCredit(t, k, ctx, participant, 100)
+				params, _ := k.GetParams(ctx)
+				params.MaintenanceParams.MaintenanceEnabled = false
+				require.NoError(t, k.SetParams(ctx, params))
+			},
+			msg: &types.MsgScheduleMaintenance{
+				Creator: participant, Participant: participant,
+				StartHeight: 500, DurationBlocks: 50,
+			},
+			expectedErr: types.ErrMaintenanceDisabled,
+		},
+		{
+			name: "insufficient credit",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				registerParticipant(t, k, ctx, participant)
+				grantCredit(t, k, ctx, participant, 10)
+			},
+			msg: &types.MsgScheduleMaintenance{
+				Creator: participant, Participant: participant,
+				StartHeight: 500, DurationBlocks: 50,
+			},
+			expectedErr: types.ErrMaintenanceInsufficientCredit,
+		},
+		{
+			name: "insufficient lead time",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				registerParticipant(t, k, ctx, participant)
+				grantCredit(t, k, ctx, participant, 100)
+			},
+			msg: &types.MsgScheduleMaintenance{
+				Creator: participant, Participant: participant,
+				StartHeight: 140, DurationBlocks: 50, // block=100, lead=50, must be >= 150
+			},
+			expectedErr: types.ErrMaintenanceInsufficientLeadTime,
+		},
+		{
+			name: "duration exceeded",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				registerParticipant(t, k, ctx, participant)
+				grantCredit(t, k, ctx, participant, 400)
+			},
+			msg: &types.MsgScheduleMaintenance{
+				Creator: participant, Participant: participant,
+				StartHeight: 500, DurationBlocks: 300, // max 200
+			},
+			expectedErr: types.ErrMaintenanceDurationExceeded,
+		},
+		{
+			name: "already scheduled",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				registerParticipant(t, k, ctx, participant)
+				grantCredit(t, k, ctx, participant, 200)
+				ms := keeper.NewMsgServerImpl(k)
+				_, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+					Creator: participant, Participant: participant,
+					StartHeight: 500, DurationBlocks: 50,
+				})
+				require.NoError(t, err)
+			},
+			msg: &types.MsgScheduleMaintenance{
+				Creator: participant, Participant: participant,
+				StartHeight: 700, DurationBlocks: 50,
+			},
+			expectedErr: types.ErrMaintenanceAlreadyScheduled,
+		},
+		{
+			name: "participant not found",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				// no participant registration
+			},
+			msg: &types.MsgScheduleMaintenance{
+				Creator: unknownAddr, Participant: unknownAddr,
+				StartHeight: 500, DurationBlocks: 50,
+			},
+			expectedErr: types.ErrParticipantNotFound,
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc // capture loop variable for parallel subtests
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			k, ms, ctx := setupMaintenanceTest(t)
+			tc.setup(t, k, ctx)
+			_, err := ms.ScheduleMaintenance(ctx, tc.msg)
+			require.ErrorIs(t, err, tc.expectedErr)
+		})
+	}
+}
+
+func TestScheduleMaintenance_RejectsCompletionHeightOverflowWithoutStateMutation(t *testing.T) {
+	t.Parallel()
+
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	params.MaintenanceParams.MaintenanceMaxWindowBlocks = 100
+	require.NoError(t, k.SetParams(ctx, params))
+
+	_, err = ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    math.MaxInt64 - 49,
+		DurationBlocks: 50,
+	})
+	require.ErrorIs(t, err, types.ErrMaintenanceCompletionHeightOverflow)
+
+	addr, err := sdk.AccAddressFromBech32(participant)
+	require.NoError(t, err)
+	state, found := k.GetMaintenanceState(ctx, addr)
+	require.True(t, found)
+	require.Equal(t, uint64(100), state.CreditBlocks)
+	require.Zero(t, state.ScheduledReservationId)
+
+	_, found = k.GetMaintenanceReservation(ctx, 1)
+	require.False(t, found)
+}
+
+// --- 7.1: Cancellation Tests ---
+
+func TestCancelMaintenance_Success(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	// Schedule first
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// Cancel
+	_, err = ms.CancelMaintenance(ctx, &types.MsgCancelMaintenance{
+		Creator:       participant,
+		ReservationId: resp.ReservationId,
+	})
+	require.NoError(t, err)
+
+	// Verify reservation is canceled
+	r, found := k.GetMaintenanceReservation(ctx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED, r.Status)
+
+	// Verify credit was restored
+	addr, _ := sdk.AccAddressFromBech32(participant)
+	state, found := k.GetMaintenanceState(ctx, addr)
+	require.True(t, found)
+	require.Equal(t, uint64(100), state.CreditBlocks) // fully restored
+	require.Equal(t, uint64(0), state.ScheduledReservationId)
+}
+
+func TestCancelMaintenance_NotFound(t *testing.T) {
+	t.Parallel()
+	_, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+
+	_, err := ms.CancelMaintenance(ctx, &types.MsgCancelMaintenance{
+		Creator:       participant,
+		ReservationId: 999,
+	})
+	require.ErrorIs(t, err, types.ErrMaintenanceReservationNotFound)
+}
+
+func TestCancelMaintenance_NotScheduled(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	// Schedule and then activate (set status to active manually)
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// Manually set to active (simulating BeginBlock activation)
+	r, _ := k.GetMaintenanceReservation(ctx, resp.ReservationId)
+	r.Status = types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE
+	require.NoError(t, k.SetMaintenanceReservation(ctx, r))
+
+	// Cancel should fail — already active
+	_, err = ms.CancelMaintenance(ctx, &types.MsgCancelMaintenance{
+		Creator:       participant,
+		ReservationId: resp.ReservationId,
+	})
+	require.ErrorIs(t, err, types.ErrMaintenanceNotScheduled)
+}
+
+func TestCancelMaintenance_CreditCapRespected(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 400) // max cap
+
+	// Schedule to deduct
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// Manually set credit near cap before cancel
+	addr, _ := sdk.AccAddressFromBech32(participant)
+	state, _ := k.GetMaintenanceState(ctx, addr)
+	state.CreditBlocks = 390 // 390 + 50 = 440, but cap is 400
+	require.NoError(t, k.SetMaintenanceState(ctx, state))
+
+	// Cancel — credit should be capped
+	_, err = ms.CancelMaintenance(ctx, &types.MsgCancelMaintenance{
+		Creator:       participant,
+		ReservationId: resp.ReservationId,
+	})
+	require.NoError(t, err)
+
+	state, _ = k.GetMaintenanceState(ctx, addr)
+	require.Equal(t, uint64(400), state.CreditBlocks) // capped at 400, not 440
+}
+
+// --- 7.1: Credit Accrual Tests ---
+
+func TestCreditAccrual_CapEnforced(t *testing.T) {
+	t.Parallel()
+	k, _, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	addr, _ := sdk.AccAddressFromBech32(participant)
+
+	// Pre-load credit close to (but under) the 400-block cap so a single
+	// successful-epoch grant of 20 blocks would push us past it.
+	grantCredit(t, k, ctx, participant, 390)
+
+	require.NoError(t, k.GrantMaintenanceCredit(ctx, participant, 1))
+
+	state, found := k.GetMaintenanceState(ctx, addr)
+	require.True(t, found)
+	require.Equal(t, uint64(400), state.CreditBlocks, "GrantMaintenanceCredit must clamp at MaintenanceCreditCapBlocks")
+
+	// A second grant must not push above the cap.
+	require.NoError(t, k.GrantMaintenanceCredit(ctx, participant, 2))
+	state, _ = k.GetMaintenanceState(ctx, addr)
+	require.Equal(t, uint64(400), state.CreditBlocks, "subsequent grants must not exceed the cap")
+}
+
+// TestCreditAccrual_SuppressedAcrossEpochRange verifies that credit is not
+// granted for any epoch within [LastMaintenanceEpoch, LastMaintenanceEndEpoch],
+// covering multi-epoch maintenance windows after they have completed.
+func TestCreditAccrual_SuppressedAcrossEpochRange(t *testing.T) {
+	t.Parallel()
+	k, _, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	addr, _ := sdk.AccAddressFromBech32(participant)
+
+	// Simulate a completed multi-epoch maintenance window covering epochs 5..7.
+	state := k.GetOrCreateMaintenanceState(ctx, addr)
+	state.CreditBlocks = 100
+	state.LastMaintenanceEpoch = 5
+	state.LastMaintenanceEndEpoch = 7
+	require.NoError(t, k.SetMaintenanceState(ctx, state))
+
+	// Claims for any covered epoch must not increase credit.
+	for _, e := range []uint64{5, 6, 7} {
+		require.NoError(t, k.GrantMaintenanceCredit(ctx, participant, e))
+		st, _ := k.GetMaintenanceState(ctx, addr)
+		require.Equal(t, uint64(100), st.CreditBlocks, "credit must be suppressed for covered epoch %d", e)
+	}
+
+	// A claim for an uncovered later epoch must accrue credit normally.
+	require.NoError(t, k.GrantMaintenanceCredit(ctx, participant, 8))
+	st, _ := k.GetMaintenanceState(ctx, addr)
+	require.Equal(t, uint64(120), st.CreditBlocks, "credit must accrue for epoch outside covered range")
+}
+
+// --- 7.1: Lifecycle Tests ---
+
+func TestLifecycle_ActivateAndComplete(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// Process at start height (activation)
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	r, found := k.GetMaintenanceReservation(activateCtx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE, r.Status)
+
+	// Verify participant is in active maintenance
+	addr, _ := sdk.AccAddressFromBech32(participant)
+	require.True(t, k.IsParticipantInActiveMaintenance(activateCtx, addr))
+
+	state, _ := k.GetMaintenanceState(activateCtx, addr)
+	require.Equal(t, resp.ReservationId, state.ActiveReservationId)
+	require.Equal(t, uint64(0), state.ScheduledReservationId)
+
+	// Process at end height (completion).
+	// Window covers [500, 549] inclusive (50 blocks), so the COMPLETE transition
+	// fires at 550 (the block AFTER the last covered block). This guarantees
+	// the active duration is exactly DurationBlocks blocks.
+	lastActiveCtx := ctx.WithBlockHeight(549)
+	require.NoError(t, k.ProcessMaintenanceTransitions(lastActiveCtx))
+	require.True(t, k.IsParticipantInActiveMaintenance(lastActiveCtx, addr),
+		"participant must still be active on the final covered block")
+
+	completeCtx := ctx.WithBlockHeight(550) // 500 + 50
+	require.NoError(t, k.ProcessMaintenanceTransitions(completeCtx))
+
+	r, found = k.GetMaintenanceReservation(completeCtx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_COMPLETED, r.Status)
+
+	// Verify participant is no longer in active maintenance
+	require.False(t, k.IsParticipantInActiveMaintenance(completeCtx, addr))
+
+	state, _ = k.GetMaintenanceState(completeCtx, addr)
+	require.Equal(t, uint64(0), state.ActiveReservationId)
+}
+
+func TestLifecycle_NoTransitionsAtWrongHeight(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// Process at height 300 — nothing should happen
+	earlyCtx := ctx.WithBlockHeight(300)
+	require.NoError(t, k.ProcessMaintenanceTransitions(earlyCtx))
+
+	r, found := k.GetMaintenanceReservation(earlyCtx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED, r.Status)
+}
+
+// --- 7.1: Scheduling Availability Query ---
+
+func TestSchedulability_Success(t *testing.T) {
+	t.Parallel()
+	k, _, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	resp, err := k.MaintenanceSchedulability(ctx, &types.QueryMaintenanceSchedulabilityRequest{
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+	require.True(t, resp.Schedulable)
+	require.Empty(t, resp.RejectionReason)
+}
+
+func TestSchedulability_Failures(t *testing.T) {
+	t.Parallel()
+
+	participant := sample.AccAddress()
+
+	tests := []struct {
+		name           string
+		setup          func(t *testing.T, k keeper.Keeper, ctx sdk.Context)
+		req            *types.QueryMaintenanceSchedulabilityRequest
+		reasonContains string
+	}{
+		{
+			name: "insufficient credit",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				registerParticipant(t, k, ctx, participant)
+				grantCredit(t, k, ctx, participant, 10)
+			},
+			req: &types.QueryMaintenanceSchedulabilityRequest{
+				Participant: participant, StartHeight: 500, DurationBlocks: 50,
+			},
+			reasonContains: "insufficient",
+		},
+		{
+			name: "disabled",
+			setup: func(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
+				params, _ := k.GetParams(ctx)
+				params.MaintenanceParams.MaintenanceEnabled = false
+				require.NoError(t, k.SetParams(ctx, params))
+			},
+			req: &types.QueryMaintenanceSchedulabilityRequest{
+				Participant: participant, StartHeight: 500, DurationBlocks: 50,
+			},
+			reasonContains: "disabled",
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc // capture loop variable for parallel subtests
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			k, _, ctx := setupMaintenanceTest(t)
+			tc.setup(t, k, ctx)
+			resp, err := k.MaintenanceSchedulability(ctx, tc.req)
+			require.NoError(t, err)
+			require.False(t, resp.Schedulable)
+			require.Contains(t, resp.RejectionReason, tc.reasonContains)
+		})
+	}
+}
+
+// --- 7.1: Query Tests ---
+
+func TestQueryMaintenanceCredit(t *testing.T) {
+	t.Parallel()
+	k, _, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 75)
+
+	resp, err := k.MaintenanceCredit(ctx, &types.QueryMaintenanceCreditRequest{Participant: participant})
+	require.NoError(t, err)
+	require.True(t, resp.Found)
+	require.Equal(t, uint64(75), resp.CreditBlocks)
+}
+
+func TestQueryMaintenanceCredit_NotFound(t *testing.T) {
+	t.Parallel()
+	k, _, ctx := setupMaintenanceTest(t)
+
+	resp, err := k.MaintenanceCredit(ctx, &types.QueryMaintenanceCreditRequest{
+		Participant: sample.AccAddress(),
+	})
+	require.NoError(t, err)
+	require.False(t, resp.Found)
+	require.Equal(t, uint64(0), resp.CreditBlocks)
+}
+
+func TestQueryMaintenanceStatus(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	// Schedule a reservation
+	schedResp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// Query status
+	resp, err := k.MaintenanceStatus(ctx, &types.QueryMaintenanceStatusRequest{Participant: participant})
+	require.NoError(t, err)
+	require.True(t, resp.Found)
+	require.NotNil(t, resp.State)
+	require.Equal(t, uint64(50), resp.State.CreditBlocks)
+	require.NotNil(t, resp.ScheduledReservation)
+	require.Equal(t, schedResp.ReservationId, resp.ScheduledReservation.ReservationId)
+	require.Nil(t, resp.ActiveReservation)
+}
+
+func TestQueryMaintenanceScheduled(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	schedResp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	resp, err := k.MaintenanceScheduled(ctx, &types.QueryMaintenanceScheduledRequest{Participant: participant})
+	require.NoError(t, err)
+	require.True(t, resp.Found)
+	require.NotNil(t, resp.Reservation)
+	require.Equal(t, schedResp.ReservationId, resp.Reservation.ReservationId)
+	require.Equal(t, int64(500), resp.Reservation.StartHeight)
+}
+
+func TestQueryMaintenanceActive(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	_, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	// No active yet
+	resp, err := k.MaintenanceActive(ctx, &types.QueryMaintenanceActiveRequest{})
+	require.NoError(t, err)
+	require.Empty(t, resp.Reservations)
+
+	// Activate
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	resp, err = k.MaintenanceActive(activateCtx, &types.QueryMaintenanceActiveRequest{})
+	require.NoError(t, err)
+	require.Len(t, resp.Reservations, 1)
+	require.Equal(t, participant, resp.Reservations[0].Participant)
+}
+
+// --- 7.2: Duty Exemption Tests ---
+
+func TestIsParticipantInActiveMaintenance(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+	addr, _ := sdk.AccAddressFromBech32(participant)
+
+	// Both AccAddress and string variants return false initially
+	t.Run("not in maintenance initially", func(t *testing.T) {
+		require.False(t, k.IsParticipantInActiveMaintenance(ctx, addr))
+		require.False(t, k.IsParticipantAddressInActiveMaintenance(ctx, participant))
+	})
+
+	// Schedule — still not active
+	_, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator: participant, Participant: participant,
+		StartHeight: 500, DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	t.Run("scheduled but not yet active", func(t *testing.T) {
+		require.False(t, k.IsParticipantInActiveMaintenance(ctx, addr))
+		require.False(t, k.IsParticipantAddressInActiveMaintenance(ctx, participant))
+	})
+
+	// Activate at block 500
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	t.Run("active after activation", func(t *testing.T) {
+		require.True(t, k.IsParticipantInActiveMaintenance(activateCtx, addr))
+		require.True(t, k.IsParticipantAddressInActiveMaintenance(activateCtx, participant))
+	})
+
+	t.Run("invalid address returns false", func(t *testing.T) {
+		require.False(t, k.IsParticipantAddressInActiveMaintenance(activateCtx, "invalid-address"))
+	})
+
+	// Window covers [500, 549]; COMPLETE fires at 550
+	completeCtx := ctx.WithBlockHeight(550)
+	require.NoError(t, k.ProcessMaintenanceTransitions(completeCtx))
+
+	t.Run("not active after completion", func(t *testing.T) {
+		require.False(t, k.IsParticipantInActiveMaintenance(completeCtx, addr))
+		require.False(t, k.IsParticipantAddressInActiveMaintenance(completeCtx, participant))
+	})
+}
+
+func TestFilterOutMaintenanceParticipants(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant1 := sample.AccAddress()
+	participant2 := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant1)
+	registerParticipant(t, k, ctx, participant2)
+	grantCredit(t, k, ctx, participant1, 100)
+
+	// Schedule and activate maintenance for participant1
+	_, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant1,
+		Participant:    participant1,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	// Create mock group members
+	members := createTestGroupMembers(participant1, participant2)
+
+	// Filter should remove participant1 (in maintenance)
+	filtered := k.FilterOutMaintenanceParticipants(activateCtx, members)
+	require.Len(t, filtered, 1)
+	require.Equal(t, participant2, filtered[0].Member.Address)
+}
+
+// TestCreditAccrual_SuppressedByActiveReservation exercises the in-progress
+// branch of maintenanceStateCoversEpoch: a still-ACTIVE multi-epoch window
+// whose end epoch has not yet been finalised must suppress credit for any
+// epoch its block range overlaps, not just the activation epoch. Pre-fix the
+// claim path used a `LastMaintenanceEpoch == epoch` equality, which only
+// matched the start epoch.
+func TestCreditAccrual_SuppressedByActiveReservation(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+	addr, _ := sdk.AccAddressFromBech32(participant)
+
+	// Mid-epoch claim while the window is still ACTIVE: schedule a window
+	// covering blocks [500, 599], then activate and pin epoch boundaries so
+	// epoch 6's block range fully overlaps the window.
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 100,
+	})
+	require.NoError(t, err)
+
+	require.NoError(t, k.SetEpoch(ctx, &types.Epoch{Index: 5, PocStartBlockHeight: 400}))
+	require.NoError(t, k.SetEpoch(ctx, &types.Epoch{Index: 6, PocStartBlockHeight: 500}))
+	require.NoError(t, k.SetEpoch(ctx, &types.Epoch{Index: 7, PocStartBlockHeight: 600}))
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, 6))
+
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	// Activation wrote LastMaintenanceEpoch = LastMaintenanceEndEpoch = 6 as
+	// provisional values. Claiming epoch 6 while still ACTIVE must suppress
+	// credit via the active-reservation branch.
+	require.NoError(t, k.GrantMaintenanceCredit(activateCtx, participant, 6))
+	state, _ := k.GetMaintenanceState(activateCtx, addr)
+	require.Equal(t, uint64(0), state.CreditBlocks, "credit must be suppressed while window is ACTIVE")
+	require.Equal(t, resp.ReservationId, state.ActiveReservationId)
+}
+
+// TestScheduleMaintenance_RejectsPoCOverlapPastFixedScanHorizon verifies that
+// the phase-overlap check walks every epoch up to endHeight, not just a fixed
+// 5-epoch window. The old constant maxFutureEpochsToCheck=5 silently allowed
+// long windows whose tail landed in an unscanned epoch's PoC start.
+func TestScheduleMaintenance_RejectsPoCOverlapPastFixedScanHorizon(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+
+	// Raise the duration cap so the long window is otherwise legal.
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	params.MaintenanceParams.MaintenanceMaxWindowBlocks = 1_000_000_000_000_000
+	require.NoError(t, k.SetParams(ctx, params))
+
+	effective := types.Epoch{Index: 1, PocStartBlockHeight: 100}
+	require.NoError(t, k.SetEpoch(ctx, &effective))
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, effective.Index))
+
+	// Walk forward past where the old fixed lookahead stopped (5 future
+	// epochs). Place the window's tail exactly at the first unscanned epoch's
+	// PoC start — pre-fix this slips through; post-fix it must be rejected.
+	lastScanned := types.NewEpochContext(effective, *params.EpochParams)
+	for i := 0; i < 5; i++ {
+		lastScanned = lastScanned.NextEpochContext()
+	}
+	firstUnscanned := lastScanned.NextEpochContext()
+
+	startHeight := lastScanned.SetNewValidators() + 1
+	durationBlocks := uint64(firstUnscanned.StartOfPoC() - startHeight + 1)
+	require.Positive(t, durationBlocks)
+	grantCredit(t, k, ctx, participant, durationBlocks)
+
+	_, err = ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    startHeight,
+		DurationBlocks: durationBlocks,
+	})
+	require.ErrorIs(t, err, types.ErrMaintenanceOverlapsPoCPhase)
+}
+
+// TestLifecycle_DisabledMidWindowCompletesNormally encodes the dev_notes
+// semantics for Bug 3: flipping MaintenanceEnabled=false while a window is
+// ACTIVE must not strand the COMPLETE transition. The reservation winds down
+// through its natural end-of-window height and the participant exits ACTIVE
+// state — preventing the "stuck-active → permanent slashing immunity" bug.
+func TestLifecycle_DisabledMidWindowCompletesNormally(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	addr, _ := sdk.AccAddressFromBech32(participant)
+	require.True(t, k.IsParticipantInActiveMaintenance(activateCtx, addr),
+		"participant must be ACTIVE after activation")
+
+	// Governance disables maintenance mid-window.
+	params, err := k.GetParams(activateCtx)
+	require.NoError(t, err)
+	params.MaintenanceParams.MaintenanceEnabled = false
+	require.NoError(t, k.SetParams(activateCtx, params))
+
+	// State-machine-only semantics: in-flight ACTIVE window keeps its
+	// exemption regardless of the disable flag, until natural completion.
+	midCtx := activateCtx.WithBlockHeight(540)
+	require.True(t, k.IsParticipantInActiveMaintenance(midCtx, addr),
+		"in-flight ACTIVE window must keep exemption after disable")
+
+	// At the scheduled COMPLETE height the transition must still fire.
+	completeCtx := activateCtx.WithBlockHeight(550)
+	require.NoError(t, k.ProcessMaintenanceTransitions(completeCtx))
+
+	r, found := k.GetMaintenanceReservation(completeCtx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_COMPLETED, r.Status)
+	require.False(t, k.IsParticipantInActiveMaintenance(completeCtx, addr))
+
+	state, _ := k.GetMaintenanceState(completeCtx, addr)
+	require.Equal(t, uint64(0), state.ActiveReservationId)
+}
+
+// TestLifecycle_DisabledBeforeActivateCancelsAndRefunds covers the
+// SCHEDULED → ACTIVATE arm of Bug 3's fix: if maintenance is disabled before
+// the activation height, the reservation must not enter ACTIVE. It is
+// canceled, its pre-paid credit refunded, and its future COMPLETE alarm
+// removed — otherwise an orphan COMPLETE row would later try to complete a
+// CANCELED reservation.
+func TestLifecycle_DisabledBeforeActivateCancelsAndRefunds(t *testing.T) {
+	t.Parallel()
+	k, ms, ctx := setupMaintenanceTest(t)
+	participant := sample.AccAddress()
+	registerParticipant(t, k, ctx, participant)
+	grantCredit(t, k, ctx, participant, 100)
+
+	resp, err := ms.ScheduleMaintenance(ctx, &types.MsgScheduleMaintenance{
+		Creator:        participant,
+		Participant:    participant,
+		StartHeight:    500,
+		DurationBlocks: 50,
+	})
+	require.NoError(t, err)
+
+	addr, _ := sdk.AccAddressFromBech32(participant)
+	state, _ := k.GetMaintenanceState(ctx, addr)
+	require.Equal(t, uint64(50), state.CreditBlocks, "credit deducted at schedule")
+
+	// Disable before the activation height.
+	params, err := k.GetParams(ctx)
+	require.NoError(t, err)
+	params.MaintenanceParams.MaintenanceEnabled = false
+	require.NoError(t, k.SetParams(ctx, params))
+
+	activateCtx := ctx.WithBlockHeight(500)
+	require.NoError(t, k.ProcessMaintenanceTransitions(activateCtx))
+
+	r, found := k.GetMaintenanceReservation(activateCtx, resp.ReservationId)
+	require.True(t, found)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED, r.Status,
+		"ACTIVATE on disabled chain must cancel the SCHEDULED reservation")
+
+	state, _ = k.GetMaintenanceState(activateCtx, addr)
+	require.Equal(t, uint64(100), state.CreditBlocks, "credit must be refunded on cancel")
+	require.Equal(t, uint64(0), state.ScheduledReservationId)
+	require.Equal(t, uint64(0), state.ActiveReservationId)
+
+	// The future COMPLETE alarm must have been removed. Run the transitions
+	// at the original complete height — if the row leaked, completing a
+	// CANCELED reservation would log an error and leave dangling state.
+	completeCtx := activateCtx.WithBlockHeight(550)
+	require.NoError(t, k.ProcessMaintenanceTransitions(completeCtx))
+	r, _ = k.GetMaintenanceReservation(completeCtx, resp.ReservationId)
+	require.Equal(t, types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED, r.Status,
+		"status must remain CANCELED — orphan COMPLETE row would have driven it elsewhere")
+}
diff --git a/inference-chain/x/inference/keeper/maintenance_validation.go b/inference-chain/x/inference/keeper/maintenance_validation.go
new file mode 100644
index 0000000000..c797c7d1a0
--- /dev/null
+++ b/inference-chain/x/inference/keeper/maintenance_validation.go
@@ -0,0 +1,228 @@
+package keeper
+
+import (
+	"context"
+	"fmt"
+
+	cosmossdk_math "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// maxEpochPhaseOverlapChecks bounds the per-call iteration of the PoC/DKG
+// overlap loop so a pathological MaintenanceMaxWindowBlocks setting cannot
+// turn a single Schedule message into an unbounded compute load. The window
+// has to cross this many epochs to trigger; well above any realistic
+// maintenance horizon, so legitimate schedules are unaffected.
+const maxEpochPhaseOverlapChecks int64 = 10_000
+
+// checkEpochPhaseOverlap verifies the proposed maintenance window does not overlap
+// epoch-critical PoC commit/exchange or DKG (SetNewValidators) phases.
+//
+// Iteration shape: walk forward in epochs starting from the epoch that
+// contains startHeight, stopping the first time the next epoch's PoC start is
+// past endHeight. The previous fixed lookahead of 5 epochs was unsafe — the
+// upper bound on MaintenanceMaxWindowBlocks (1e15) is many orders of
+// magnitude above 5 epoch lengths, and startHeight itself can sit many epochs
+// past the effective epoch (governance-bound only by lead time), so any
+// fixed lookahead can leave the window's tail in an unscanned epoch's busy
+// region.
+func (k Keeper) checkEpochPhaseOverlap(ctx context.Context, startHeight int64, durationBlocks uint64, mp *types.MaintenanceParams) error {
+	endHeight := startHeight + int64(durationBlocks) - 1
+
+	params, err := k.GetParams(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get params: %w", err)
+	}
+	ep := params.EpochParams
+	if ep == nil {
+		return nil // no epoch params, skip check
+	}
+	if ep.EpochLength <= 0 {
+		// Invalid epoch params are rejected at SetParams; defending here keeps
+		// this function from entering an infinite NextEpochContext walk if a
+		// malformed state ever lands.
+		return nil
+	}
+
+	effectiveEpoch, found := k.GetEffectiveEpoch(ctx)
+	if !found {
+		return nil // no epoch yet, skip check
+	}
+
+	ec := types.NewEpochContext(*effectiveEpoch, *ep)
+
+	// Fast-forward ec to the epoch that contains startHeight. Without this,
+	// a window scheduled many epochs in the future would force the loop to
+	// walk every intermediate epoch — wasted work and a DoS surface.
+	// Uniform EpochLength is assumed (NextEpochContext advances by exactly
+	// EpochLength); historical re-anchoring is not needed because the schedule
+	// path operates entirely against the current epoch params.
+	if ec.EpochIndex > 0 && startHeight > ec.StartOfPoC() {
+		steps := (startHeight - ec.StartOfPoC()) / ep.EpochLength
+		ec.EpochIndex += uint64(steps)
+		ec.PocStartBlockHeight += steps * ep.EpochLength
+	}
+
+	for checked := int64(0); ; checked++ {
+		if checked >= maxEpochPhaseOverlapChecks {
+			return fmt.Errorf("maintenance window spans more than %d epochs: %w",
+				maxEpochPhaseOverlapChecks, types.ErrMaintenanceDurationExceeded)
+		}
+
+		if ec.EpochIndex != 0 {
+			// PoC commit/exchange overlap
+			pocStart := ec.StartOfPoC()
+			pocExchangeEnd := ec.PoCExchangeDeadline()
+			if startHeight <= pocExchangeEnd && endHeight >= pocStart {
+				return types.ErrMaintenanceOverlapsPoCPhase
+			}
+
+			// PoC validation overlap
+			valStart := ec.StartOfPoCValidation()
+			valEnd := ec.EndOfPoCValidation()
+			if startHeight <= valEnd && endHeight >= valStart {
+				return types.ErrMaintenanceOverlapsPoCPhase
+			}
+
+			// SetNewValidators (DKG) overlap
+			setNewVal := ec.SetNewValidators()
+			if startHeight <= setNewVal && endHeight >= setNewVal {
+				return types.ErrMaintenanceOverlapsDKGPhase
+			}
+		}
+
+		next := ec.NextEpochContext()
+		if next.StartOfPoC() > endHeight {
+			return nil
+		}
+		ec = next
+	}
+}
+
+// checkConcurrencyLimits verifies that adding a new reservation does not exceed
+// concurrent participant count or power caps at scheduling time.
+//
+// Instead of scanning a start-height index (which suffered from unbounded growth
+// of completed entries), this iterates the bounded set of ACTIVE + SCHEDULED
+// reservations derived from MaintenanceStates. The size is at most
+// 2 * total_participants, and in practice much smaller.
+//
+// All power math is done in math.Int (cosmossdk_math.Int) to avoid int64
+// overflow on either token aggregation or the bps multiplication.
+func (k Keeper) checkConcurrencyLimits(ctx context.Context, startHeight int64, durationBlocks uint64, participant sdk.AccAddress, mp *types.MaintenanceParams) error {
+	endHeight := startHeight + int64(durationBlocks) - 1
+
+	reservations, err := k.collectActiveAndScheduledReservations(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to check concurrency: %w", err)
+	}
+
+	concurrentCount := uint32(0)
+	concurrentPower := cosmossdk_math.ZeroInt()
+	participantPower := k.getParticipantPower(ctx, participant)
+
+	for _, r := range reservations {
+		rEnd := r.StartHeight + int64(r.DurationBlocks) - 1
+		if r.StartHeight <= endHeight && rEnd >= startHeight {
+			concurrentCount++
+			rAddr, addrErr := sdk.AccAddressFromBech32(r.Participant)
+			if addrErr == nil {
+				concurrentPower = concurrentPower.Add(k.getParticipantPower(ctx, rAddr))
+			}
+		}
+	}
+
+	// Check count cap (including the new reservation)
+	if concurrentCount+1 > mp.MaintenanceMaxConcurrentValidators {
+		return types.ErrMaintenanceConcurrentCountExceeded
+	}
+
+	// Check power cap (including this participant's power) using integer math.
+	totalPower := k.getTotalConsensusPower(ctx)
+	if totalPower.IsPositive() && mp.MaintenanceMaxConcurrentPowerBps > 0 {
+		maxPower := totalPower.MulRaw(int64(mp.MaintenanceMaxConcurrentPowerBps)).QuoRaw(10000)
+		if concurrentPower.Add(participantPower).GT(maxPower) {
+			return types.ErrMaintenanceConcurrentPowerExceeded
+		}
+	}
+
+	return nil
+}
+
+// validatorPower returns the consensus power of v as a math.Int. Using
+// TokensFromConsensusPower's inverse here would lose precision; instead we
+// just return v.Tokens, which is the effective bonded-token weight that
+// underlies consensus power. The caller compares this against bps of the
+// total bonded tokens, so the units are consistent.
+func validatorPower(v stakingtypes.Validator) cosmossdk_math.Int {
+	return v.Tokens
+}
+
+// checkParticipantOverlap checks that the proposed window does not overlap
+// with any existing scheduled/active reservation for the same participant.
+// Since MaintenanceState tracks at most 1 active + 1 scheduled reservation per
+// participant, this is a simple direct lookup — no index scan needed.
+func (k Keeper) checkParticipantOverlap(ctx context.Context, participant sdk.AccAddress, startHeight int64, durationBlocks uint64) error {
+	endHeight := startHeight + int64(durationBlocks) - 1
+
+	state, found := k.GetMaintenanceState(ctx, participant)
+	if !found {
+		return nil
+	}
+
+	// Check active reservation overlap
+	if state.ActiveReservationId != 0 {
+		if r, ok := k.GetMaintenanceReservation(ctx, state.ActiveReservationId); ok {
+			rEnd := r.StartHeight + int64(r.DurationBlocks) - 1
+			if r.StartHeight <= endHeight && rEnd >= startHeight {
+				return types.ErrMaintenanceOverlap
+			}
+		}
+	}
+
+	// Check scheduled reservation overlap
+	if state.ScheduledReservationId != 0 {
+		if r, ok := k.GetMaintenanceReservation(ctx, state.ScheduledReservationId); ok {
+			rEnd := r.StartHeight + int64(r.DurationBlocks) - 1
+			if r.StartHeight <= endHeight && rEnd >= startHeight {
+				return types.ErrMaintenanceOverlap
+			}
+		}
+	}
+
+	return nil
+}
+
+// getParticipantPower returns the consensus power (in bonded-token units, as
+// math.Int) for a participant. Returns ZeroInt if the participant is not a
+// validator. This is an O(1) lookup via the staking keeper — no full
+// validator-set scan.
+func (k Keeper) getParticipantPower(ctx context.Context, participant sdk.AccAddress) cosmossdk_math.Int {
+	// In Gonka, the participant account address bytes match the validator
+	// operator address bytes, so we can convert directly.
+	v, err := k.Staking.GetValidator(ctx, sdk.ValAddress(participant))
+	if err != nil {
+		return cosmossdk_math.ZeroInt()
+	}
+	return validatorPower(v)
+}
+
+// getTotalConsensusPower returns the total bonded-token power across all
+// validators as a math.Int. Uses GetLastTotalPower (which returns the staking
+// module's cached LastTotalPower in *consensus power* units, then re-scales
+// back to bonded-token units to keep units consistent with getParticipantPower).
+//
+// We multiply by DefaultPowerReduction to convert "consensus power units" back
+// to "bonded-token units" so that the bps comparison in checkConcurrencyLimits
+// is unit-consistent: both sides are bonded-token amounts.
+func (k Keeper) getTotalConsensusPower(ctx context.Context) cosmossdk_math.Int {
+	totalConsPower, err := k.Staking.GetLastTotalPower(ctx)
+	if err != nil {
+		return cosmossdk_math.ZeroInt()
+	}
+	// LastTotalPower is stored in consensus-power units; reverse the
+	// PowerReduction to get bonded-token units.
+	return totalConsPower.Mul(sdk.DefaultPowerReduction)
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_cancel_maintenance.go b/inference-chain/x/inference/keeper/msg_server_cancel_maintenance.go
new file mode 100644
index 0000000000..5126a674c5
--- /dev/null
+++ b/inference-chain/x/inference/keeper/msg_server_cancel_maintenance.go
@@ -0,0 +1,100 @@
+package keeper
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func (k msgServer) CancelMaintenance(goCtx context.Context, msg *types.MsgCancelMaintenance) (*types.MsgCancelMaintenanceResponse, error) {
+	if err := k.CheckPermission(goCtx, msg, AccountPermission); err != nil {
+		return nil, err
+	}
+
+	sdkCtx := sdk.UnwrapSDKContext(goCtx)
+
+	// Look up the reservation
+	r, found := k.GetMaintenanceReservation(goCtx, msg.ReservationId)
+	if !found {
+		return nil, types.ErrMaintenanceReservationNotFound
+	}
+
+	// Only scheduled reservations can be canceled
+	if r.Status != types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED {
+		return nil, types.ErrMaintenanceNotScheduled
+	}
+
+	// Authorization: only the participant themselves may cancel their
+	// reservation. ScheduleMaintenance enforces Creator == Participant, so
+	// CreatedBy on existing rows is always equal to Participant — comparing
+	// against r.CreatedBy here is redundant and would silently widen
+	// authorization if the schedule-side constraint were ever relaxed.
+	if msg.Creator != r.Participant {
+		return nil, types.ErrInvalidPermission
+	}
+
+	// Transition to canceled
+	r.Status = types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED
+	if err := k.SetMaintenanceReservation(goCtx, r); err != nil {
+		return nil, err
+	}
+
+	// Remove from scheduled index (no-op if absent).
+	if err := k.MaintenanceScheduledIndex.Remove(goCtx, r.ReservationId); err != nil {
+		return nil, fmt.Errorf("failed to remove scheduled index entry: %w", err)
+	}
+
+	// Restore credit to participant
+	participantAddr, err := sdk.AccAddressFromBech32(r.Participant)
+	if err != nil {
+		return nil, err
+	}
+	state := k.GetOrCreateMaintenanceState(goCtx, participantAddr)
+	state.CreditBlocks += r.DurationBlocks
+	// Cap credit at max
+	mp := k.GetMaintenanceParams(goCtx)
+	if mp != nil && state.CreditBlocks > mp.MaintenanceCreditCapBlocks {
+		state.CreditBlocks = mp.MaintenanceCreditCapBlocks
+	}
+	state.ScheduledReservationId = 0
+	if err := k.SetMaintenanceState(goCtx, state); err != nil {
+		return nil, err
+	}
+
+	// Remove transition schedule entries. The COMPLETE transition height must
+	// match what ScheduleMaintenance wrote: startHeight + DurationBlocks
+	// (the block AFTER the last covered block). Guard against int64 overflow:
+	// DurationBlocks is uint64 and although ScheduleMaintenance enforces a
+	// governance-bounded cap, defense-in-depth here keeps a corrupt or
+	// pre-validation reservation from producing a wrap-around height that
+	// would silently miss the delete and leave a stale transition row behind.
+	if r.DurationBlocks > math.MaxInt64 || r.StartHeight > math.MaxInt64-int64(r.DurationBlocks) {
+		return nil, fmt.Errorf("reservation %d has invalid start/duration that would overflow completion height", r.ReservationId)
+	}
+	completeHeight := r.StartHeight + int64(r.DurationBlocks)
+	if err := k.DeleteMaintenanceTransition(goCtx, r.StartHeight, r.ReservationId); err != nil {
+		return nil, fmt.Errorf("failed to delete activate transition: %w", err)
+	}
+	if err := k.DeleteMaintenanceTransition(goCtx, completeHeight, r.ReservationId); err != nil {
+		return nil, fmt.Errorf("failed to delete complete transition: %w", err)
+	}
+
+	k.LogInfo("Maintenance window canceled",
+		types.Maintenance,
+		"reservation_id", r.ReservationId,
+		"participant", r.Participant,
+		"credit_restored", r.DurationBlocks,
+	)
+
+	sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+		"maintenance_canceled",
+		sdk.NewAttribute("reservation_id", fmt.Sprint(r.ReservationId)),
+		sdk.NewAttribute("participant", r.Participant),
+		sdk.NewAttribute("credit_restored", fmt.Sprint(r.DurationBlocks)),
+	))
+
+	return &types.MsgCancelMaintenanceResponse{}, nil
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_claim_rewards.go b/inference-chain/x/inference/keeper/msg_server_claim_rewards.go
index a3430034fc..582bd21be7 100644
--- a/inference-chain/x/inference/keeper/msg_server_claim_rewards.go
+++ b/inference-chain/x/inference/keeper/msg_server_claim_rewards.go
@@ -66,9 +66,20 @@ func (ms msgServer) payoutClaim(ctx sdk.Context, msg *types.MsgClaimRewards, set
 
 	// Use CacheContext so all payout mutations are atomic.
 	// If any payment fails, nothing is committed and the settle record
-	// persists for retry.
+	// + scheduled recipient persist for retry.
 	cacheCtx, writeFn := ctx.CacheContext()
 
+	// Resolve the destination once, using cacheCtx so the lookup view is
+	// consistent with the writes below. Recipient is already bech32-validated
+	// at the SetClaimRecipients write path; if not scheduled, returns msg.Creator.
+	payoutAddress, err := ms.resolvePayoutAddress(cacheCtx, msg.Creator, msg.EpochIndex)
+	if err != nil {
+		return &types.MsgClaimRewardsResponse{
+			Amount: 0,
+			Result: "Claim recipient lookup failed, claim can be retried",
+		}, err
+	}
+
 	// Pay for work from escrow
 	escrowPayment := settleAmount.GetWorkCoins()
 	params, err := ms.GetParams(cacheCtx)
@@ -76,7 +87,7 @@ func (ms msgServer) payoutClaim(ctx sdk.Context, msg *types.MsgClaimRewards, set
 		return nil, fmt.Errorf("failed to get params: %w", err)
 	}
 	workVestingPeriod := &params.TokenomicsParams.WorkVestingPeriod
-	if err := ms.PayParticipantFromEscrow(cacheCtx, msg.Creator, int64(escrowPayment), "work_coins:"+settleAmount.Participant, workVestingPeriod); err != nil {
+	if err := ms.PayParticipantFromEscrow(cacheCtx, payoutAddress, int64(escrowPayment), "work_coins:"+settleAmount.Participant, workVestingPeriod); err != nil {
 		if sdkerrors.ErrInsufficientFunds.Is(err) {
 			ms.LogError("Insufficient funds for paying participant for work, claim can be retried", types.Claims, "error", err, "settleAmount", settleAmount)
 			return &types.MsgClaimRewardsResponse{
@@ -96,7 +107,7 @@ func (ms msgServer) payoutClaim(ctx sdk.Context, msg *types.MsgClaimRewards, set
 
 	// Pay rewards from module
 	rewardVestingPeriod := &params.TokenomicsParams.RewardVestingPeriod
-	if err := ms.PayParticipantFromModule(cacheCtx, msg.Creator, int64(settleAmount.GetRewardCoins()), types.ModuleName, "reward_coins:"+settleAmount.Participant, rewardVestingPeriod); err != nil {
+	if err := ms.PayParticipantFromModule(cacheCtx, payoutAddress, int64(settleAmount.GetRewardCoins()), types.ModuleName, "reward_coins:"+settleAmount.Participant, rewardVestingPeriod); err != nil {
 		if sdkerrors.ErrInsufficientFunds.Is(err) {
 			ms.LogError("Insufficient funds for paying rewards, claim can be retried", types.Claims, "error", err, "settleAmount", settleAmount)
 		} else {
@@ -123,6 +134,18 @@ func (ms msgServer) payoutClaim(ctx sdk.Context, msg *types.MsgClaimRewards, set
 	}, nil
 }
 
+// resolvePayoutAddress returns the destination address for a claim payout.
+func (ms msgServer) resolvePayoutAddress(ctx context.Context, participant string, epoch uint64) (string, error) {
+	addr, err := ms.ResolveClaimRecipientAddress(ctx, participant, epoch)
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve claim recipient for participant %s epoch %d: %w", participant, epoch, err)
+	}
+	if addr.String() != participant {
+		ms.LogInfo("Using scheduled claim recipient", types.Claims, "participant", participant, "epoch", epoch, "recipient", addr.String())
+	}
+	return addr.String(), nil
+}
+
 func (ms msgServer) finishSettle(ctx sdk.Context, settleAmount *types.SettleAmount) {
 	ms.RemoveSettleAmount(ctx, settleAmount.Participant)
 	perfSummary, found := ms.GetEpochPerformanceSummary(ctx, settleAmount.EpochIndex, settleAmount.Participant)
@@ -133,6 +156,14 @@ func (ms msgServer) finishSettle(ctx sdk.Context, settleAmount *types.SettleAmou
 			ms.LogError("Error setting epoch performance summary", types.Claims, "error", err)
 		}
 	}
+
+	// Grant maintenance credit for this successfully claimed epoch
+	if err := ms.GrantMaintenanceCredit(ctx, settleAmount.Participant, settleAmount.EpochIndex); err != nil {
+		ms.LogError("Error granting maintenance credit", types.Maintenance,
+			"participant", settleAmount.Participant,
+			"epoch", settleAmount.EpochIndex,
+			"error", err)
+	}
 }
 
 func (k msgServer) validateRequest(ctx sdk.Context, msg *types.MsgClaimRewards) (*types.SettleAmount, *types.MsgClaimRewardsResponse) {
@@ -231,6 +262,21 @@ func (k msgServer) validateClaim(ctx sdk.Context, msg *types.MsgClaimRewards, se
 }
 
 func (k msgServer) hasSignificantMissedValidations(ctx sdk.Context, msg *types.MsgClaimRewards) (bool, error) {
+	// Exempt participants who had a maintenance window covering the claimed
+	// epoch. Uses the same coverage check as GrantMaintenanceCredit so the
+	// two paths cannot disagree — otherwise a multi-epoch window's mid/end
+	// epoch could pass credit suppression but fail missed-validation here
+	// (the `==` match used previously only covered the window's start epoch).
+	participantAddr, err := sdk.AccAddressFromBech32(msg.Creator)
+	if err == nil {
+		state, found := k.GetMaintenanceState(ctx, participantAddr)
+		if found && k.maintenanceStateCoversEpoch(ctx, state, msg.EpochIndex) {
+			k.LogInfo("Skipping missed validation check: participant had maintenance in this epoch",
+				types.Maintenance, "participant", msg.Creator, "epoch", msg.EpochIndex)
+			return false, nil
+		}
+	}
+
 	//nolint:forbidigo // Must in different context
 	mustBeValidated, err := k.getMustBeValidatedInferences(ctx, msg)
 	if err != nil {
@@ -482,21 +528,21 @@ func (k msgServer) getMustBeValidatedInferences(ctx sdk.Context, msg *types.MsgC
 		}
 
 		k.LogDebug("Getting validation", types.Claims, "seed", msg.Seed, "totalWeight", totalWeight, "executorPower", executorPower, "validatorPower", validatorPowerForModel)
-		safeTotalWeight, err := safeUint32FromInt64(totalWeight)
+		safeTotalWeight, err := safeUint64FromInt64(totalWeight)
 		if err != nil {
-			k.LogError("Weight overflow in validation sampling", types.Claims,
+			k.LogError("Negative weight in validation sampling", types.Claims,
 				"totalWeight", totalWeight, "error", err, "inference", inference.InferenceId)
 			continue // Skip this inference -- can't compute validation probability safely
 		}
-		safeValidatorWeight, err := safeUint32FromInt64(validatorPowerForModel.Weight)
+		safeValidatorWeight, err := safeUint64FromInt64(validatorPowerForModel.Weight)
 		if err != nil {
-			k.LogError("Weight overflow in validation sampling", types.Claims,
+			k.LogError("Negative weight in validation sampling", types.Claims,
 				"validatorWeight", validatorPowerForModel.Weight, "error", err, "inference", inference.InferenceId)
 			continue
 		}
-		safeExecutorWeight, err := safeUint32FromInt64(executorPower.Weight)
+		safeExecutorWeight, err := safeUint64FromInt64(executorPower.Weight)
 		if err != nil {
-			k.LogError("Weight overflow in validation sampling", types.Claims,
+			k.LogError("Negative weight in validation sampling", types.Claims,
 				"executorWeight", executorPower.Weight, "error", err, "inference", inference.InferenceId)
 			continue
 		}
diff --git a/inference-chain/x/inference/keeper/msg_server_claim_rewards_test.go b/inference-chain/x/inference/keeper/msg_server_claim_rewards_test.go
index 7889136c67..ec1b1b411b 100644
--- a/inference-chain/x/inference/keeper/msg_server_claim_rewards_test.go
+++ b/inference-chain/x/inference/keeper/msg_server_claim_rewards_test.go
@@ -1166,3 +1166,145 @@ func pocAvailabilityTest(t *testing.T, validatorIsAvailableDuringPoC bool) {
 		require.Equal(t, "Rewards claimed successfully", resp.Result)
 	}
 }
+
+func TestPayoutClaim_WithSchedule(t *testing.T) {
+	k, ms, ctx, mocks := setupKeeperWithMocks(t)
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+
+	mockAccount := NewMockAccount(testutil.Creator)
+	seed := uint64(1)
+	seedBytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(seedBytes, seed)
+	signature, err := mockAccount.key.Sign(seedBytes)
+	require.NoError(t, err)
+	signatureHex := hex.EncodeToString(signature)
+
+	epochIndex := uint64(100)
+	k.SetEpoch(sdkCtx, &types.Epoch{Index: epochIndex, PocStartBlockHeight: 1000})
+	currentEpochIndex := uint64(101)
+	k.SetEpoch(sdkCtx, &types.Epoch{Index: currentEpochIndex, PocStartBlockHeight: 2000})
+	require.NoError(t, k.SetEffectiveEpochIndex(sdkCtx, currentEpochIndex))
+
+	k.SetEpochGroupData(sdkCtx, types.EpochGroupData{
+		EpochIndex: currentEpochIndex, EpochGroupId: 101, PocStartBlockHeight: currentEpochIndex,
+		ValidationWeights: []*types.ValidationWeight{{MemberAddress: testutil.Creator, Weight: 10}},
+	})
+	k.SetEpochGroupData(sdkCtx, types.EpochGroupData{
+		EpochIndex: epochIndex, EpochGroupId: 100, PocStartBlockHeight: epochIndex,
+		ValidationWeights: []*types.ValidationWeight{{MemberAddress: testutil.Creator, Weight: 10}},
+	})
+
+	require.NoError(t, k.SetSettleAmount(sdkCtx, types.SettleAmount{
+		Participant: testutil.Creator, EpochIndex: epochIndex, WorkCoins: 1000, RewardCoins: 500, SeedSignature: signatureHex,
+	}))
+	k.SetEpochPerformanceSummary(sdkCtx, types.EpochPerformanceSummary{
+		EpochIndex: epochIndex, ParticipantId: testutil.Creator,
+	})
+	require.NoError(t, k.SeedEpochGroupValidationEntries(sdkCtx, types.EpochGroupValidations{
+		Participant: testutil.Creator, EpochIndex: epochIndex, ValidatedInferences: []string{"inference1"},
+	}))
+
+	creatorAddr, err := sdk.AccAddressFromBech32(testutil.Creator)
+	require.NoError(t, err)
+	k.Participants.Set(sdkCtx, creatorAddr, types.Participant{Index: testutil.Creator, Address: testutil.Creator, Status: types.ParticipantStatus_ACTIVE})
+	k.SetActiveParticipants(sdkCtx, types.ActiveParticipants{EpochId: epochIndex, Participants: []*types.ActiveParticipant{{Index: testutil.Creator}}})
+	k.SetActiveParticipants(sdkCtx, types.ActiveParticipants{EpochId: currentEpochIndex, Participants: []*types.ActiveParticipant{{Index: testutil.Creator}}})
+
+	// Scheduled recipient: a different, valid address owned by nobody in the test.
+	recipientStr := testutil.Bech32Addr(7)
+	recipientAddr, err := sdk.AccAddressFromBech32(recipientStr)
+	require.NoError(t, err)
+	require.NoError(t, k.SetClaimRecipientForEpoch(sdkCtx, creatorAddr, epochIndex, recipientStr))
+
+	mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), creatorAddr).Return(true).AnyTimes()
+	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), creatorAddr).Return(mockAccount).AnyTimes()
+	mocks.AuthzKeeper.EXPECT().GranterGrants(gomock.Any(), gomock.Any()).Return(&authztypes.QueryGranterGrantsResponse{Grants: []*authztypes.GrantAuthorization{}}, nil).AnyTimes()
+
+	workCoins := sdk.NewCoins(sdk.NewInt64Coin(types.BaseCoin, 1000))
+	rewardCoins := sdk.NewCoins(sdk.NewInt64Coin(types.BaseCoin, 500))
+	// Rewards must go to recipientAddr, NOT creatorAddr.
+	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, recipientAddr, workCoins, gomock.Any()).Return(nil)
+	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, recipientAddr, rewardCoins, gomock.Any()).Return(nil)
+
+	resp, err := ms.ClaimRewards(ctx.WithBlockHeight(claimDebounceBlocks+1), &types.MsgClaimRewards{
+		Creator: testutil.Creator, EpochIndex: epochIndex, Seed: int64(seed),
+	})
+	require.NoError(t, err)
+	require.Equal(t, uint64(1500), resp.Amount)
+	require.Equal(t, "Rewards claimed successfully", resp.Result)
+
+	// Entry is retained after successful claim so late/direct payouts for the
+	// same epoch can still resolve the configured recipient.
+	_, found, err := k.GetClaimRecipientForEpoch(sdkCtx, creatorAddr, epochIndex)
+	require.NoError(t, err)
+	require.True(t, found, "claim recipient entry must remain until pruning")
+}
+
+func TestPayoutClaim_WithScheduleAndVesting(t *testing.T) {
+	k, ms, ctx, mocks := setupKeeperWithMocks(t)
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+
+	mockAccount := NewMockAccount(testutil.Creator)
+	seed := uint64(1)
+	seedBytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(seedBytes, seed)
+	signature, err := mockAccount.key.Sign(seedBytes)
+	require.NoError(t, err)
+	signatureHex := hex.EncodeToString(signature)
+
+	params := types.DefaultParams()
+	params.TokenomicsParams.WorkVestingPeriod = 180
+	params.TokenomicsParams.RewardVestingPeriod = 180
+	require.NoError(t, k.SetParams(sdkCtx, params))
+
+	epochIndex := uint64(100)
+	k.SetEpoch(sdkCtx, &types.Epoch{Index: epochIndex, PocStartBlockHeight: 1000})
+	currentEpochIndex := uint64(101)
+	k.SetEpoch(sdkCtx, &types.Epoch{Index: currentEpochIndex, PocStartBlockHeight: 2000})
+	require.NoError(t, k.SetEffectiveEpochIndex(sdkCtx, currentEpochIndex))
+
+	k.SetEpochGroupData(sdkCtx, types.EpochGroupData{
+		EpochIndex: currentEpochIndex, EpochGroupId: 101, PocStartBlockHeight: currentEpochIndex,
+		ValidationWeights: []*types.ValidationWeight{{MemberAddress: testutil.Creator, Weight: 10}},
+	})
+	k.SetEpochGroupData(sdkCtx, types.EpochGroupData{
+		EpochIndex: epochIndex, EpochGroupId: 100, PocStartBlockHeight: epochIndex,
+		ValidationWeights: []*types.ValidationWeight{{MemberAddress: testutil.Creator, Weight: 10}},
+	})
+
+	require.NoError(t, k.SetSettleAmount(sdkCtx, types.SettleAmount{
+		Participant: testutil.Creator, EpochIndex: epochIndex, WorkCoins: 1000, RewardCoins: 500, SeedSignature: signatureHex,
+	}))
+	k.SetEpochPerformanceSummary(sdkCtx, types.EpochPerformanceSummary{
+		EpochIndex: epochIndex, ParticipantId: testutil.Creator,
+	})
+	require.NoError(t, k.SeedEpochGroupValidationEntries(sdkCtx, types.EpochGroupValidations{
+		Participant: testutil.Creator, EpochIndex: epochIndex, ValidatedInferences: []string{"inference1"},
+	}))
+
+	creatorAddr, err := sdk.AccAddressFromBech32(testutil.Creator)
+	require.NoError(t, err)
+	k.Participants.Set(sdkCtx, creatorAddr, types.Participant{Index: testutil.Creator, Address: testutil.Creator, Status: types.ParticipantStatus_ACTIVE})
+	k.SetActiveParticipants(sdkCtx, types.ActiveParticipants{EpochId: epochIndex, Participants: []*types.ActiveParticipant{{Index: testutil.Creator}}})
+	k.SetActiveParticipants(sdkCtx, types.ActiveParticipants{EpochId: currentEpochIndex, Participants: []*types.ActiveParticipant{{Index: testutil.Creator}}})
+
+	recipientStr := testutil.Bech32Addr(8)
+	require.NoError(t, k.SetClaimRecipientForEpoch(sdkCtx, creatorAddr, epochIndex, recipientStr))
+
+	mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), creatorAddr).Return(true).AnyTimes()
+	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), creatorAddr).Return(mockAccount).AnyTimes()
+	mocks.AuthzKeeper.EXPECT().GranterGrants(gomock.Any(), gomock.Any()).Return(&authztypes.QueryGranterGrantsResponse{Grants: []*authztypes.GrantAuthorization{}}, nil).AnyTimes()
+
+	workCoins := sdk.NewCoins(sdk.NewInt64Coin(types.BaseCoin, 1000))
+	rewardCoins := sdk.NewCoins(sdk.NewInt64Coin(types.BaseCoin, 500))
+	// Vesting path: AddVestedRewards must be called with recipientStr (not creator).
+	mocks.StreamVestingKeeper.EXPECT().AddVestedRewards(gomock.Any(), recipientStr, gomock.Any(), workCoins, gomock.Any(), gomock.Any()).Return(nil)
+	mocks.StreamVestingKeeper.EXPECT().AddVestedRewards(gomock.Any(), recipientStr, gomock.Any(), rewardCoins, gomock.Any(), gomock.Any()).Return(nil)
+
+	resp, err := ms.ClaimRewards(ctx.WithBlockHeight(claimDebounceBlocks+1), &types.MsgClaimRewards{
+		Creator: testutil.Creator, EpochIndex: epochIndex, Seed: int64(seed),
+	})
+	require.NoError(t, err)
+	require.Equal(t, uint64(1500), resp.Amount)
+	require.Equal(t, "Rewards claimed successfully", resp.Result)
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_classic_inference_deprecated_test.go b/inference-chain/x/inference/keeper/msg_server_classic_inference_deprecated_test.go
new file mode 100644
index 0000000000..9431a2fa08
--- /dev/null
+++ b/inference-chain/x/inference/keeper/msg_server_classic_inference_deprecated_test.go
@@ -0,0 +1,87 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"cosmossdk.io/errors"
+	"github.com/productscience/inference/testutil"
+	"github.com/productscience/inference/x/inference/types"
+	"github.com/stretchr/testify/require"
+)
+
+const classicInferenceDeprecatedText = "classic inference is deprecated"
+
+func TestMsgServer_ClassicStartInferenceDeprecated(t *testing.T) {
+	k, ms, ctx := setupMsgServer(t)
+	_ = k.SetEffectiveEpochIndex(ctx, 1)
+	AddParticipantToActive(ctx, &k, testutil.Creator, 1)
+
+	resp, err := ms.StartInference(ctx, &types.MsgStartInference{
+		Creator:     testutil.Creator,
+		InferenceId: "classic-start",
+	})
+
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.Equal(t, "classic-start", resp.InferenceIndex)
+	require.Contains(t, resp.ErrorMessage, classicInferenceDeprecatedText)
+	_, found := k.GetInference(ctx, "classic-start")
+	require.False(t, found)
+}
+
+func TestMsgServer_ClassicFinishInferenceDeprecated(t *testing.T) {
+	k, ms, ctx := setupMsgServer(t)
+	_ = k.SetEffectiveEpochIndex(ctx, 1)
+	AddParticipantToActive(ctx, &k, testutil.Creator, 1)
+
+	resp, err := ms.FinishInference(ctx, &types.MsgFinishInference{
+		Creator:     testutil.Creator,
+		ExecutedBy:  testutil.Creator,
+		InferenceId: "classic-finish",
+	})
+
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	require.Equal(t, "classic-finish", resp.InferenceIndex)
+	require.Contains(t, resp.ErrorMessage, classicInferenceDeprecatedText)
+	_, found := k.GetInference(ctx, "classic-finish")
+	require.False(t, found)
+}
+
+func TestMsgServer_ClassicValidationDeprecated(t *testing.T) {
+	k, ms, ctx := setupMsgServer(t)
+	_ = k.SetEffectiveEpochIndex(ctx, 1)
+	AddParticipantToActive(ctx, &k, testutil.Validator, 1)
+
+	_, err := ms.Validation(ctx, &types.MsgValidation{
+		Creator:     testutil.Validator,
+		InferenceId: "classic-validation",
+	})
+
+	require.True(t, errors.IsOf(err, types.ErrDeprecated), "err=%v", err)
+	require.Contains(t, err.Error(), classicInferenceDeprecatedText)
+}
+
+func TestMsgServer_ClassicInvalidateInferenceDeprecated(t *testing.T) {
+	_, ms, ctx := setupMsgServer(t)
+
+	_, err := ms.InvalidateInference(ctx, &types.MsgInvalidateInference{
+		Creator:     testutil.Requester,
+		InferenceId: "classic-invalidate",
+	})
+
+	require.True(t, errors.IsOf(err, types.ErrDeprecated), "err=%v", err)
+	require.Contains(t, err.Error(), classicInferenceDeprecatedText)
+}
+
+func TestMsgServer_ClassicRevalidateInferenceDeprecated(t *testing.T) {
+	_, ms, ctx := setupMsgServer(t)
+
+	_, err := ms.RevalidateInference(ctx, &types.MsgRevalidateInference{
+		Creator:     testutil.Requester,
+		InferenceId: "classic-revalidate",
+	})
+
+	require.True(t, errors.IsOf(err, types.ErrDeprecated), "err=%v", err)
+	require.Contains(t, err.Error(), classicInferenceDeprecatedText)
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow.go b/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow.go
index 1e36f18a2e..d47a7a69e9 100644
--- a/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow.go
+++ b/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow.go
@@ -105,6 +105,7 @@ func (k msgServer) CreateDevshardEscrow(goCtx context.Context, msg *types.MsgCre
 		InferenceSealGraceNonces:  types.DevshardInferenceSealGraceNoncesForCreate(ep, uint32(len(slots))),
 		InferenceSealGraceSeconds: types.DevshardInferenceSealGraceSecondsForCreate(ep),
 		AutoSealEveryNNonces:      types.DevshardAutoSealEveryNNoncesForCreate(ep),
+		ValidationRate:            types.DevshardValidationRateForCreate(ep),
 	}
 
 	id, err := k.StoreDevshardEscrow(goCtx, escrow, nextID)
diff --git a/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow_test.go b/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow_test.go
index b634529c7e..5f0aef9dee 100644
--- a/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow_test.go
+++ b/inference-chain/x/inference/keeper/msg_server_create_devshard_escrow_test.go
@@ -100,6 +100,9 @@ func TestCreateDevshardEscrow_HappyPath(t *testing.T) {
 	require.Equal(t, types.DevshardAutoSealEveryNNoncesForCreate(
 		types.DefaultDevshardEscrowParams(),
 	), escrow.AutoSealEveryNNonces)
+	require.Equal(t, types.DevshardValidationRateForCreate(
+		types.DefaultDevshardEscrowParams(),
+	), escrow.ValidationRate)
 	for _, slotAddr := range escrow.Slots {
 		require.Contains(t, subgroupAddrs, slotAddr)
 	}
diff --git a/inference-chain/x/inference/keeper/msg_server_cross_message_comparison_test.go b/inference-chain/x/inference/keeper/msg_server_cross_message_comparison_test.go
deleted file mode 100644
index 019bd4b067..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_cross_message_comparison_test.go
+++ /dev/null
@@ -1,402 +0,0 @@
-package keeper_test
-
-import (
-	"context"
-	"encoding/base64"
-	"testing"
-
-	"github.com/productscience/inference/x/inference/calculations"
-	"github.com/productscience/inference/x/inference/keeper"
-
-	authztypes "github.com/cosmos/cosmos-sdk/x/authz"
-	"github.com/productscience/inference/testutil"
-	"github.com/productscience/inference/x/inference/types"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-)
-
-// --- Helpers ---
-
-func bogusSig() string {
-	return base64.StdEncoding.EncodeToString(make([]byte, 64))
-}
-
-type crossMsgTestSetup struct {
-	helper           *MockInferenceHelper
-	requestTimestamp int64
-	originalHash     string
-	promptHash       string
-	inferenceID      string
-	taSignature      string
-	executorSig      string
-}
-
-func newCrossMsgSetup(t *testing.T) crossMsgTestSetup {
-	t.Helper()
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-
-	model := types.Model{Id: "model1"}
-	k.SetModel(ctx, &model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, &model)
-
-	requestTimestamp := inferenceHelper.context.BlockTime().UnixNano()
-	originalHash, promptHash, inferenceID, taSig, execSig := buildInferenceSignatures(
-		t,
-		inferenceHelper.MockRequester,
-		inferenceHelper.MockTransferAgent,
-		inferenceHelper.MockExecutor,
-		"promptPayload",
-		requestTimestamp,
-	)
-
-	inferenceHelper.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), inferenceHelper.MockRequester.GetBechAddress()).Return(inferenceHelper.MockRequester).AnyTimes()
-	inferenceHelper.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), inferenceHelper.MockTransferAgent.GetBechAddress()).Return(inferenceHelper.MockTransferAgent).AnyTimes()
-	inferenceHelper.Mocks.AuthzKeeper.EXPECT().GranterGrants(gomock.Any(), gomock.Any()).Return(&authztypes.QueryGranterGrantsResponse{Grants: []*authztypes.GrantAuthorization{}}, nil).AnyTimes()
-	inferenceHelper.Mocks.BankKeeper.ExpectAny(inferenceHelper.context)
-
-	return crossMsgTestSetup{
-		helper:           inferenceHelper,
-		requestTimestamp: requestTimestamp,
-		originalHash:     originalHash,
-		promptHash:       promptHash,
-		inferenceID:      inferenceID,
-		taSignature:      taSig,
-		executorSig:      execSig,
-	}
-}
-
-func buildInferenceSignatures(
-	t *testing.T,
-	requester *MockAccount,
-	transferAgent *MockAccount,
-	executor *MockAccount,
-	promptPayload string,
-	requestTimestamp int64,
-) (string, string, string, string, string) {
-	t.Helper()
-
-	originalPromptHash := sha256Hash(promptPayload)
-	promptHash := sha256Hash(promptPayload)
-
-	devComponents := calculations.SignatureComponents{
-		Payload:         originalPromptHash,
-		Timestamp:       requestTimestamp,
-		TransferAddress: transferAgent.address,
-		ExecutorAddress: "",
-	}
-	inferenceId, err := calculations.Sign(requester, devComponents, calculations.Developer)
-	require.NoError(t, err)
-
-	taComponents := calculations.SignatureComponents{
-		Payload:         promptHash,
-		Timestamp:       requestTimestamp,
-		TransferAddress: transferAgent.address,
-		ExecutorAddress: executor.address,
-	}
-	taSignature, err := calculations.Sign(transferAgent, taComponents, calculations.TransferAgent)
-	require.NoError(t, err)
-	executorSignature, err := calculations.Sign(executor, taComponents, calculations.ExecutorAgent)
-	require.NoError(t, err)
-
-	return originalPromptHash, promptHash, inferenceId, taSignature, executorSignature
-}
-
-func (s *crossMsgTestSetup) validFinishMsg() *types.MsgFinishInference {
-	return &types.MsgFinishInference{
-		Creator:              s.helper.MockExecutor.address,
-		InferenceId:          s.inferenceID,
-		ResponseHash:         "responseHash",
-		PromptTokenCount:     10,
-		CompletionTokenCount: 20,
-		ExecutedBy:           s.helper.MockExecutor.address,
-		TransferredBy:        s.helper.MockTransferAgent.address,
-		RequestTimestamp:     s.requestTimestamp,
-		TransferSignature:    s.taSignature,
-		ExecutorSignature:    s.executorSig,
-		RequestedBy:          s.helper.MockRequester.address,
-		PromptHash:           s.promptHash,
-		OriginalPromptHash:   s.originalHash,
-		Model:                "model1",
-	}
-}
-
-func (s *crossMsgTestSetup) validStartMsg() *types.MsgStartInference {
-	return &types.MsgStartInference{
-		InferenceId:        s.inferenceID,
-		PromptHash:         s.promptHash,
-		RequestedBy:        s.helper.MockRequester.address,
-		Creator:            s.helper.MockTransferAgent.address,
-		Model:              "model1",
-		OriginalPromptHash: s.originalHash,
-		RequestTimestamp:   s.requestTimestamp,
-		TransferSignature:  s.taSignature,
-		AssignedTo:         s.helper.MockExecutor.address,
-		MaxTokens:          20,
-	}
-}
-
-func (s *crossMsgTestSetup) mustFinishFirst(t *testing.T) {
-	t.Helper()
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, s.validFinishMsg())
-	require.NoError(t, err)
-	require.Empty(t, resp.ErrorMessage)
-}
-
-func (s *crossMsgTestSetup) mustStartFirst(t *testing.T) {
-	t.Helper()
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, s.validStartMsg())
-	require.NoError(t, err)
-	require.Empty(t, resp.ErrorMessage)
-}
-
-// ========================
-// Happy path (both orders)
-// ========================
-
-func TestCrossMsg_FinishFirst_ThenStart_Succeeds(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustFinishFirst(t)
-	s.mustStartFirst(t)
-}
-
-func TestCrossMsg_StartFirst_ThenFinish_Succeeds(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, s.validFinishMsg())
-	require.NoError(t, err)
-	require.Empty(t, resp.ErrorMessage)
-}
-
-// ================================
-// Dev signature on first message
-// ================================
-
-func TestCrossMsg_StartFirst_BadDevSignature_Rejected(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	msg := s.validStartMsg()
-	msg.InferenceId = bogusSig() // dev signature is the inferenceId
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrInvalidSignature.Error())
-}
-
-func TestCrossMsg_FinishFirst_BadDevSignature_Rejected(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	msg := s.validFinishMsg()
-	msg.InferenceId = bogusSig()
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrInvalidSignature.Error())
-}
-
-// ========================================
-// TA signature on finish-first (verified)
-// ========================================
-
-func TestCrossMsg_FinishFirst_BadTASignature_Rejected(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	msg := s.validFinishMsg()
-	msg.TransferSignature = bogusSig()
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrInvalidSignature.Error())
-}
-
-// TA signature is NOT checked on start-first
-// When finish comes in we only care about field correctness
-func TestCrossMsg_StartFirst_BadTASignature_Accepted(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	msg := s.validStartMsg()
-	msg.TransferSignature = bogusSig()
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Empty(t, resp.ErrorMessage)
-
-	msgF := s.validFinishMsg()
-	msgF.TransferSignature = bogusSig()
-	respF, err := s.helper.MessageServer.FinishInference(s.helper.context, msgF)
-	require.NoError(t, err)
-	require.Empty(t, respF.ErrorMessage)
-}
-
-// ================================================
-// Executor signature is NEVER checked (both paths)
-// ================================================
-
-func TestCrossMsg_FinishFirst_BadExecutorSignature_Accepted(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	msg := s.validFinishMsg()
-	msg.ExecutorSignature = bogusSig()
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Empty(t, resp.ErrorMessage)
-}
-
-// ============================================================
-// Dev component mismatch on second message (both orderings)
-// ============================================================
-
-func TestCrossMsg_FinishFirst_StartSecond_OriginalPromptHashMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustFinishFirst(t)
-
-	msg := s.validStartMsg()
-	msg.OriginalPromptHash = sha256Hash("different_prompt")
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrDevComponentMismatch.Error())
-}
-
-func TestCrossMsg_FinishFirst_StartSecond_RequestedByMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustFinishFirst(t)
-
-	other := NewMockAccount(testutil.Executor2)
-	MustAddParticipant(t, s.helper.MessageServer, s.helper.context, *other)
-
-	msg := s.validStartMsg()
-	msg.RequestedBy = other.address
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrDevComponentMismatch.Error())
-}
-
-func TestCrossMsg_StartFirst_FinishSecond_OriginalPromptHashMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	msg := s.validFinishMsg()
-	msg.OriginalPromptHash = sha256Hash("different_prompt")
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrDevComponentMismatch.Error())
-}
-
-func TestCrossMsg_StartFirst_FinishSecond_RequestedByMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	other := NewMockAccount(testutil.Executor2)
-	MustAddParticipant(t, s.helper.MessageServer, s.helper.context, *other)
-
-	msg := s.validFinishMsg()
-	msg.RequestedBy = other.address
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrDevComponentMismatch.Error())
-}
-
-func TestCrossMsg_StartFirst_FinishSecond_RequestTimestampMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	msg := s.validFinishMsg()
-	msg.RequestTimestamp = s.requestTimestamp + 999
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrDevComponentMismatch.Error())
-}
-
-// =========================================================
-// TA component mismatch on second message (both orderings)
-// =========================================================
-
-func TestCrossMsg_FinishFirst_StartSecond_PromptHashMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustFinishFirst(t)
-
-	msg := s.validStartMsg()
-	msg.PromptHash = sha256Hash("different_prompt")
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrTAComponentMismatch.Error())
-}
-
-func TestCrossMsg_FinishFirst_StartSecond_ExecutorMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustFinishFirst(t)
-
-	other := NewMockAccount(testutil.Executor2)
-	MustAddParticipant(t, s.helper.MessageServer, s.helper.context, *other)
-
-	msg := s.validStartMsg()
-	msg.AssignedTo = other.address
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrTAComponentMismatch.Error())
-}
-
-func TestCrossMsg_StartFirst_FinishSecond_PromptHashMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	msg := s.validFinishMsg()
-	msg.PromptHash = sha256Hash("different_prompt")
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrTAComponentMismatch.Error())
-}
-
-func TestCrossMsg_StartFirst_FinishSecond_ExecutorMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	other := NewMockAccount(testutil.Executor2)
-	MustAddParticipant(t, s.helper.MessageServer, s.helper.context, *other)
-	AddParticipantToActive(s.helper.context, s.helper.keeper, other.address, 0)
-
-	msg := s.validFinishMsg()
-	msg.ExecutedBy = other.address
-	msg.Creator = other.address // creator must == executed_by
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrTAComponentMismatch.Error())
-}
-
-func AddParticipantToActive(ctx context.Context, k *keeper.Keeper, address string, epochIndex uint64) {
-	current, found := k.GetActiveParticipants(ctx, epochIndex)
-	var currentParticipants []*types.ActiveParticipant
-	if found {
-		currentParticipants = current.Participants
-	} else {
-		currentParticipants = []*types.ActiveParticipant{}
-	}
-	currentParticipants = append(currentParticipants, &types.ActiveParticipant{
-		Index: address,
-	})
-	newParticipants := types.ActiveParticipants{
-		EpochId:      epochIndex,
-		Participants: currentParticipants,
-	}
-	err := k.SetActiveParticipants(ctx, newParticipants)
-	if err != nil {
-		panic(err)
-	}
-}
-
-// =============================================
-// Model mismatch on second message (both ways)
-// =============================================
-
-func TestCrossMsg_FinishFirst_StartSecond_ModelMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustFinishFirst(t)
-
-	msg := s.validStartMsg()
-	msg.Model = "different_model"
-	resp, err := s.helper.MessageServer.StartInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrInferenceRoleMismatch.Error())
-}
-
-func TestCrossMsg_StartFirst_FinishSecond_ModelMismatch(t *testing.T) {
-	s := newCrossMsgSetup(t)
-	s.mustStartFirst(t)
-
-	msg := s.validFinishMsg()
-	msg.Model = "different_model"
-	resp, err := s.helper.MessageServer.FinishInference(s.helper.context, msg)
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrInferenceRoleMismatch.Error())
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_finish_inference.go b/inference-chain/x/inference/keeper/msg_server_finish_inference.go
index b1e2519561..b4d940a0ea 100644
--- a/inference-chain/x/inference/keeper/msg_server_finish_inference.go
+++ b/inference-chain/x/inference/keeper/msg_server_finish_inference.go
@@ -2,171 +2,19 @@ package keeper
 
 import (
 	"context"
-	"strconv"
 
-	sdkerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/productscience/inference/x/inference/calculations"
 	"github.com/productscience/inference/x/inference/types"
 )
 
 func (k msgServer) FinishInference(goCtx context.Context, msg *types.MsgFinishInference) (*types.MsgFinishInferenceResponse, error) {
 	if err := k.CheckPermission(goCtx, msg, ActiveParticipantPermission, PreviousActiveParticipantPermission); err != nil {
-		// do not return failedFinish here. The entire transaction should fail here since permissions will all
-		// have the same result
 		return nil, err
 	}
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
-	// Inject cache once at the entry point
-	ctx, err := k.Keeper.InjectParamsIntoContext(sdk.UnwrapSDKContext(goCtx))
-	if err != nil {
-		k.LogWarn("FinishInference: failed to inject params", types.Inferences, "error", err)
-	}
-
-	k.LogInfo("FinishInference", types.Inferences, "inference_id", msg.InferenceId, "executed_by", msg.ExecutedBy, "created_by", msg.Creator)
-	if msg.Creator != msg.ExecutedBy {
-		err := sdkerrors.Wrapf(types.ErrInferenceRoleMismatch, "creator (%s) must equal executed_by (%s)", msg.Creator, msg.ExecutedBy)
-		k.LogError("FinishInference: creator-role invariant failed", types.Inferences, "error", err)
-		return failedFinish(ctx, err, msg), nil
-	}
-
-	if msg.PromptTokenCount > types.MaxAllowedTokens {
-		return failedFinish(ctx, sdkerrors.Wrapf(types.ErrTokenCountOutOfRange, "prompt_token_count exceeds limit (%d > %d)", msg.PromptTokenCount, types.MaxAllowedTokens), msg), nil
-	}
-	if msg.CompletionTokenCount > types.MaxAllowedTokens {
-		return failedFinish(ctx, sdkerrors.Wrapf(types.ErrTokenCountOutOfRange, "completion_token_count exceeds limit (%d > %d)", msg.CompletionTokenCount, types.MaxAllowedTokens), msg), nil
-	}
-
-	// Developer access gating: until cutoff height only allowlisted developers may run inference flows.
-	// We gate by the original requester (developer), not the executor/TA.
-	if k.IsDeveloperAccessRestricted(ctx, ctx.BlockHeight()) && !k.IsAllowedDeveloper(ctx, msg.RequestedBy) {
-		k.LogError("FinishInference: developer is not allowlisted at this height", types.Inferences, "developer", msg.RequestedBy, "blockHeight", ctx.BlockHeight())
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrDeveloperNotAllowlisted, msg.RequestedBy), msg), nil
-	}
-
-	// Transfer Agent access gating: only allowlisted TAs may be involved in inferences.
-	if k.IsTransferAgentRestricted(ctx) && !k.IsAllowedTransferAgent(ctx, msg.TransferredBy) {
-		k.LogError("FinishInference: transfer agent is not allowlisted", types.Inferences,
-			"transferAgent", msg.TransferredBy, "blockHeight", ctx.BlockHeight())
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrTransferAgentNotAllowlisted, msg.TransferredBy), msg), nil
-	}
-
-	executor, found := k.GetParticipant(ctx, msg.ExecutedBy)
-	if !found {
-		k.LogError("FinishInference: executor not found", types.Inferences, "executed_by", msg.ExecutedBy)
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrParticipantNotFound, msg.ExecutedBy), msg), nil
-	}
-
-	transferAgent, found := k.GetParticipant(ctx, msg.TransferredBy)
-	if !found {
-		k.LogError("FinishInference: transfer agent not found", types.Inferences, "transferred_by", msg.TransferredBy)
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrParticipantNotFound, msg.TransferredBy), msg), nil
-	}
-	devAddress := msg.RequestedBy
-
-	existingInference, found := k.GetInference(ctx, msg.InferenceId)
-
-	if found && existingInference.FinishedProcessed() {
-		k.LogError("FinishInference: inference already finished", types.Inferences, "inferenceId", msg.InferenceId)
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrInferenceFinishProcessed, "inference has already finished processed"), msg), nil
-	}
-
-	if found && existingInference.Status == types.InferenceStatus_EXPIRED {
-		k.LogWarn("FinishInference: cannot finish expired inference", types.Inferences,
-			"inferenceId", msg.InferenceId,
-			"currentStatus", existingInference.Status,
-			"executedBy", msg.ExecutedBy)
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrInferenceExpired, "inference has already expired"), msg), nil
-	}
-
-	// Signature verification policy:
-	// - Start first: finish performs equality checks only (no TA/dev re-verification).
-	// - Finish first: verify dev + TA signatures.
-	// - Executor signature verification is disabled by policy in both paths.
-	if existingInference.StartProcessed() {
-		if err := k.compareDevComponents(msg, &existingInference); err != nil {
-			k.LogError("FinishInference: dev component mismatch", types.Inferences, "error", err, "inferenceId", msg.InferenceId)
-			return failedFinish(ctx, err, msg), nil
-		}
-		if err := k.compareFinishTAComponents(msg, &existingInference); err != nil {
-			k.LogError("FinishInference: TA component mismatch", types.Inferences, "error", err, "inferenceId", msg.InferenceId)
-			return failedFinish(ctx, err, msg), nil
-		}
-		if err := k.compareFinishModelField(msg, &existingInference); err != nil {
-			k.LogError("FinishInference: model field mismatch", types.Inferences, "error", err, "inferenceId", msg.InferenceId)
-			return failedFinish(ctx, err, msg), nil
-		}
-		k.LogDebug("FinishInference: cryptographic signature verification skipped; dev and TA components compared for consistency", types.Inferences, "inferenceId", msg.InferenceId)
-	} else {
-		err := k.verifyFinishKeys(ctx, msg, transferAgent.Address, devAddress)
-		if err != nil {
-			k.LogError("FinishInference: verifyFinishKeys failed", types.Inferences, "error", err)
-			return failedFinish(ctx, sdkerrors.Wrap(types.ErrInvalidSignature, err.Error()), msg), nil
-		}
-		k.LogDebug("FinishInference: dev and TA signatures cryptographically verified", types.Inferences, "inferenceId", msg.InferenceId)
-	}
-	k.LogDebug("FinishInference: executor signature verification disabled by policy", types.Inferences, "inferenceId", msg.InferenceId)
-
-	// Record the current price only if this is the first message (StartInference not processed yet)
-	// This ensures consistent pricing regardless of message arrival order
-	if !existingInference.StartProcessed() {
-		existingInference.Model = msg.Model
-		k.RecordInferencePrice(goCtx, &existingInference, msg.InferenceId)
-	} else if existingInference.Model == "" {
-		k.LogError("FinishInference: model not set by the processed start message", types.Inferences,
-			"inferenceId", msg.InferenceId,
-			"executedBy", msg.ExecutedBy)
-	} else if existingInference.Model != msg.Model {
-		k.LogError("FinishInference: model mismatch", types.Inferences,
-			"inferenceId", msg.InferenceId,
-			"existingInference.Model", existingInference.Model,
-			"msg.Model", msg.Model)
-	}
-
-	blockContext := calculations.BlockContext{
-		BlockHeight:    ctx.BlockHeight(),
-		BlockTimestamp: ctx.BlockTime().UnixMilli(),
-	}
-
-	inference, payments, err := calculations.ProcessFinishInference(&existingInference, msg, blockContext, k)
-	if err != nil {
-		return failedFinish(ctx, err, msg), nil
-	}
-
-	// FinishInference returns nil error to the SDK regardless of internal failures.
-	// This is intentional: returning an error would revert the entire transaction,
-	// but the caller has already paid gas and expects an ErrorMessage response.
-	// CacheContext ensures that if ANY mutation below fails, ALL mutations roll back,
-	// preventing partial state (e.g., escrow moved but inference not updated,
-	// or participant stats incremented but inference not marked completed).
-	cacheCtx, writeFn := ctx.CacheContext()
-
-	finalInference, err := k.processInferencePayments(cacheCtx, inference, payments, true, &executor)
-	if err != nil {
-		k.LogError("FinishInference: payment processing failed", types.Inferences,
-			"inferenceId", msg.InferenceId, "error", err)
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrIllegalState, "payment processing failed"), msg), nil
-	}
-	if finalInference.IsCompleted() {
-		k.handleInferenceCompleted(cacheCtx, finalInference, &executor)
-	}
-	if shouldPersistParticipant(finalInference, payments, &executor) {
-		if err := k.SetParticipant(cacheCtx, executor); err != nil {
-			return failedFinish(ctx, err, msg), nil
-		}
-	}
-	err = k.SetInference(cacheCtx, *finalInference)
-	if err != nil {
-		k.LogError("FinishInference: SetInference failed", types.Inferences,
-			"inferenceId", msg.InferenceId, "error", err)
-		return failedFinish(ctx, sdkerrors.Wrap(types.ErrIllegalState, "failed to persist inference"), msg), nil
-	}
-
-	// All mutations succeeded -- commit to parent store.
-	writeFn()
-
-	return &types.MsgFinishInferenceResponse{InferenceIndex: msg.InferenceId}, nil
+	k.LogInfo("FinishInference deprecated", types.Inferences, "inference_id", msg.InferenceId, "executed_by", msg.ExecutedBy, "created_by", msg.Creator)
+	return failedFinish(ctx, classicInferenceDeprecatedError(), msg), nil
 }
 
 func failedFinish(ctx sdk.Context, err error, msg *types.MsgFinishInference) *types.MsgFinishInferenceResponse {
@@ -178,182 +26,3 @@ func failedFinish(ctx sdk.Context, err error, msg *types.MsgFinishInference) *ty
 		ErrorMessage:   err.Error(),
 	}
 }
-
-func (k msgServer) verifyFinishKeys(ctx sdk.Context, msg *types.MsgFinishInference, taAddress string, devAddress string) error {
-	// Hash-based signature verification (post-upgrade flow)
-	// Dev signs: original_prompt_hash + timestamp + ta_address
-	// TA signs: prompt_hash + timestamp + ta_address + executor_address
-	devComponents := getFinishDevSignatureComponents(msg)
-	taComponents := getFinishTASignatureComponents(msg)
-
-	// Extra seconds for long-running inferences; deduping via inferenceId is primary replay defense
-	if err := k.validateTimestamp(ctx, devComponents, msg.InferenceId, 60*60); err != nil {
-		return err
-	}
-
-	// Verify dev signature (original_prompt_hash)
-	if err := calculations.VerifyKeys(ctx, devComponents, calculations.SignatureData{
-		DevSignature: msg.InferenceId, Dev: devAddress,
-	}, k); err != nil {
-		k.LogError("FinishInference: dev signature failed", types.Inferences, "error", err)
-		return err
-	}
-
-	// Verify TA signature (prompt_hash)
-	if err := k.verifyTASignature(ctx, msg, taComponents, taAddress); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// verifyTASignature verifies TA signature using prompt_hash.
-// Includes upgrade-epoch fallback for inferences started before hash-based signing.
-func (k msgServer) verifyTASignature(ctx sdk.Context, msg *types.MsgFinishInference, taComponents calculations.SignatureComponents, taAddress string) error {
-	err := calculations.VerifyKeys(ctx, taComponents, calculations.SignatureData{
-		TransferSignature: msg.TransferSignature, TransferAgent: taAddress,
-	}, k)
-	if err == nil {
-		return nil
-	}
-
-	// Upgrade-epoch fallback: inferences started before hash-based signing use original_prompt_hash
-	// This path will be removed after upgrade epoch completes
-	directComponents := calculations.SignatureComponents{
-		Payload:         msg.OriginalPromptHash,
-		Timestamp:       msg.RequestTimestamp,
-		TransferAddress: msg.TransferredBy,
-		ExecutorAddress: msg.ExecutedBy,
-	}
-	if fallbackErr := calculations.VerifyKeys(ctx, directComponents, calculations.SignatureData{
-		TransferSignature: msg.TransferSignature, TransferAgent: taAddress,
-	}, k); fallbackErr != nil {
-		k.LogError("FinishInference: TA signature failed", types.Inferences, "promptHashErr", err, "fallbackErr", fallbackErr)
-		return err
-	}
-
-	k.LogDebug("FinishInference: Using upgrade-epoch fallback for TA signature", types.Inferences, "inferenceId", msg.InferenceId)
-	return nil
-}
-
-// getFinishDevSignatureComponents returns components for dev signature verification
-// Dev signs: original_prompt_hash + timestamp + ta_address (no executor)
-func getFinishDevSignatureComponents(msg *types.MsgFinishInference) calculations.SignatureComponents {
-	return calculations.SignatureComponents{
-		Payload:         msg.OriginalPromptHash,
-		Timestamp:       msg.RequestTimestamp,
-		TransferAddress: msg.TransferredBy,
-		ExecutorAddress: "", // Dev doesn't include executor address
-	}
-}
-
-// getFinishTASignatureComponents returns components for TA/Executor signature verification
-// TA/Executor sign: prompt_hash + timestamp + ta_address + executor_address
-func getFinishTASignatureComponents(msg *types.MsgFinishInference) calculations.SignatureComponents {
-	return calculations.SignatureComponents{
-		Payload:         msg.PromptHash,
-		Timestamp:       msg.RequestTimestamp,
-		TransferAddress: msg.TransferredBy,
-		ExecutorAddress: msg.ExecutedBy,
-	}
-}
-
-func (k msgServer) compareFinishTAComponents(msg *types.MsgFinishInference, inference *types.Inference) error {
-	if inference.PromptHash != msg.PromptHash {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"prompt_hash mismatch: finish=%s start=%s",
-			msg.PromptHash,
-			inference.PromptHash,
-		)
-	}
-	if inference.RequestTimestamp != msg.RequestTimestamp {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"request_timestamp mismatch: finish=%d start=%d",
-			msg.RequestTimestamp,
-			inference.RequestTimestamp,
-		)
-	}
-	if inference.TransferredBy != msg.TransferredBy {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"transfer agent mismatch: finish=%s start=%s",
-			msg.TransferredBy,
-			inference.TransferredBy,
-		)
-	}
-	if inference.AssignedTo != msg.ExecutedBy {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"executor mismatch: finish.executed_by=%s start.assigned_to=%s",
-			msg.ExecutedBy,
-			inference.AssignedTo,
-		)
-	}
-	return nil
-}
-
-func (k msgServer) compareFinishModelField(msg *types.MsgFinishInference, inference *types.Inference) error {
-	// inference.Model CANNOT be "" here, Model is a required field for StartInference message
-	if inference.Model != "" && inference.Model != msg.Model {
-		return sdkerrors.Wrapf(
-			types.ErrInferenceRoleMismatch,
-			"model mismatch: finish=%s start=%s",
-			msg.Model,
-			inference.Model,
-		)
-	}
-	return nil
-}
-
-func (k msgServer) handleInferenceCompleted(ctx sdk.Context, inference *types.Inference, executor *types.Participant) {
-	if executor == nil {
-		k.LogWarn("handleInferenceCompleted: executor not loaded, skipping participant updates", types.Inferences, "executed_by", inference.ExecutedBy)
-	} else {
-		ensureParticipantEpochStats(executor)
-		executor.CurrentEpochStats.InferenceCount++
-		executor.LastInferenceTime = inference.EndBlockTimestamp
-	}
-
-	effectiveEpoch, found := k.GetEffectiveEpoch(ctx)
-	if !found {
-		k.LogWarn("handleInferenceCompleted: effective epoch not found, defaulting epoch fields to zero", types.EpochGroup)
-		inference.EpochPocStartBlockHeight = 0
-		inference.EpochId = 0
-	} else {
-		inference.EpochPocStartBlockHeight = uint64(effectiveEpoch.PocStartBlockHeight)
-		inference.EpochId = effectiveEpoch.Index
-	}
-	ctx.EventManager().EmitEvent(sdk.NewEvent(
-		"inference_finished",
-		buildInferenceFinishedEventAttributes(inference)...,
-	))
-
-	if err := k.EnqueueFinishedInference(ctx, inference.InferenceId); err != nil {
-		k.LogError("Unable to enqueue pending inference validation", types.Validation, "inference_id", inference.InferenceId, "block_height", ctx.BlockHeight(), "err", err)
-		return
-	}
-
-	k.LogDebug("Queued inference for deferred validation details processing", types.Validation,
-		"inference_id", inference.InferenceId,
-		"epoch_id", inference.EpochId,
-		"block_height", ctx.BlockHeight(),
-	)
-}
-
-// buildInferenceFinishedEventAttributes emits only fields required for dev-stats off-chain migration.
-func buildInferenceFinishedEventAttributes(inference *types.Inference) []sdk.Attribute {
-	return []sdk.Attribute{
-		sdk.NewAttribute("inference_id", inference.InferenceId),
-		sdk.NewAttribute("requested_by", inference.RequestedBy),
-		sdk.NewAttribute("model", inference.Model),
-		sdk.NewAttribute("status", inference.Status.String()),
-		sdk.NewAttribute("epoch_id", strconv.FormatUint(inference.EpochId, 10)),
-		sdk.NewAttribute("prompt_token_count", strconv.FormatUint(inference.PromptTokenCount, 10)),
-		sdk.NewAttribute("completion_token_count", strconv.FormatUint(inference.CompletionTokenCount, 10)),
-		sdk.NewAttribute("actual_cost_in_coins", strconv.FormatInt(inference.ActualCost, 10)),
-		sdk.NewAttribute("start_block_timestamp", strconv.FormatInt(inference.StartBlockTimestamp, 10)),
-		sdk.NewAttribute("end_block_timestamp", strconv.FormatInt(inference.EndBlockTimestamp, 10)),
-	}
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_finish_inference_atomicity_test.go b/inference-chain/x/inference/keeper/msg_server_finish_inference_atomicity_test.go
deleted file mode 100644
index b0abda881c..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_finish_inference_atomicity_test.go
+++ /dev/null
@@ -1,380 +0,0 @@
-package keeper_test
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"testing"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	authztypes "github.com/cosmos/cosmos-sdk/x/authz"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-
-	"github.com/productscience/inference/testutil"
-	keeper2 "github.com/productscience/inference/testutil/keeper"
-	"github.com/productscience/inference/x/inference/calculations"
-	"github.com/productscience/inference/x/inference/keeper"
-	inference "github.com/productscience/inference/x/inference/module"
-	"github.com/productscience/inference/x/inference/types"
-)
-
-// finishInferenceAtomicityHelper wraps MockInferenceHelper to control
-// bank mock behavior for FinishInference atomicity tests.
-type finishInferenceAtomicityHelper struct {
-	helper *MockInferenceHelper
-	k      keeper.Keeper
-	ctx    sdk.Context
-}
-
-func newFinishInferenceAtomicityHelper(t *testing.T) *finishInferenceAtomicityHelper {
-	h, k, ctx := NewMockInferenceHelper(t)
-	return &finishInferenceAtomicityHelper{helper: h, k: k, ctx: ctx}
-}
-
-// startAndAdvanceEpoch creates an inference via StartInference and advances the epoch
-// so FinishInference sees the inference in a valid state.
-func (f *finishInferenceAtomicityHelper) startAndAdvanceEpoch(t *testing.T) *types.Inference {
-	t.Helper()
-
-	const (
-		epochId  = 1
-		epochId2 = 2
-	)
-
-	requestTimestamp := f.helper.context.BlockTime().UnixNano()
-	initialBlockTime := f.ctx.BlockTime().UnixMilli()
-	initialBlockHeight := int64(10)
-
-	var err error
-	f.ctx, err = advanceEpoch(f.ctx, &f.k, f.helper.Mocks, initialBlockHeight, epochId)
-	require.NoError(t, err)
-	// Sync the helper context and re-register active participants for the new epoch
-	f.helper.context = f.ctx
-	f.helper.EnsureActiveParticipants()
-
-	modelId := "model1"
-	model := types.Model{Id: modelId}
-	f.k.SetModel(f.ctx, &model)
-
-	inf, err := f.helper.StartInference(
-		"promptPayload",
-		modelId,
-		requestTimestamp,
-		calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-
-	newBlockHeight := initialBlockTime + 10
-	f.ctx, err = advanceEpoch(f.ctx, &f.k, f.helper.Mocks, newBlockHeight, epochId2)
-	require.NoError(t, err)
-	f.helper.context = f.ctx
-	f.helper.EnsureActiveParticipants()
-
-	StubModelSubgroup(t, f.ctx, f.k, f.helper.Mocks, &model)
-
-	return inf
-}
-
-// buildFinishMsg constructs a valid FinishInference message with correct signatures.
-func (f *finishInferenceAtomicityHelper) buildFinishMsg(t *testing.T) *types.MsgFinishInference {
-	t.Helper()
-
-	prev := f.helper.previousInference
-	require.NotNil(t, prev, "must call startAndAdvanceEpoch first")
-
-	originalPromptHash := sha256HashForAtomicity(f.helper.promptPayload)
-	promptHash := prev.PromptHash
-
-	// Dev signs original_prompt_hash
-	devComponents := calculations.SignatureComponents{
-		Payload:         originalPromptHash,
-		Timestamp:       prev.RequestTimestamp,
-		TransferAddress: f.helper.MockTransferAgent.address,
-		ExecutorAddress: "",
-	}
-	inferenceId, err := calculations.Sign(f.helper.MockRequester, devComponents, calculations.Developer)
-	require.NoError(t, err)
-
-	// TA and Executor sign prompt_hash
-	taComponents := calculations.SignatureComponents{
-		Payload:         promptHash,
-		Timestamp:       prev.RequestTimestamp,
-		TransferAddress: f.helper.MockTransferAgent.address,
-		ExecutorAddress: f.helper.MockExecutor.address,
-	}
-	taSignature, err := calculations.Sign(f.helper.MockTransferAgent, taComponents, calculations.TransferAgent)
-	require.NoError(t, err)
-	eaSignature, err := calculations.Sign(f.helper.MockExecutor, taComponents, calculations.ExecutorAgent)
-	require.NoError(t, err)
-
-	// Setup account mock expectations for signature verification
-	f.helper.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), f.helper.MockRequester.GetBechAddress()).Return(f.helper.MockRequester).AnyTimes()
-	f.helper.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), f.helper.MockTransferAgent.GetBechAddress()).Return(f.helper.MockTransferAgent).AnyTimes()
-	f.helper.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), f.helper.MockExecutor.GetBechAddress()).Return(f.helper.MockExecutor).AnyTimes()
-
-	return &types.MsgFinishInference{
-		Creator:              f.helper.MockExecutor.address,
-		InferenceId:          inferenceId,
-		ResponseHash:         "responseHash",
-		ResponsePayload:      "responsePayload",
-		PromptTokenCount:     10,
-		CompletionTokenCount: 20,
-		ExecutedBy:           f.helper.MockExecutor.address,
-		TransferredBy:        f.helper.MockTransferAgent.address,
-		RequestTimestamp:      prev.RequestTimestamp,
-		TransferSignature:    taSignature,
-		ExecutorSignature:    eaSignature,
-		RequestedBy:          f.helper.MockRequester.address,
-		OriginalPrompt:       f.helper.promptPayload,
-		Model:                prev.Model,
-		PromptHash:           promptHash,
-		OriginalPromptHash:   originalPromptHash,
-	}
-}
-
-func sha256HashForAtomicity(input string) string {
-	hash := sha256.Sum256([]byte(input))
-	return hex.EncodeToString(hash[:])
-}
-
-// TestFinishInference_PaymentFails_InferenceUnchanged proves that when
-// the refund payment (SendCoinsFromModuleToAccount) fails during FinishInference,
-// CacheContext rolls back all state changes. The inference remains in STARTED state
-// and the executor's participant stats are unchanged.
-func TestFinishInference_PaymentFails_InferenceUnchanged(t *testing.T) {
-	f := newFinishInferenceAtomicityHelper(t)
-	inf := f.startAndAdvanceEpoch(t)
-
-	// Capture pre-FinishInference state
-	savedInference, found := f.k.GetInference(f.ctx, inf.InferenceId)
-	require.True(t, found)
-	originalStatus := savedInference.Status
-
-	executor, found := f.k.GetParticipant(f.ctx, f.helper.MockExecutor.address)
-	require.True(t, found)
-	originalInferenceCount := executor.CurrentEpochStats.InferenceCount
-
-	msg := f.buildFinishMsg(t)
-
-	// Mock: refund payment (SendCoinsFromModuleToAccount) fails.
-	// processInferencePayments calls IssueRefund -> PayParticipantFromEscrow ->
-	// SendCoinsFromModuleToAccount when there's excess escrow to refund.
-	f.helper.Mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(
-		gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
-	).Return(fmt.Errorf("insufficient funds in module account"))
-
-	resp, err := f.helper.MessageServer.FinishInference(f.helper.context, msg)
-
-	// FinishInference returns (response, nil) -- errors go in ErrorMessage
-	require.NoError(t, err, "FinishInference returns nil error by convention")
-	require.NotNil(t, resp)
-	require.NotEmpty(t, resp.ErrorMessage, "response should contain error message")
-
-	// KEY ASSERTION: inference state must be unchanged (CacheContext rolled back)
-	afterInference, found := f.k.GetInference(f.ctx, inf.InferenceId)
-	require.True(t, found, "inference must still exist")
-	require.Equal(t, originalStatus, afterInference.Status,
-		"inference status must be unchanged after payment failure")
-
-	// Executor stats must not have been incremented
-	afterExecutor, found := f.k.GetParticipant(f.ctx, f.helper.MockExecutor.address)
-	require.True(t, found)
-	require.Equal(t, originalInferenceCount, afterExecutor.CurrentEpochStats.InferenceCount,
-		"executor inference count must be unchanged after payment failure")
-}
-
-// TestFinishInference_HappyPath_AllStateCommitted proves that when all mutations
-// succeed, CacheContext commits and the inference is marked completed with
-// correct participant stats.
-func TestFinishInference_HappyPath_AllStateCommitted(t *testing.T) {
-	f := newFinishInferenceAtomicityHelper(t)
-	inf := f.startAndAdvanceEpoch(t)
-
-	msg := f.buildFinishMsg(t)
-
-	// Mock: all bank calls succeed
-	f.helper.Mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(
-		gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
-	).Return(nil)
-
-	resp, err := f.helper.MessageServer.FinishInference(f.helper.context, msg)
-
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.Empty(t, resp.ErrorMessage, "happy path should have no error")
-
-	// Inference should be marked as finished
-	afterInference, found := f.k.GetInference(f.ctx, inf.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_FINISHED, afterInference.Status,
-		"inference should be FINISHED after successful completion")
-}
-
-// -- Alternate approach using InferenceKeeperReturningMocks for simpler setup --
-
-// TestFinishInference_RefundError_Propagated verifies that the fixed IssueRefund
-// error propagation in processInferencePayments actually returns an error
-// (instead of swallowing it) which causes the CacheContext to NOT commit.
-func TestFinishInference_RefundError_Propagated(t *testing.T) {
-	k, ctx, mocks := keeper2.InferenceKeeperReturningMocks(t)
-	ms := keeper.NewMsgServerImpl(k)
-	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
-
-	// Setup: full MockInferenceHelper flow
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
-	mocks.StubForInitGenesis(ctx)
-	inference.InitGenesis(ctx, k, mocks.StubGenesisState())
-
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	params.DynamicPricingParams.GracePeriodEndEpoch = 0
-	k.SetParams(ctx, params)
-
-	requester := NewMockAccount(testutil.Requester)
-	ta := NewMockAccount(testutil.Creator)
-	executor := NewMockAccount(testutil.Executor)
-	MustAddParticipant(t, ms, ctx, *requester)
-	MustAddParticipant(t, ms, ctx, *ta)
-	MustAddParticipant(t, ms, ctx, *executor)
-
-	// Register all participants as active for epoch 0 (genesis) so CheckPermission passes
-	currentEpoch, found := k.GetEffectiveEpochIndex(ctx)
-	require.True(t, found)
-	_ = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: currentEpoch,
-		Participants: []*types.ActiveParticipant{
-			{Index: requester.address},
-			{Index: ta.address},
-			{Index: executor.address},
-		},
-	})
-
-	// Start inference (needs escrow payment to succeed)
-	mocks.BankKeeper.EXPECT().SendCoinsFromAccountToModule(gomock.Any(), gomock.Any(), types.ModuleName, gomock.Any(), gomock.Any()).Return(nil)
-	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), requester.GetBechAddress()).Return(requester).AnyTimes()
-	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), ta.GetBechAddress()).Return(ta).AnyTimes()
-	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), executor.GetBechAddress()).Return(executor).AnyTimes()
-	mocks.AuthzKeeper.EXPECT().GranterGrants(gomock.Any(), gomock.Any()).Return(&authztypes.QueryGranterGrantsResponse{Grants: []*authztypes.GrantAuthorization{}}, nil).AnyTimes()
-
-	requestTimestamp := ctx.BlockTime().UnixNano()
-	promptPayload := "test-prompt"
-	originalPromptHash := sha256HashForAtomicity(promptPayload)
-	promptHash := sha256HashForAtomicity(promptPayload)
-	modelId := "model1"
-
-	// Advance to epoch 1
-	ctx = ctx.WithBlockHeight(10)
-	epoch1 := types.Epoch{Index: 1, PocStartBlockHeight: 10}
-	k.SetEpoch(ctx, &epoch1)
-	_ = k.SetEffectiveEpochIndex(ctx, 1)
-	_ = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId:      1,
-		Participants: []*types.ActiveParticipant{
-			{Index: requester.address}, {Index: ta.address}, {Index: executor.address},
-		},
-	})
-	mocks.ExpectCreateGroupWithPolicyCall(ctx, 1)
-	eg, err := k.CreateEpochGroup(ctx, 10, 1)
-	require.NoError(t, err)
-	require.NoError(t, eg.CreateGroup(ctx))
-
-	model := types.Model{Id: modelId}
-	k.SetModel(ctx, &model)
-
-	// Sign StartInference
-	devComponents := calculations.SignatureComponents{
-		Payload: originalPromptHash, Timestamp: requestTimestamp,
-		TransferAddress: ta.address, ExecutorAddress: "",
-	}
-	inferenceId, err := calculations.Sign(requester, devComponents, calculations.Developer)
-	require.NoError(t, err)
-
-	taComponents := calculations.SignatureComponents{
-		Payload: promptHash, Timestamp: requestTimestamp,
-		TransferAddress: ta.address, ExecutorAddress: executor.address,
-	}
-	taSignature, err := calculations.Sign(ta, taComponents, calculations.TransferAgent)
-	require.NoError(t, err)
-
-	_, err = ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:        inferenceId,
-		PromptHash:         promptHash,
-		PromptPayload:      promptPayload,
-		RequestedBy:        requester.address,
-		Creator:            ta.address,
-		Model:              modelId,
-		OriginalPrompt:     promptPayload,
-		OriginalPromptHash: originalPromptHash,
-		RequestTimestamp:    requestTimestamp,
-		TransferSignature:  taSignature,
-		AssignedTo:         executor.address,
-	})
-	require.NoError(t, err)
-
-	// Verify inference is STARTED
-	savedInf, found := k.GetInference(ctx, inferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_STARTED, savedInf.Status)
-
-	// Advance to epoch 2
-	newBlockHeight := ctx.BlockTime().UnixMilli() + 10
-	ctx = ctx.WithBlockHeight(newBlockHeight)
-	epoch2 := types.Epoch{Index: 2, PocStartBlockHeight: newBlockHeight}
-	k.SetEpoch(ctx, &epoch2)
-	_ = k.SetEffectiveEpochIndex(ctx, 2)
-	_ = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId:      2,
-		Participants: []*types.ActiveParticipant{
-			{Index: requester.address}, {Index: ta.address}, {Index: executor.address},
-		},
-	})
-	mocks.ExpectCreateGroupWithPolicyCall(ctx, 2)
-	eg2, err := k.CreateEpochGroup(ctx, uint64(newBlockHeight), 2)
-	require.NoError(t, err)
-	require.NoError(t, eg2.CreateGroup(ctx))
-
-	// Create model subgroup for epoch 2
-	eg2Current, err := k.GetCurrentEpochGroup(ctx)
-	require.NoError(t, err)
-	mocks.ExpectAnyCreateGroupWithPolicyCall()
-	_, err = eg2Current.CreateSubGroup(ctx, &model)
-	require.NoError(t, err)
-
-	// Sign FinishInference
-	eaSignature, err := calculations.Sign(executor, taComponents, calculations.ExecutorAgent)
-	require.NoError(t, err)
-
-	// Mock: refund SendCoinsFromModuleToAccount FAILS
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(
-		gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
-	).Return(fmt.Errorf("module account has insufficient funds"))
-
-	resp, err := ms.FinishInference(ctx, &types.MsgFinishInference{
-		Creator:              executor.address,
-		InferenceId:          inferenceId,
-		ResponseHash:         "responseHash",
-		ResponsePayload:      "responsePayload",
-		PromptTokenCount:     10,
-		CompletionTokenCount: 20,
-		ExecutedBy:           executor.address,
-		TransferredBy:        ta.address,
-		RequestTimestamp:      requestTimestamp,
-		TransferSignature:    taSignature,
-		ExecutorSignature:    eaSignature,
-		RequestedBy:          requester.address,
-		OriginalPrompt:       promptPayload,
-		Model:                modelId,
-		PromptHash:           promptHash,
-		OriginalPromptHash:   originalPromptHash,
-	})
-
-	require.NoError(t, err, "handler returns nil error by convention")
-	require.NotNil(t, resp)
-	require.NotEmpty(t, resp.ErrorMessage, "should have error message for failed refund")
-
-	// KEY ASSERTION: inference must still be STARTED (CacheContext rollback)
-	afterInf, found := k.GetInference(sdk.UnwrapSDKContext(ctx), inferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_STARTED, afterInf.Status,
-		"inference status must remain STARTED when refund fails -- CacheContext should roll back all mutations")
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_finish_inference_test.go b/inference-chain/x/inference/keeper/msg_server_finish_inference_test.go
deleted file mode 100644
index ddf37bc331..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_finish_inference_test.go
+++ /dev/null
@@ -1,584 +0,0 @@
-package keeper_test
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
-	"testing"
-
-	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
-	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	authztypes "github.com/cosmos/cosmos-sdk/x/authz"
-	"github.com/productscience/inference/testutil"
-	keeper2 "github.com/productscience/inference/testutil/keeper"
-	"github.com/productscience/inference/x/inference/calculations"
-	"github.com/productscience/inference/x/inference/keeper"
-	inference "github.com/productscience/inference/x/inference/module"
-	"go.uber.org/mock/gomock"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/productscience/inference/x/inference/types"
-)
-
-// sha256Hash computes SHA256 hash and returns hex string
-func sha256Hash(input string) string {
-	hash := sha256.Sum256([]byte(input))
-	return hex.EncodeToString(hash[:])
-}
-
-func advanceEpoch(ctx sdk.Context, k *keeper.Keeper, mocks *keeper2.InferenceMocks, blockHeight int64, epochGroupId uint64) (sdk.Context, error) {
-	ctx = ctx.WithBlockHeight(blockHeight)
-	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(10 * 60 * 1000 * 1000)) // 10 minutes later
-
-	epochIndex, found := k.GetEffectiveEpochIndex(ctx)
-	if !found {
-		return ctx, types.ErrEffectiveEpochNotFound
-	}
-	// The genesis groups have already been created
-	newEpoch := types.Epoch{Index: epochIndex + 1, PocStartBlockHeight: blockHeight}
-	k.SetEpoch(ctx, &newEpoch)
-	_ = k.SetEffectiveEpochIndex(ctx, newEpoch.Index)
-	mocks.ExpectCreateGroupWithPolicyCall(ctx, epochGroupId)
-
-	eg, err := k.CreateEpochGroup(ctx, uint64(newEpoch.PocStartBlockHeight), epochIndex+1)
-	if err != nil {
-		return ctx, err
-	}
-	err = eg.CreateGroup(ctx)
-	if err != nil {
-		return ctx, err
-	}
-	return ctx, nil
-}
-
-func StubModelSubgroup(t *testing.T, ctx context.Context, k keeper.Keeper, mocks *keeper2.InferenceMocks, model *types.Model) {
-	eg, err := k.GetCurrentEpochGroup(ctx)
-	require.NoError(t, err)
-	mocks.ExpectAnyCreateGroupWithPolicyCall()
-	_, err = eg.CreateSubGroup(ctx, model)
-
-	require.NoError(t, err)
-}
-
-func TestMsgServer_FinishInference_DeveloperAccessRestricted(t *testing.T) {
-	const (
-		epochId = 1
-	)
-
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-
-	// Developer access gating should apply to FinishInference as well (gated by RequestedBy).
-	originalParams, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		_ = k.SetParams(ctx, originalParams)
-	})
-
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	params.DeveloperAccessParams = &types.DeveloperAccessParams{
-		UntilBlockHeight:          9999999,
-		AllowedDeveloperAddresses: []string{"gonka1someotherxxxxxxxxxxxxxxxxxxxxxx"},
-	}
-	_ = k.SetParams(ctx, params)
-	participant := types.Participant{
-		Address: testutil.Creator,
-		Index:   testutil.Creator,
-		Status:  types.ParticipantStatus_ACTIVE,
-	}
-	_ = k.SetParticipant(ctx, participant)
-	_ = k.SetEffectiveEpochIndex(ctx, epochId)
-	_ = k.SetActiveParticipants(ctx, ParticipantsToActive(epochId, participant))
-
-	resp, err := inferenceHelper.MessageServer.FinishInference(ctx, &types.MsgFinishInference{
-		Creator:     testutil.Creator,
-		ExecutedBy:  testutil.Creator,
-		InferenceId: "dummy",
-		RequestedBy: testutil.Requester,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.Contains(t, resp.ErrorMessage, types.ErrDeveloperNotAllowlisted.Error())
-}
-
-func TestMsgServer_FinishInference(t *testing.T) {
-	const (
-		epochId  = 1
-		epochId2 = 2
-	)
-
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-
-	requestTimestamp := inferenceHelper.context.BlockTime().UnixNano()
-	initialBlockTime := ctx.BlockTime().UnixMilli()
-	initialBlockHeight := int64(10)
-	// This should advance us to epoch 1 (the first after genesis)
-	ctx, err := advanceEpoch(ctx, &k, inferenceHelper.Mocks, initialBlockHeight, epochId)
-	if err != nil {
-		t.Fatalf("Failed to advance epoch: %v", err)
-	}
-	require.Equal(t, initialBlockHeight, ctx.BlockHeight())
-
-	modelId := "model1"
-	model := types.Model{Id: modelId}
-	k.SetModel(ctx, &model)
-
-	expected, err := inferenceHelper.StartInference(
-		"promptPayload",
-		modelId,
-		requestTimestamp,
-		calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	savedInference, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, expected, &savedInference)
-
-	_, found = k.GetDevelopersStatsByEpoch(ctx, testutil.Requester, epochId)
-	require.False(t, found)
-
-	newBlockHeight := initialBlockTime + 10
-	// This should advance us to epoch 2
-	ctx, err = advanceEpoch(ctx, &k, inferenceHelper.Mocks, newBlockHeight, epochId2)
-	if err != nil {
-		t.Fatalf("Failed to advance epoch: %v", err)
-	}
-	require.Equal(t, newBlockHeight, ctx.BlockHeight())
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, &model)
-
-	expectedFinished, err := inferenceHelper.FinishInference()
-	require.NoError(t, err)
-
-	savedInference, found = k.GetInference(ctx, expected.InferenceId)
-	expectedFinished.EpochId = epochId2 // Update the EpochId to the new one
-	expectedFinished.EpochPocStartBlockHeight = 0
-	savedInference.EpochPocStartBlockHeight = 0
-	require.True(t, found)
-	require.Equal(t, expectedFinished, &savedInference)
-
-	_, found = k.GetDevelopersStatsByEpoch(ctx, testutil.Requester, epochId2)
-	require.False(t, found)
-
-	// Task III: validation-details creation is deferred to EndBlock.
-	queuedInferenceIDs, err := k.ListFinishedInferenceIDs(ctx)
-	require.NoError(t, err)
-	require.Contains(t, queuedInferenceIDs, expected.InferenceId)
-
-	_, found = k.GetInferenceValidationDetails(ctx, epochId2, expected.InferenceId)
-	require.False(t, found)
-
-}
-
-func TestMsgServer_FinishInference_UpdatesExecutorOnceOnCompletion(t *testing.T) {
-	inferenceHelper, k, _ := NewMockInferenceHelper(t)
-	requestTimestamp := inferenceHelper.context.BlockTime().UnixNano()
-
-	_, err := inferenceHelper.StartInference("promptPayload", "model1", requestTimestamp, calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-
-	beforeExecutor, found := k.GetParticipant(inferenceHelper.context, testutil.Executor)
-	require.True(t, found)
-	if beforeExecutor.CurrentEpochStats == nil {
-		beforeExecutor.CurrentEpochStats = &types.CurrentEpochStats{}
-	}
-	beforeEarned := beforeExecutor.CurrentEpochStats.EarnedCoins
-	beforeInferenceCount := beforeExecutor.CurrentEpochStats.InferenceCount
-
-	expectedFinished, err := inferenceHelper.FinishInference()
-	require.NoError(t, err)
-
-	afterExecutor, found := k.GetParticipant(inferenceHelper.context, testutil.Executor)
-	require.True(t, found)
-	require.NotNil(t, afterExecutor.CurrentEpochStats)
-	require.Equal(t, beforeEarned+uint64(expectedFinished.ActualCost), afterExecutor.CurrentEpochStats.EarnedCoins)
-	require.Equal(t, beforeInferenceCount+1, afterExecutor.CurrentEpochStats.InferenceCount)
-	require.Equal(t, expectedFinished.EndBlockTimestamp, afterExecutor.LastInferenceTime)
-}
-
-func TestMsgServer_FinishInference_ParamsCacheDoesNotLeakAcrossCalls(t *testing.T) {
-	k, ms, ctx := setupMsgServer(t)
-
-	err := k.SetEffectiveEpochIndex(ctx, 1) // Set to non-zero epoch to avoid epoch not found error
-	require.NoError(t, err)
-	err = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: 1,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: testutil.Creator,
-			},
-		},
-	})
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	params.DeveloperAccessParams = &types.DeveloperAccessParams{
-		UntilBlockHeight:          ctx.BlockHeight() + 100,
-		AllowedDeveloperAddresses: []string{testutil.Requester},
-	}
-	require.NoError(t, k.SetParams(ctx, params))
-
-	AddParticipantToActive(ctx, &k, testutil.Executor, 1)
-	firstResp, err := ms.FinishInference(ctx, &types.MsgFinishInference{
-		InferenceId: "cache-test-finish-1",
-		RequestedBy: testutil.Requester,
-		ExecutedBy:  testutil.Executor,
-		Creator:     testutil.Executor,
-	})
-	require.NoError(t, err)
-	require.NotContains(t, firstResp.ErrorMessage, types.ErrDeveloperNotAllowlisted.Error())
-	require.Contains(t, firstResp.ErrorMessage, types.ErrParticipantNotFound.Error())
-
-	params.DeveloperAccessParams = &types.DeveloperAccessParams{
-		UntilBlockHeight:          ctx.BlockHeight() + 100,
-		AllowedDeveloperAddresses: []string{"gonka1notallowlistedxxxxxxxxxxxxxxxxxxxxxx"},
-	}
-	require.NoError(t, k.SetParams(ctx, params))
-
-	secondResp, err := ms.FinishInference(ctx, &types.MsgFinishInference{
-		InferenceId: "cache-test-finish-2",
-		RequestedBy: testutil.Requester,
-		ExecutedBy:  testutil.Executor,
-		Creator:     testutil.Executor,
-	})
-	require.NoError(t, err)
-	require.Contains(t, secondResp.ErrorMessage, types.ErrDeveloperNotAllowlisted.Error())
-}
-
-func MustAddParticipant(t *testing.T, ms types.MsgServer, ctx context.Context, mockAccount MockAccount) {
-	_, err := ms.SubmitNewParticipant(ctx, &types.MsgSubmitNewParticipant{
-		Creator:      mockAccount.address,
-		Url:          "url",
-		ValidatorKey: mockAccount.GetPubKey().String(),
-	})
-	require.NoError(t, err)
-}
-
-func TestMsgServer_FinishInference_InferenceNotFound(t *testing.T) {
-	k, ms, ctx := setupMsgServer(t)
-	k.SetEffectiveEpochIndex(ctx, 1) // Set to non-zero epoch to avoid epoch not found error
-	k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: 1,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: testutil.Executor,
-			},
-		},
-	})
-	response, err := ms.FinishInference(ctx, &types.MsgFinishInference{
-		Creator:              testutil.Executor,
-		InferenceId:          "inferenceId",
-		ResponseHash:         "responseHash",
-		ResponsePayload:      "responsePayload",
-		PromptTokenCount:     1,
-		CompletionTokenCount: 1,
-		ExecutedBy:           testutil.Executor,
-	})
-	require.NoError(t, err)
-	require.NotEmpty(t, response.ErrorMessage)
-	_, found := k.GetInference(ctx, "inferenceId")
-	require.False(t, found)
-}
-
-func TestMsgServer_FinishInferenceCreatorMustMatchExecutor(t *testing.T) {
-	k, ms, ctx := setupMsgServer(t)
-	_ = k.SetEffectiveEpochIndex(ctx, 1)
-	AddParticipantToActive(ctx, &k, testutil.Creator, 1)
-	resp, err := ms.FinishInference(ctx, &types.MsgFinishInference{
-		Creator:    testutil.Creator,
-		ExecutedBy: testutil.Executor,
-	})
-	require.NoError(t, err)
-	require.Contains(t, resp.ErrorMessage, types.ErrInferenceRoleMismatch.Error())
-}
-
-type MockAccount struct {
-	address string
-	key     *secp256k1.PrivKey
-}
-
-func NewMockAccount(address string) *MockAccount {
-	return &MockAccount{address: address, key: secp256k1.GenPrivKey()}
-}
-func (m *MockAccount) GetBechAddress() sdk.AccAddress          { return sdk.MustAccAddressFromBech32(m.address) }
-func (m *MockAccount) GetAddress() sdk.AccAddress              { return sdk.AccAddress(m.address) }
-func (m *MockAccount) SetAddress(address sdk.AccAddress) error { return nil }
-func (m *MockAccount) GetPubKey() cryptotypes.PubKey           { return m.key.PubKey() }
-func (m *MockAccount) SetPubKey(key cryptotypes.PubKey) error  { return nil }
-func (m *MockAccount) GetAccountNumber() uint64                { return 0 }
-func (m *MockAccount) SetAccountNumber(accNumber uint64) error { return nil }
-func (m *MockAccount) GetSequence() uint64                     { return 0 }
-func (m *MockAccount) SetSequence(sequence uint64) error       { return nil }
-func (m *MockAccount) String() string                          { return "" }
-func (m *MockAccount) Reset()                                  {}
-func (m *MockAccount) ProtoMessage()                           {}
-func (m *MockAccount) SignBytes(msg []byte) (string, error) {
-	signature, err := m.key.Sign(msg)
-	if err != nil {
-		return "", err
-	}
-	return base64.StdEncoding.EncodeToString(signature), nil
-}
-
-type MockInferenceHelper struct {
-	MockRequester     *MockAccount
-	MockTransferAgent *MockAccount
-	MockExecutor      *MockAccount
-	testingT          *testing.T
-	Mocks             *keeper2.InferenceMocks
-	MessageServer     types.MsgServer
-	keeper            *keeper.Keeper
-	context           sdk.Context
-	previousInference *types.Inference
-	promptPayload     string // Phase 6: Store prompt for hash computation (not stored on-chain)
-}
-
-func NewMockInferenceHelper(t *testing.T) (*MockInferenceHelper, keeper.Keeper, sdk.Context) {
-	k, ms, ctx, mocks := setupKeeperWithMocks(t)
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
-	mocks.StubForInitGenesis(ctx)
-	inference.InitGenesis(ctx, k, mocks.StubGenesisState())
-
-	// Disable grace period for tests so we get actual pricing instead of 0
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	params.DynamicPricingParams.GracePeriodEndEpoch = 0
-	k.SetParams(ctx, params)
-
-	requesterAccount := NewMockAccount(testutil.Requester)
-	taAccount := NewMockAccount(testutil.Creator)
-	executorAccount := NewMockAccount(testutil.Executor)
-	MustAddParticipant(t, ms, ctx, *requesterAccount)
-	MustAddParticipant(t, ms, ctx, *taAccount)
-	MustAddParticipant(t, ms, ctx, *executorAccount)
-
-	currentEpoch, found := k.GetEffectiveEpochIndex(ctx)
-	require.True(t, found)
-	err = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: currentEpoch,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: requesterAccount.address,
-			},
-			{
-				Index: taAccount.address,
-			},
-			{
-				Index: executorAccount.address,
-			},
-		},
-	})
-	require.NoError(t, err)
-
-	return &MockInferenceHelper{
-		MockRequester:     requesterAccount,
-		MockTransferAgent: taAccount,
-		MockExecutor:      executorAccount,
-		testingT:          t,
-		Mocks:             mocks,
-		MessageServer:     ms,
-		keeper:            &k,
-		context:           ctx,
-	}, k, ctx
-}
-
-func (h *MockInferenceHelper) EnsureActiveParticipants() {
-	currentEpoch, found := h.keeper.GetEffectiveEpochIndex(h.context)
-	require.True(h.testingT, found)
-	err := h.keeper.SetActiveParticipants(h.context, types.ActiveParticipants{
-		EpochId: currentEpoch,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: h.MockRequester.address,
-			},
-			{
-				Index: h.MockTransferAgent.address,
-			},
-			{
-				Index: h.MockExecutor.address,
-			},
-			{
-				Index: testutil.Validator,
-			},
-		},
-	})
-	require.NoError(h.testingT, err)
-}
-func (h *MockInferenceHelper) StartInference(
-	promptPayload string, model string, requestTimestamp int64, maxTokens uint64) (*types.Inference, error) {
-	h.Mocks.BankKeeper.EXPECT().SendCoinsFromAccountToModule(gomock.Any(), gomock.Any(), types.ModuleName, gomock.Any(), gomock.Any()).Return(nil)
-	h.Mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), h.MockRequester.GetBechAddress()).Return(true).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), h.MockRequester.GetBechAddress()).Return(h.MockRequester)
-	h.Mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), h.MockTransferAgent.GetBechAddress()).Return(true).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), h.MockTransferAgent.GetBechAddress()).Return(h.MockTransferAgent).AnyTimes()
-	h.Mocks.AuthzKeeper.EXPECT().GranterGrants(gomock.Any(), gomock.Any()).Return(&authztypes.QueryGranterGrantsResponse{Grants: []*authztypes.GrantAuthorization{}}, nil).AnyTimes()
-	h.EnsureActiveParticipants()
-
-	// Phase 3: Compute hashes for signatures
-	originalPromptHash := sha256Hash(promptPayload)
-	promptHash := sha256Hash(promptPayload) // In real flow, this would be sha256(modified request with seed)
-
-	// Phase 3: Dev signs original_prompt_hash (no executor address)
-	devComponents := calculations.SignatureComponents{
-		Payload:         originalPromptHash,
-		Timestamp:       requestTimestamp,
-		TransferAddress: h.MockTransferAgent.address,
-		ExecutorAddress: "", // Dev doesn't include executor
-	}
-	inferenceId, err := calculations.Sign(h.MockRequester, devComponents, calculations.Developer)
-	if err != nil {
-		return nil, err
-	}
-
-	// Phase 3: TA signs prompt_hash (with executor address)
-	taComponents := calculations.SignatureComponents{
-		Payload:         promptHash,
-		Timestamp:       requestTimestamp,
-		TransferAddress: h.MockTransferAgent.address,
-		ExecutorAddress: h.MockExecutor.address,
-	}
-	taSignature, err := calculations.Sign(h.MockTransferAgent, taComponents, calculations.TransferAgent)
-	if err != nil {
-		return nil, err
-	}
-	startInferenceMsg := &types.MsgStartInference{
-		InferenceId:        inferenceId,
-		PromptHash:         promptHash,
-		PromptPayload:      promptPayload,
-		RequestedBy:        h.MockRequester.address,
-		Creator:            h.MockTransferAgent.address,
-		Model:              model,
-		OriginalPrompt:     promptPayload,
-		OriginalPromptHash: originalPromptHash,
-		RequestTimestamp:   requestTimestamp,
-		TransferSignature:  taSignature,
-		AssignedTo:         h.MockExecutor.address,
-	}
-	if maxTokens != calculations.DefaultMaxTokens {
-		startInferenceMsg.MaxTokens = maxTokens
-	}
-	_, err = h.MessageServer.StartInference(h.context, startInferenceMsg)
-	h.promptPayload = promptPayload // Phase 6: Store for hash computation in FinishInference
-	h.previousInference = &types.Inference{
-		Index:               inferenceId,
-		InferenceId:         inferenceId,
-		PromptHash:          promptHash,
-		OriginalPromptHash:  originalPromptHash,
-		PromptPayload:       "", // Phase 6: Stored offchain
-		RequestedBy:         h.MockRequester.address,
-		Status:              types.InferenceStatus_STARTED,
-		Model:               model,
-		StartBlockHeight:    h.context.BlockHeight(),
-		StartBlockTimestamp: h.context.BlockTime().UnixMilli(),
-		MaxTokens:           maxTokens,
-		EscrowAmount:        int64(maxTokens * calculations.PerTokenCost),
-		AssignedTo:          h.MockExecutor.address,
-		TransferredBy:       h.MockTransferAgent.address,
-		TransferSignature:   taSignature,
-		RequestTimestamp:    requestTimestamp,
-		OriginalPrompt:      "",                        // Phase 6: Stored offchain
-		PerTokenPrice:       calculations.PerTokenCost, // Set expected dynamic pricing value
-	}
-	return h.previousInference, err
-}
-
-func (h *MockInferenceHelper) FinishInference() (*types.Inference, error) {
-	if h.previousInference == nil {
-		return nil, types.ErrInferenceNotFound
-	}
-	h.Mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
-
-	h.Mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), h.MockRequester.GetBechAddress()).Return(true).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), h.MockRequester.GetBechAddress()).Return(h.MockRequester).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), h.MockTransferAgent.GetBechAddress()).Return(true).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), h.MockTransferAgent.GetBechAddress()).Return(h.MockTransferAgent).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), h.MockExecutor.GetBechAddress()).Return(true).AnyTimes()
-	h.Mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), h.MockExecutor.GetBechAddress()).Return(h.MockExecutor).AnyTimes()
-	h.EnsureActiveParticipants()
-
-	// Phase 3: Compute hashes for signatures
-	// Phase 6: Use stored promptPayload (not from inference struct, which is now empty)
-	originalPromptHash := sha256Hash(h.promptPayload)
-	promptHash := h.previousInference.PromptHash // Already computed in StartInference
-
-	// Phase 3: Dev signs original_prompt_hash (no executor address)
-	devComponents := calculations.SignatureComponents{
-		Payload:         originalPromptHash,
-		Timestamp:       h.previousInference.RequestTimestamp,
-		TransferAddress: h.MockTransferAgent.address,
-		ExecutorAddress: "", // Dev doesn't include executor
-	}
-	inferenceId, err := calculations.Sign(h.MockRequester, devComponents, calculations.Developer)
-	if err != nil {
-		return nil, err
-	}
-
-	// Phase 3: TA and Executor sign prompt_hash (with executor address)
-	taComponents := calculations.SignatureComponents{
-		Payload:         promptHash,
-		Timestamp:       h.previousInference.RequestTimestamp,
-		TransferAddress: h.MockTransferAgent.address,
-		ExecutorAddress: h.MockExecutor.address,
-	}
-	taSignature, err := calculations.Sign(h.MockTransferAgent, taComponents, calculations.TransferAgent)
-	if err != nil {
-		return nil, err
-	}
-	eaSignature, err := calculations.Sign(h.MockExecutor, taComponents, calculations.ExecutorAgent)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = h.MessageServer.FinishInference(h.context, &types.MsgFinishInference{
-		Creator:              h.MockExecutor.address,
-		InferenceId:          inferenceId,
-		ResponseHash:         "responseHash",
-		ResponsePayload:      "responsePayload",
-		PromptTokenCount:     10,
-		CompletionTokenCount: 20,
-		ExecutedBy:           h.MockExecutor.address,
-		TransferredBy:        h.MockTransferAgent.address,
-		RequestTimestamp:     h.previousInference.RequestTimestamp,
-		TransferSignature:    taSignature,
-		ExecutorSignature:    eaSignature,
-		RequestedBy:          h.MockRequester.address,
-		OriginalPrompt:       h.promptPayload, // Phase 6: Use stored prompt (not from inference struct)
-		Model:                h.previousInference.Model,
-		PromptHash:           promptHash,
-		OriginalPromptHash:   originalPromptHash,
-	})
-	if err != nil {
-		return nil, err
-	}
-	return &types.Inference{
-		Index:                    inferenceId,
-		InferenceId:              inferenceId,
-		PromptHash:               h.previousInference.PromptHash,
-		OriginalPromptHash:       originalPromptHash,
-		PromptPayload:            "", // Phase 6: Stored offchain
-		RequestedBy:              h.MockRequester.address,
-		Status:                   types.InferenceStatus_FINISHED,
-		ResponseHash:             "responseHash",
-		ResponsePayload:          "", // Phase 6: Stored offchain
-		PromptTokenCount:         10,
-		CompletionTokenCount:     20,
-		EpochPocStartBlockHeight: h.previousInference.EpochPocStartBlockHeight,
-		EpochId:                  h.previousInference.EpochId + 1,
-		ExecutedBy:               h.MockExecutor.address,
-		Model:                    h.previousInference.Model,
-		StartBlockTimestamp:      h.previousInference.StartBlockTimestamp,
-		StartBlockHeight:         h.previousInference.StartBlockHeight,
-		EndBlockTimestamp:        h.context.BlockTime().UnixMilli(),
-		EndBlockHeight:           h.context.BlockHeight(),
-		MaxTokens:                h.previousInference.MaxTokens,
-		EscrowAmount:             int64(h.previousInference.MaxTokens * calculations.PerTokenCost),
-		ActualCost:               30 * calculations.PerTokenCost,
-		AssignedTo:               h.previousInference.AssignedTo,
-		TransferredBy:            h.previousInference.TransferredBy,
-		TransferSignature:        h.previousInference.TransferSignature,
-		RequestTimestamp:         h.previousInference.RequestTimestamp,
-		OriginalPrompt:           "", // Phase 6: Stored offchain
-		ExecutionSignature:       eaSignature,
-		PerTokenPrice:            calculations.PerTokenCost, // Set expected dynamic pricing value
-	}, nil
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_invalidate_inference.go b/inference-chain/x/inference/keeper/msg_server_invalidate_inference.go
index 83918f1f0e..458933e730 100644
--- a/inference-chain/x/inference/keeper/msg_server_invalidate_inference.go
+++ b/inference-chain/x/inference/keeper/msg_server_invalidate_inference.go
@@ -3,114 +3,14 @@ package keeper
 import (
 	"context"
 
-	"cosmossdk.io/collections"
-	errorsmod "cosmossdk.io/errors"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/productscience/inference/x/inference/types"
 )
 
 func (k msgServer) InvalidateInference(ctx context.Context, msg *types.MsgInvalidateInference) (*types.MsgInvalidateInferenceResponse, error) {
-	// Invalidate uses the Inference and the group policy id to get permissions,
-	// so it and revalidate don't go through the usual permissions path
 	if err := k.CheckPermission(ctx, msg, NoPermission); err != nil {
 		return nil, err
 	}
-	inference, executor, err := k.validateDecisionMessage(ctx, msg)
-	if err != nil {
-		return nil, err
-	}
-	// Idempotent, so no error
-	if inference.Status == types.InferenceStatus_INVALIDATED {
-		k.LogDebug("Inference already invalidated", types.Validation, "inferenceId", msg.InferenceId)
-		return nil, nil
-	}
-	previousStatus := inference.Status
-	inference.Status = types.InferenceStatus_INVALIDATED
-	executor.CurrentEpochStats.InvalidatedInferences++
-	executor.ConsecutiveInvalidInferences++
-	currentEpochIndex, found := k.GetEffectiveEpochIndex(ctx)
-	if !found {
-		k.LogError("Failed to get effective epoch index", types.Validation)
-		return nil, types.ErrEffectiveEpochNotFound
-	}
-
-	shouldRefund, reason := k.inferenceIsBeforeClaimsSet(ctx, *inference, currentEpochIndex)
-	k.LogInfo("Inference refund decision", types.Validation, "inferenceId", inference.InferenceId, "executor", executor.Address, "shouldRefund", shouldRefund, "reason", reason)
-	if shouldRefund {
-		err := k.refundInvalidatedInference(executor, inference, ctx)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	k.LogInfo("Inference invalidated", types.Inferences, "inferenceId", inference.InferenceId, "executor", executor.Address, "actualCost", inference.ActualCost)
-
-	err = k.SetParticipant(ctx, *executor)
-	if err != nil {
-		return nil, err
-	}
-
-	err = k.SetInference(ctx, *inference)
-	if err != nil {
-		return nil, err
-	}
-	if inference.Status != previousStatus {
-		emitInferenceStatusUpdatedEvent(sdk.UnwrapSDKContext(ctx), inference.InferenceId, inference.Status)
-	}
-
-	return &types.MsgInvalidateInferenceResponse{}, nil
-}
 
-func (k msgServer) refundInvalidatedInference(executor *types.Participant, inference *types.Inference, ctx context.Context) error {
-	// Attempt refund BEFORE modifying executor balance.
-	// If refund fails (e.g. underfunded escrow), don't corrupt state.
-	err := k.IssueRefund(ctx, inference.ActualCost, inference.RequestedBy, "invalidated_inference:"+inference.InferenceId)
-	if err != nil {
-		k.LogError("Refund failed", types.Validation, "error", err)
-		return err
-	}
-
-	// Only deduct from executor after successful refund
-	executor.CoinBalance -= inference.ActualCost
-	k.SafeLogSubAccountTransaction(ctx, types.ModuleName, executor.Address, types.OwedSubAccount, inference.ActualCost, "invalidated_inference:"+inference.InferenceId)
-	k.LogInfo("Invalid Inference subtracted from Executor CoinBalance ", types.Balances, "inferenceId", inference.InferenceId, "executor", executor.Address, "actualCost", inference.ActualCost, "coinBalance", executor.CoinBalance)
-
-	return nil
-}
-
-type ValidationDecision interface {
-	GetInferenceId() string
-	GetCreator() string
-	GetInvalidator() string
-}
-
-func (k msgServer) validateDecisionMessage(ctx context.Context, msg ValidationDecision) (*types.Inference, *types.Participant, error) {
-	inference, found := k.GetInference(ctx, msg.GetInferenceId())
-	if !found {
-		k.LogError("Inference not found", types.Validation, "inferenceId", msg.GetInferenceId())
-		return nil, nil, errorsmod.Wrapf(types.ErrInferenceNotFound, "inference with id %s not found", msg.GetInferenceId())
-	}
-
-	if msg.GetCreator() != inference.ProposalDetails.PolicyAddress {
-		k.LogError("Invalid authority", types.Validation, "expected", inference.ProposalDetails.PolicyAddress, "got", msg.GetCreator())
-		return nil, nil, errorsmod.Wrapf(types.ErrInvalidSigner, "invalid authority; expected %s, got %s", inference.ProposalDetails.PolicyAddress, msg.GetCreator())
-	}
-
-	addr, err := sdk.AccAddressFromBech32(msg.GetInvalidator())
-	if err != nil {
-		k.LogError("Invalidator address is invalid", types.Validation, "invalidator", msg.GetInvalidator())
-	} else {
-		err = k.ActiveInvalidations.Remove(ctx, collections.Join(addr, inference.InferenceId))
-		if err != nil {
-			k.LogError("Failed to remove active invalidation", types.Validation, "error", err)
-		}
-
-	}
-
-	executor, found := k.GetParticipant(ctx, inference.ExecutedBy)
-	if !found {
-		k.LogError("Executor not found", types.Validation, "address", inference.ExecutedBy)
-		return nil, nil, errorsmod.Wrapf(types.ErrParticipantNotFound, "participant with address %s not found", inference.ExecutedBy)
-	}
-	return &inference, &executor, nil
+	k.LogInfo("MsgInvalidateInference deprecated", types.Validation, "inferenceId", msg.InferenceId, "creator", msg.Creator)
+	return nil, classicInferenceDeprecatedError()
 }
diff --git a/inference-chain/x/inference/keeper/msg_server_invalidate_inference_test.go b/inference-chain/x/inference/keeper/msg_server_invalidate_inference_test.go
deleted file mode 100644
index 1face85e0d..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_invalidate_inference_test.go
+++ /dev/null
@@ -1,373 +0,0 @@
-package keeper_test
-
-import (
-	"testing"
-
-	"cosmossdk.io/collections"
-	"cosmossdk.io/math"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-
-	keepertest "github.com/productscience/inference/testutil/keeper"
-	"github.com/productscience/inference/testutil/sample"
-	"github.com/productscience/inference/x/inference/keeper"
-	"github.com/productscience/inference/x/inference/types"
-)
-
-// This suite focuses on msg_server_invalidate_inference.go behavior around refunding the requester
-// and subtracting the ActualCost from the executor.
-
-func setupInvalidateHarness(t testing.TB) (keeper.Keeper, types.MsgServer, sdk.Context, *keepertest.InferenceMocks) {
-	k, ctx, mocks := keepertest.InferenceKeeperReturningMocks(t)
-	ms := keeper.NewMsgServerImpl(k)
-	return k, ms, ctx, &mocks
-}
-
-func setEffectiveEpoch(ctx sdk.Context, k keeper.Keeper, epochIndex uint64, mocks *keepertest.InferenceMocks) error {
-	k.SetEpoch(ctx, &types.Epoch{Index: epochIndex})
-	_ = k.SetEffectiveEpochIndex(ctx, epochIndex)
-	mocks.ExpectCreateGroupWithPolicyCall(ctx, epochIndex)
-	eg, err := k.CreateEpochGroup(ctx, epochIndex, epochIndex)
-	if err != nil {
-		return err
-	}
-	err = eg.CreateGroup(ctx)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func TestInvalidateInference_RefundsRequesterAndChargesExecutor_NoSlash(t *testing.T) {
-	k, ms, ctx, mocks := setupInvalidateHarness(t)
-
-	// Configure params so that invalidation does NOT trigger status INVALID (no slash).
-	params := types.DefaultParams()
-	// Keep FalsePositiveRate at default 0.05 and start with 0 consecutive; after +1, probability is 0.05^1 = 0.05 > 1e-6, so remains ACTIVE, so no slashing.
-	k.SetParams(ctx, params)
-
-	err := setEffectiveEpoch(ctx, k, 1, mocks)
-	require.NoError(t, err)
-
-	// Create executor and payer accounts
-
-	executorAddr := sample.AccAddress()
-	payerAddr := sample.AccAddress()
-
-	// Register executor with some coin balance and just below threshold
-	executor := types.Participant{
-		Index:                        executorAddr,
-		Address:                      executorAddr,
-		Status:                       types.ParticipantStatus_ACTIVE,
-		ConsecutiveInvalidInferences: 0,
-		CurrentEpochStats:            &types.CurrentEpochStats{},
-		CoinBalance:                  1_000, // arbitrary internal balance field used by keeper
-	}
-	k.SetParticipant(ctx, executor)
-
-	// Register payer (requester)
-	payer := types.Participant{Index: payerAddr, Address: payerAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, payer)
-
-	k.SetActiveParticipants(ctx, ParticipantsToActive(1, payer, executor))
-	// Inference with non-zero cost
-	inferenceID := "refund-no-slash"
-	actualCost := int64(123)
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceID,
-		InferenceId:     inferenceID,
-		ExecutedBy:      executorAddr,
-		RequestedBy:     payerAddr,
-		Status:          types.InferenceStatus_FINISHED,
-		ActualCost:      actualCost,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: payerAddr},
-		EpochId:         1,
-	})
-
-	// Expect subaccount transaction log for executor debt subtraction
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any())
-	// Expect refund to be issued to the payer via module->account transfer inside IssueRefund
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
-
-	// We do NOT expect any slashing in this test
-	mocks.CollateralKeeper.EXPECT().Slash(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{Creator: payerAddr, InferenceId: inferenceID})
-	require.NoError(t, err)
-
-	// Verify executor was charged
-	updatedExecutor, ok := k.GetParticipant(ctx, executorAddr)
-	require.True(t, ok)
-	require.Equal(t, int64(1_000-actualCost), updatedExecutor.CoinBalance)
-
-	// Verify inference status updated
-	updatedInf, found := k.GetInference(ctx, inferenceID)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_INVALIDATED, updatedInf.Status)
-}
-
-func TestInvalidateInference_RefundsRequesterAndChargesExecutor_WithSlash(t *testing.T) {
-	k, ms, ctx, mocks := setupInvalidateHarness(t)
-
-	// Configure params so that slashing will occur upon INVALID status; we will force INVALID by setting
-	// executor.ConsecutiveInvalidInferences high enough that after +1, ProbabilityOfConsecutiveFailures < 1e-6.
-	// With FPR=0.05, need N such that 0.05^N < 1e-6 => N > log(1e-6)/log(0.05) ~ 3.01/1.3 ~ 4; actually 0.05^5=3.125e-7 <1e-6.
-	params := types.DefaultParams()
-	params.CollateralParams.SlashFractionInvalid = types.DecimalFromFloat(0.25)
-	k.SetParams(ctx, params)
-
-	err := setEffectiveEpoch(ctx, k, 1, mocks)
-	require.NoError(t, err)
-
-	executorAddr := sample.AccAddress()
-	payerAddr := sample.AccAddress()
-
-	// Set executor with 4 consecutive invalids so increment => 5, causing INVALID by probability rule
-	executor := types.Participant{
-		Index:                        executorAddr,
-		Address:                      executorAddr,
-		Status:                       types.ParticipantStatus_ACTIVE,
-		ConsecutiveInvalidInferences: 4,
-		CurrentEpochStats:            &types.CurrentEpochStats{},
-		CoinBalance:                  5_000,
-	}
-	k.SetParticipant(ctx, executor)
-
-	// Register payer
-	payer := types.Participant{Index: payerAddr, Address: payerAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, payer)
-
-	k.SetActiveParticipants(ctx, ParticipantsToActive(1, payer, executor))
-	// Non-zero cost
-	inferenceID := "refund-with-slash"
-	actualCost := int64(250)
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceID,
-		InferenceId:     inferenceID,
-		ExecutedBy:      executorAddr,
-		RequestedBy:     payerAddr,
-		Status:          types.InferenceStatus_FINISHED,
-		ActualCost:      actualCost,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: payerAddr},
-		EpochId:         1,
-	})
-
-	// Expect refund transfer to payer for ActualCost
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
-	// Expect subaccount transaction log
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any())
-	mocks.GroupKeeper.EXPECT().UpdateGroupMembers(gomock.Any(), gomock.Any())
-	mocks.GroupKeeper.EXPECT().UpdateGroupMetadata(gomock.Any(), gomock.Any())
-
-	// Expect a slash due to status transition to INVALID
-	execAcc, _ := sdk.AccAddressFromBech32(executorAddr)
-	slashFraction, _ := params.CollateralParams.SlashFractionInvalid.ToLegacyDec()
-	mocks.CollateralKeeper.EXPECT().Slash(gomock.Any(), execAcc, slashFraction, types.SlashReasonInvalidation, gomock.Any()).Return(sdk.NewCoin(types.BaseCoin, math.NewInt(0)), nil).Times(1)
-
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{Creator: payerAddr, InferenceId: inferenceID})
-	require.NoError(t, err)
-
-	// Verify executor charged
-	updatedExecutor, ok := k.GetParticipant(ctx, executorAddr)
-	require.True(t, ok)
-	require.Equal(t, int64(5_000-actualCost), updatedExecutor.CoinBalance)
-	// And status should now be INVALID due to threshold 1
-	require.Equal(t, types.ParticipantStatus_INVALID, updatedExecutor.Status)
-
-	updatedInf, found := k.GetInference(ctx, inferenceID)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_INVALIDATED, updatedInf.Status)
-}
-
-func TestInvalidateInference_NextEpoch_NoRefundNoCharge_NoSlash(t *testing.T) {
-	k, ms, ctx, mocks := setupInvalidateHarness(t)
-
-	// Params where slashing could occur if status flips, but in next-epoch invalidation
-	// we expect NO financial moves (no refund, no executor charge) and NO slash.
-	params := types.DefaultParams()
-	params.CollateralParams.SlashFractionInvalid = types.DecimalFromFloat(0.3)
-	k.SetParams(ctx, params)
-
-	err := setEffectiveEpoch(ctx, k, 1, mocks)
-	require.NoError(t, err)
-
-	executorAddr := sample.AccAddress()
-	payerAddr := sample.AccAddress()
-
-	initialBalance := int64(2_000)
-	executor := types.Participant{
-		Index:                        executorAddr,
-		Address:                      executorAddr,
-		Status:                       types.ParticipantStatus_ACTIVE,
-		ConsecutiveInvalidInferences: 0,
-		CurrentEpochStats:            &types.CurrentEpochStats{},
-		CoinBalance:                  initialBalance,
-	}
-	k.SetParticipant(ctx, executor)
-
-	payer := types.Participant{Index: payerAddr, Address: payerAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, payer)
-
-	inferenceID := "invalidate-next-epoch"
-	actualCost := int64(777)
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceID,
-		InferenceId:     inferenceID,
-		ExecutedBy:      executorAddr,
-		RequestedBy:     payerAddr,
-		Status:          types.InferenceStatus_FINISHED,
-		ActualCost:      actualCost,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: payerAddr},
-		EpochId:         1,
-	})
-
-	err = setEffectiveEpoch(ctx, k, 2, mocks)
-	require.NoError(t, err)
-	k.SetActiveParticipants(ctx, ParticipantsToActive(2, payer, executor))
-
-	// In the correct behavior, since the invalidation happens after the epoch of execution,
-	// there should be NO refund and NO charge to executor, and NO slashing.
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-	mocks.CollateralKeeper.EXPECT().Slash(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{Creator: payerAddr, InferenceId: inferenceID})
-	require.NoError(t, err)
-
-	// Expect executor coin balance unchanged
-	updatedExecutor, ok := k.GetParticipant(ctx, executorAddr)
-	require.True(t, ok)
-	require.Equal(t, initialBalance, updatedExecutor.CoinBalance)
-
-	// Inference may be marked invalidated, but no financials changed
-	updatedInf, found := k.GetInference(ctx, inferenceID)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_INVALIDATED, updatedInf.Status)
-}
-
-func TestInvalidateInference_FailsWithWrongPolicyAddress(t *testing.T) {
-	k, ms, ctx, mocks := setupInvalidateHarness(t)
-
-	// Setup epoch and group
-	require.NoError(t, setEffectiveEpoch(ctx, k, 1, mocks))
-
-	executorAddr := sample.AccAddress()
-	payerAddr := sample.AccAddress()
-	wrongCreator := sample.AccAddress()
-
-	k.SetParticipant(ctx, types.Participant{Index: executorAddr, Address: executorAddr, CurrentEpochStats: &types.CurrentEpochStats{}})
-	k.SetParticipant(ctx, types.Participant{Index: payerAddr, Address: payerAddr, CurrentEpochStats: &types.CurrentEpochStats{}})
-
-	inferenceID := "wrong-policy"
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceID,
-		InferenceId:     inferenceID,
-		ExecutedBy:      executorAddr,
-		RequestedBy:     payerAddr,
-		Status:          types.InferenceStatus_FINISHED,
-		ActualCost:      10,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: payerAddr},
-		EpochId:         1,
-	})
-
-	// Creator is not equal to policy address -> expect error
-	_, err := ms.InvalidateInference(ctx, &types.MsgInvalidateInference{Creator: wrongCreator, InferenceId: inferenceID, Invalidator: payerAddr})
-	require.Error(t, err)
-}
-
-func TestInvalidateInference_RemovesActiveInvalidations(t *testing.T) {
-	k, ms, ctx, mocks := setupInvalidateHarness(t)
-
-	// Set epoch 1
-	require.NoError(t, setEffectiveEpoch(ctx, k, 1, mocks))
-
-	executorAddr := sample.AccAddress()
-	payerAddr := sample.AccAddress()
-	invalidator := sample.AccAddress()
-	executor := types.Participant{Index: executorAddr, Address: executorAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, executor)
-	payer := types.Participant{Index: payerAddr, Address: payerAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, payer)
-
-	inferenceID := "remove-active-invalidations"
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceID,
-		InferenceId:     inferenceID,
-		ExecutedBy:      executorAddr,
-		RequestedBy:     payerAddr,
-		Status:          types.InferenceStatus_FINISHED,
-		ActualCost:      100,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: payerAddr},
-		EpochId:         1,
-	})
-
-	// Add ActiveInvalidations entry for invalidator
-	addr := sdk.MustAccAddressFromBech32(invalidator)
-	require.NoError(t, k.ActiveInvalidations.Set(ctx, collections.Join(addr, inferenceID)))
-	has, err := k.ActiveInvalidations.Has(ctx, collections.Join(addr, inferenceID))
-	require.NoError(t, err)
-	require.True(t, has)
-
-	// Move to next epoch to avoid any refund/charge side effects in this focused test
-	require.NoError(t, setEffectiveEpoch(ctx, k, 2, mocks))
-	k.SetActiveParticipants(ctx, ParticipantsToActive(2, payer, executor))
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-	mocks.CollateralKeeper.EXPECT().Slash(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{Creator: payerAddr, InferenceId: inferenceID, Invalidator: invalidator})
-	require.NoError(t, err)
-
-	// ActiveInvalidations should be removed
-	has, err = k.ActiveInvalidations.Has(ctx, collections.Join(addr, inferenceID))
-	require.NoError(t, err)
-	require.False(t, has)
-}
-
-func TestInvalidateInference_AlreadyInvalidated_RemovesActiveInvalidations(t *testing.T) {
-	k, ms, ctx, mocks := setupInvalidateHarness(t)
-	require.NoError(t, setEffectiveEpoch(ctx, k, 1, mocks))
-
-	executorAddr := sample.AccAddress()
-	payerAddr := sample.AccAddress()
-	invalidator := sample.AccAddress()
-	executor := types.Participant{Index: executorAddr, Address: executorAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, executor)
-	payer := types.Participant{Index: payerAddr, Address: payerAddr, CurrentEpochStats: &types.CurrentEpochStats{}}
-	k.SetParticipant(ctx, payer)
-
-	inferenceID := "already-invalidated-removes"
-	k.SetInference(ctx, types.Inference{
-		Index:           inferenceID,
-		InferenceId:     inferenceID,
-		ExecutedBy:      executorAddr,
-		RequestedBy:     payerAddr,
-		Status:          types.InferenceStatus_INVALIDATED, // already invalidated
-		ActualCost:      50,
-		ProposalDetails: &types.ProposalDetails{PolicyAddress: payerAddr},
-		EpochId:         1,
-	})
-
-	// Add ActiveInvalidations entry which should be removed even on idempotent path
-	addr := sdk.MustAccAddressFromBech32(invalidator)
-	require.NoError(t, k.ActiveInvalidations.Set(ctx, collections.Join(addr, inferenceID)))
-	has, err := k.ActiveInvalidations.Has(ctx, collections.Join(addr, inferenceID))
-	require.NoError(t, err)
-	require.True(t, has)
-
-	// Move to next epoch to avoid any refund/charge expectations
-	require.NoError(t, setEffectiveEpoch(ctx, k, 2, mocks))
-	k.SetActiveParticipants(ctx, ParticipantsToActive(2, payer, executor))
-	mocks.BankKeeper.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-	mocks.BankKeeper.EXPECT().LogSubAccountTransaction(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-	mocks.CollateralKeeper.EXPECT().Slash(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
-
-	// Call invalidate; should succeed and remove ActiveInvalidations
-	_, err = ms.InvalidateInference(ctx, &types.MsgInvalidateInference{Creator: payerAddr, InferenceId: inferenceID, Invalidator: invalidator})
-	require.NoError(t, err)
-
-	has, err = k.ActiveInvalidations.Has(ctx, collections.Join(addr, inferenceID))
-	require.NoError(t, err)
-	require.False(t, has)
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_out_of_order_inference_test.go b/inference-chain/x/inference/keeper/msg_server_out_of_order_inference_test.go
deleted file mode 100644
index 738bf9f8ad..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_out_of_order_inference_test.go
+++ /dev/null
@@ -1,168 +0,0 @@
-package keeper_test
-
-import (
-	"testing"
-
-	"github.com/productscience/inference/x/inference/calculations"
-	inference "github.com/productscience/inference/x/inference/module"
-	"go.uber.org/mock/gomock"
-
-	authztypes "github.com/cosmos/cosmos-sdk/x/authz"
-	"github.com/productscience/inference/testutil"
-	"github.com/productscience/inference/x/inference/types"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMsgServer_OutOfOrderInference(t *testing.T) {
-	k, ms, ctx, mocks := setupKeeperWithMocks(t)
-
-	mockRequester := NewMockAccount(testutil.Requester)
-	mockTransferAgent := NewMockAccount(testutil.Creator)
-	mockExecutor := NewMockAccount(testutil.Executor)
-	MustAddParticipant(t, ms, ctx, *mockRequester)
-	MustAddParticipant(t, ms, ctx, *mockTransferAgent)
-	MustAddParticipant(t, ms, ctx, *mockExecutor)
-
-	_ = k.SetActiveParticipants(ctx, ParticipantsToActive(0, types.Participant{Index: testutil.Executor},
-		types.Participant{Index: testutil.Creator}, types.Participant{Index: testutil.Requester}))
-	mocks.StubForInitGenesis(ctx)
-
-	// For escrow calls
-	mocks.BankKeeper.ExpectAny(ctx)
-	mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), mockRequester.GetBechAddress()).Return(true).AnyTimes()
-	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), mockRequester.GetBechAddress()).Return(mockRequester).AnyTimes()
-	mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), mockTransferAgent.GetBechAddress()).Return(true).AnyTimes()
-	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), mockTransferAgent.GetBechAddress()).Return(mockTransferAgent).AnyTimes()
-	mocks.AccountKeeper.EXPECT().HasAccount(gomock.Any(), mockExecutor.GetBechAddress()).Return(true).AnyTimes()
-	mocks.AccountKeeper.EXPECT().GetAccount(gomock.Any(), mockExecutor.GetBechAddress()).Return(mockExecutor).AnyTimes()
-
-	// For GranteesByMessageType calls (used by both FinishInference and StartInference)
-	mocks.AuthzKeeper.EXPECT().GranterGrants(gomock.Any(), gomock.Any()).Return(&authztypes.QueryGranterGrantsResponse{Grants: []*authztypes.GrantAuthorization{}}, nil).AnyTimes()
-
-	inference.InitGenesis(ctx, k, mocks.StubGenesisState())
-
-	// Disable grace period for tests so we get actual pricing instead of 0
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	params.DynamicPricingParams.GracePeriodEndEpoch = 0
-	k.SetParams(ctx, params)
-
-	payload := "promptPayload"
-	requestTimestamp := ctx.BlockTime().UnixNano()
-
-	// Phase 3/6: Compute hashes for signatures
-	originalPromptHash := sha256Hash(payload)
-	promptHash := sha256Hash(payload) // In real flow, would be sha256(canonical request)
-
-	// Phase 3: Dev signs original_prompt_hash
-	devComponents := calculations.SignatureComponents{
-		Payload:         originalPromptHash,
-		Timestamp:       requestTimestamp,
-		TransferAddress: mockTransferAgent.address,
-		ExecutorAddress: "", // Dev doesn't include executor
-	}
-	inferenceId, err := calculations.Sign(mockRequester, devComponents, calculations.Developer)
-	require.NoError(t, err)
-
-	// Phase 3: TA and Executor sign prompt_hash
-	taComponents := calculations.SignatureComponents{
-		Payload:         promptHash,
-		Timestamp:       requestTimestamp,
-		TransferAddress: mockTransferAgent.address,
-		ExecutorAddress: mockExecutor.address,
-	}
-	taSignature, err := calculations.Sign(mockTransferAgent, taComponents, calculations.TransferAgent)
-	require.NoError(t, err)
-	eaSignature, err := calculations.Sign(mockExecutor, taComponents, calculations.ExecutorAgent)
-	require.NoError(t, err)
-
-	// First, try to finish an inference that hasn't been started yet
-	// With our fix, this should now succeed
-	_, err = ms.FinishInference(ctx, &types.MsgFinishInference{
-		Creator:              mockExecutor.address,
-		InferenceId:          inferenceId,
-		ResponseHash:         "responseHash",
-		ResponsePayload:      "responsePayload",
-		PromptTokenCount:     10,
-		CompletionTokenCount: 20,
-		ExecutedBy:           mockExecutor.address,
-		TransferredBy:        mockTransferAgent.address,
-		RequestTimestamp:     requestTimestamp,
-		TransferSignature:    taSignature,
-		ExecutorSignature:    eaSignature,
-		RequestedBy:          mockRequester.address,
-		OriginalPrompt:       payload,
-		PromptHash:           promptHash,
-		OriginalPromptHash:   originalPromptHash,
-		Model:                "model1",
-	})
-	require.NoError(t, err) // Now this should succeed
-
-	// Verify the inference was created with FINISHED status
-	savedInference, found := k.GetInference(ctx, inferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_FINISHED, savedInference.Status)
-	require.Equal(t, "responseHash", savedInference.ResponseHash)
-	require.Equal(t, "", savedInference.ResponsePayload) // Phase 6: Stored offchain
-	require.Equal(t, uint64(10), savedInference.PromptTokenCount)
-	require.Equal(t, uint64(20), savedInference.CompletionTokenCount)
-	require.Equal(t, testutil.Executor, savedInference.ExecutedBy)
-	require.Equal(t, originalPromptHash, savedInference.OriginalPromptHash)
-
-	model := types.Model{Id: "model1"}
-	StubModelSubgroup(t, ctx, k, mocks, &model)
-
-	executorBeforeStart, found := k.GetParticipant(ctx, testutil.Executor)
-	require.True(t, found)
-	if executorBeforeStart.CurrentEpochStats == nil {
-		executorBeforeStart.CurrentEpochStats = &types.CurrentEpochStats{}
-	}
-
-	// Now start the inference
-	_, err = ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:        inferenceId,
-		PromptHash:         promptHash,
-		PromptPayload:      payload,
-		RequestedBy:        testutil.Requester,
-		Creator:            testutil.Creator,
-		Model:              "model1",
-		OriginalPrompt:     payload,
-		OriginalPromptHash: originalPromptHash,
-		RequestTimestamp:   requestTimestamp,
-		TransferSignature:  taSignature,
-		AssignedTo:         testutil.Executor,
-	})
-	require.NoError(t, err)
-
-	// Verify the inference was updated correctly
-	// It should still be in FINISHED state, but now have the start information as well
-	savedInference, found = k.GetInference(ctx, inferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_FINISHED, savedInference.Status)
-	require.Equal(t, promptHash, savedInference.PromptHash)
-	require.Equal(t, "", savedInference.PromptPayload) // Phase 6: Stored offchain
-	require.Equal(t, testutil.Requester, savedInference.RequestedBy)
-	require.Equal(t, "model1", savedInference.Model)
-
-	// The finish information should still be there
-	require.Equal(t, "responseHash", savedInference.ResponseHash)
-	require.Equal(t, "", savedInference.ResponsePayload) // Phase 6: Stored offchain
-	require.Equal(t, uint64(10), savedInference.PromptTokenCount)
-	require.Equal(t, uint64(20), savedInference.CompletionTokenCount)
-	require.Equal(t, testutil.Executor, savedInference.ExecutedBy)
-	require.Equal(t, originalPromptHash, savedInference.OriginalPromptHash)
-
-	// Verify that the escrow amount is based on the actual token counts, not the MaxTokens
-	// The actual cost should be (10 + 20) * PerTokenCost = 30 * PerTokenCost
-	expectedActualCost := int64(30 * calculations.PerTokenCost)
-	require.Equal(t, expectedActualCost, savedInference.ActualCost)
-
-	// The escrow amount should be the same as the actual cost
-	require.Equal(t, expectedActualCost, savedInference.EscrowAmount)
-
-	executorAfterStart, found := k.GetParticipant(ctx, testutil.Executor)
-	require.True(t, found)
-	require.NotNil(t, executorAfterStart.CurrentEpochStats)
-	require.Equal(t, executorBeforeStart.CurrentEpochStats.InferenceCount+1, executorAfterStart.CurrentEpochStats.InferenceCount)
-	require.Equal(t, executorBeforeStart.CurrentEpochStats.EarnedCoins+uint64(expectedActualCost), executorAfterStart.CurrentEpochStats.EarnedCoins)
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_poc_validations_v2.go b/inference-chain/x/inference/keeper/msg_server_poc_validations_v2.go
index b44b157af2..0620e4ad7e 100644
--- a/inference-chain/x/inference/keeper/msg_server_poc_validations_v2.go
+++ b/inference-chain/x/inference/keeper/msg_server_poc_validations_v2.go
@@ -119,15 +119,23 @@ func (k msgServer) SubmitPocValidationsV2(goCtx context.Context, msg *types.MsgS
 			continue
 		}
 
+		// Pre-validate participant address to avoid conflating input errors with storage errors
+		if _, err := sdk.AccAddressFromBech32(validation.ParticipantAddress); err != nil {
+			k.LogWarn("[SubmitPocValidationsV2] Invalid participant address, skipping", types.PoC,
+				"validator", msg.Creator,
+				"participant", validation.ParticipantAddress,
+				"error", err)
+			continue
+		}
+
 		// Check for duplicate submission (prevents vote flipping)
 		exists, err := k.HasPocValidationV2(ctx, startBlockHeight, validation.ParticipantAddress, modelID, msg.Creator)
 		if err != nil {
-			k.LogWarn("[SubmitPocValidationsV2] Failed to check existing validation, skipping", types.PoC,
+			k.LogError("[SubmitPocValidationsV2] Unexpected storage read error, aborting batch", types.PoC,
 				"validator", msg.Creator,
 				"participant", validation.ParticipantAddress,
-				"model_id", modelID,
 				"error", err)
-			continue
+			return nil, sdkerrors.Wrapf(err, "[SubmitPocValidationsV2] failed to check existing validation for participant %s", validation.ParticipantAddress)
 		}
 		if exists {
 			k.LogWarn("[SubmitPocValidationsV2] Validation already exists, skipping duplicate", types.PoC,
@@ -148,12 +156,12 @@ func (k msgServer) SubmitPocValidationsV2(goCtx context.Context, msg *types.MsgS
 		}
 
 		if err := k.SetPocValidationV2(ctx, storedValidation); err != nil {
-			k.LogWarn("[SubmitPocValidationsV2] Failed to store validation, skipping", types.PoC,
+			k.LogError("[SubmitPocValidationsV2] Unexpected storage write error, aborting batch", types.PoC,
 				"validator", msg.Creator,
 				"participant", validation.ParticipantAddress,
 				"model_id", modelID,
 				"error", err)
-			continue
+			return nil, sdkerrors.Wrapf(err, "[SubmitPocValidationsV2] failed to store validation for participant %s", validation.ParticipantAddress)
 		}
 
 		storedCount++
diff --git a/inference-chain/x/inference/keeper/msg_server_revalidate_inference.go b/inference-chain/x/inference/keeper/msg_server_revalidate_inference.go
index 47d3c01af6..aaf6bd3633 100644
--- a/inference-chain/x/inference/keeper/msg_server_revalidate_inference.go
+++ b/inference-chain/x/inference/keeper/msg_server_revalidate_inference.go
@@ -3,45 +3,14 @@ package keeper
 import (
 	"context"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/productscience/inference/x/inference/types"
 )
 
 func (k msgServer) RevalidateInference(ctx context.Context, msg *types.MsgRevalidateInference) (*types.MsgRevalidateInferenceResponse, error) {
-	// Revalidate is a special case for permissions!
-	// The Creator needs to be the policy-id of the GROUP that the revalidation vote happened in.
 	if err := k.CheckPermission(ctx, msg, NoPermission); err != nil {
 		return nil, err
 	}
 
-	inference, executor, err := k.validateDecisionMessage(ctx, msg)
-	if err != nil {
-		return nil, err
-	}
-
-	if inference.Status == types.InferenceStatus_VALIDATED {
-		k.LogDebug("Inference already validated", types.Validation, "inferenceId", msg.InferenceId)
-		return nil, nil
-	}
-
-	previousStatus := inference.Status
-	inference.Status = types.InferenceStatus_VALIDATED
-	executor.ConsecutiveInvalidInferences = 0
-	executor.CurrentEpochStats.ValidatedInferences++
-
-	err = k.SetParticipant(ctx, *executor)
-	if err != nil {
-		return nil, err
-	}
-
-	k.LogInfo("Saving inference", types.Validation, "inferenceId", inference.InferenceId, "status", inference.Status, "authority", inference.ProposalDetails.PolicyAddress)
-	err = k.SetInference(ctx, *inference)
-	if err != nil {
-		return nil, err
-	}
-	if inference.Status != previousStatus {
-		emitInferenceStatusUpdatedEvent(sdk.UnwrapSDKContext(ctx), inference.InferenceId, inference.Status)
-	}
-
-	return &types.MsgRevalidateInferenceResponse{}, nil
+	k.LogInfo("MsgRevalidateInference deprecated", types.Validation, "inferenceId", msg.InferenceId, "creator", msg.Creator)
+	return nil, classicInferenceDeprecatedError()
 }
diff --git a/inference-chain/x/inference/keeper/msg_server_revalidate_inference_test.go b/inference-chain/x/inference/keeper/msg_server_revalidate_inference_test.go
deleted file mode 100644
index 250dce5609..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_revalidate_inference_test.go
+++ /dev/null
@@ -1,176 +0,0 @@
-package keeper_test
-
-import (
-	"testing"
-	"time"
-
-	"cosmossdk.io/collections"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/group"
-	"github.com/productscience/inference/testutil"
-	"github.com/productscience/inference/x/inference/calculations"
-	"github.com/productscience/inference/x/inference/types"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-)
-
-// These tests mirror msg_server_validation_test.go setup and assertions
-// to validate RevalidateInference behavior.
-
-func setupInferenceInVoting(t *testing.T) (*MockInferenceHelper, *types.Inference, string) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-	addMembersToGroupData(k, ctx)
-
-	// Start and finish an inference
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-	buildValidationCacheForTest(t, k, ctx)
-
-	// Cause an invalidation vote by submitting a below-threshold validation
-	mocks := inferenceHelper.Mocks
-	mocks.GroupKeeper.EXPECT().SubmitProposal(gomock.Any(), gomock.Any()).Return(&group.MsgSubmitProposalResponse{ProposalId: 1}, nil)
-	mocks.GroupKeeper.EXPECT().SubmitProposal(gomock.Any(), gomock.Any()).Return(&group.MsgSubmitProposalResponse{ProposalId: 2}, nil)
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.0), // below threshold to trigger voting
-	})
-	require.NoError(t, err)
-
-	// Fetch updated inference to get policy address
-	saved, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VOTING, saved.Status)
-
-	return inferenceHelper, &saved, saved.ProposalDetails.PolicyAddress
-}
-
-func TestRevalidate_FailsWithWrongPolicyAddress(t *testing.T) {
-	inferenceHelper, inf, _ := setupInferenceInVoting(t)
-	ctx := inferenceHelper.context
-	ms := inferenceHelper.MessageServer
-
-	// Attempt revalidation with WRONG creator (should be policy address)
-	_, err := ms.RevalidateInference(ctx, &types.MsgRevalidateInference{
-		InferenceId: inf.InferenceId,
-		Creator:     testutil.Validator, // wrong; should be policy address
-		Invalidator: testutil.Validator,
-	})
-	require.Error(t, err)
-}
-
-func TestRevalidate_RemovesActiveInvalidation(t *testing.T) {
-	inferenceHelper, inf, policyAddr := setupInferenceInVoting(t)
-	k := inferenceHelper.keeper
-	ctx := inferenceHelper.context
-	ms := inferenceHelper.MessageServer
-
-	// Ensure ActiveInvalidations entry exists first
-	has, err := k.ActiveInvalidations.Has(ctx, collections.Join(sdk.MustAccAddressFromBech32(testutil.Validator), inf.InferenceId))
-	require.NoError(t, err)
-	require.True(t, has)
-
-	// Perform revalidation with correct policy address and invalidator
-	_, err = ms.RevalidateInference(ctx, &types.MsgRevalidateInference{
-		InferenceId: inf.InferenceId,
-		Creator:     policyAddr,
-		Invalidator: testutil.Validator,
-	})
-	require.NoError(t, err)
-
-	// ActiveInvalidations should be removed
-	has, err = k.ActiveInvalidations.Has(ctx, collections.Join(sdk.MustAccAddressFromBech32(testutil.Validator), inf.InferenceId))
-	require.NoError(t, err)
-	require.False(t, has)
-}
-
-func TestRevalidate_DoesNotChangeAlreadyValidatedInference(t *testing.T) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-	addMembersToGroupData(k, ctx)
-
-	// Start and finish inference
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-
-	// Manually set status to VALIDATED and add an ActiveInvalidations entry to simulate prior state
-	inf, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	inf.Status = types.InferenceStatus_VALIDATED
-	// create a fake policy address authority matching creator
-	policyAddr := testutil.Creator
-	inf.ProposalDetails = &types.ProposalDetails{PolicyAddress: policyAddr}
-	k.SetInference(ctx, inf)
-	err = k.ActiveInvalidations.Set(ctx, collections.Join(sdk.MustAccAddressFromBech32(testutil.Validator), expected.InferenceId))
-	require.NoError(t, err)
-
-	// Capture executor stats before
-	execBefore, found := k.GetParticipant(ctx, inf.ExecutedBy)
-	require.True(t, found)
-
-	// Call revalidate: should early-return (no change to inference/executor), but still remove ActiveInvalidation due to validationDecisionMessage
-	_, err = inferenceHelper.MessageServer.RevalidateInference(ctx, &types.MsgRevalidateInference{
-		InferenceId: inf.InferenceId,
-		Creator:     policyAddr,
-		Invalidator: testutil.Validator,
-	})
-	require.NoError(t, err)
-
-	// Inference unchanged (still VALIDATED)
-	after, found := k.GetInference(ctx, inf.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VALIDATED, after.Status)
-
-	// Executor stats unchanged
-	execAfter, found := k.GetParticipant(ctx, inf.ExecutedBy)
-	require.True(t, found)
-	require.Equal(t, execBefore, execAfter)
-
-	// ActiveInvalidations should be removed despite early return
-	has, err := k.ActiveInvalidations.Has(ctx, collections.Join(sdk.MustAccAddressFromBech32(testutil.Validator), inf.InferenceId))
-	require.NoError(t, err)
-	require.False(t, has)
-}
-
-func TestRevalidate_UpdatesExecutorAndInference(t *testing.T) {
-	inferenceHelper, inf, policyAddr := setupInferenceInVoting(t)
-	k := inferenceHelper.keeper
-	ctx := inferenceHelper.context
-	ms := inferenceHelper.MessageServer
-
-	// Get executor before
-	execBefore, found := k.GetParticipant(ctx, inf.ExecutedBy)
-	require.True(t, found)
-
-	// Perform revalidation
-	_, err := ms.RevalidateInference(ctx, &types.MsgRevalidateInference{
-		InferenceId: inf.InferenceId,
-		Creator:     policyAddr,
-		Invalidator: testutil.Validator,
-	})
-	require.NoError(t, err)
-
-	// Inference should now be VALIDATED
-	saved, found := k.GetInference(ctx, inf.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VALIDATED, saved.Status)
-
-	// Executor should have stats updated
-	execAfter, found := k.GetParticipant(ctx, inf.ExecutedBy)
-	require.True(t, found)
-	require.Equal(t, int64(0), execBefore.ConsecutiveInvalidInferences) // Before could be 0 already, but after must be 0
-	require.Equal(t, execBefore.CurrentEpochStats.ValidatedInferences+1, execAfter.CurrentEpochStats.ValidatedInferences)
-	// Status is recalculated by calculateStatus; we don't assert exact status value, but ensure it's set (enum) by checking not empty string when converted
-	_ = execAfter.Status // presence check
-}
diff --git a/inference-chain/x/inference/keeper/msg_server_schedule_maintenance.go b/inference-chain/x/inference/keeper/msg_server_schedule_maintenance.go
new file mode 100644
index 0000000000..88d38c0b22
--- /dev/null
+++ b/inference-chain/x/inference/keeper/msg_server_schedule_maintenance.go
@@ -0,0 +1,154 @@
+package keeper
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func (k msgServer) ScheduleMaintenance(goCtx context.Context, msg *types.MsgScheduleMaintenance) (*types.MsgScheduleMaintenanceResponse, error) {
+	if err := k.CheckPermission(goCtx, msg, AccountPermission); err != nil {
+		return nil, err
+	}
+
+	sdkCtx := sdk.UnwrapSDKContext(goCtx)
+	blockHeight := sdkCtx.BlockHeight()
+
+	// Authorization: only the participant themselves may schedule their own
+	// maintenance window. Without this check, anyone could drain another
+	// participant's credit and force them into maintenance.
+	if msg.Creator != msg.Participant {
+		return nil, types.ErrInvalidPermission
+	}
+
+	// Check maintenance is enabled
+	mp := k.GetMaintenanceParams(goCtx)
+	if mp == nil || !mp.MaintenanceEnabled {
+		return nil, types.ErrMaintenanceDisabled
+	}
+
+	// Validate participant address
+	participantAddr, err := sdk.AccAddressFromBech32(msg.Participant)
+	if err != nil {
+		return nil, types.ErrMaintenanceInvalidParticipant
+	}
+
+	// Verify participant exists
+	_, err = k.Participants.Get(goCtx, participantAddr)
+	if err != nil {
+		return nil, types.ErrParticipantNotFound
+	}
+
+	// Validate duration is positive and within limits
+	if msg.DurationBlocks == 0 {
+		return nil, types.ErrMaintenanceZeroDuration
+	}
+	if msg.DurationBlocks > mp.MaintenanceMaxWindowBlocks {
+		return nil, types.ErrMaintenanceDurationExceeded
+	}
+	if msg.DurationBlocks > math.MaxInt64 || msg.StartHeight > math.MaxInt64-int64(msg.DurationBlocks) {
+		return nil, types.ErrMaintenanceCompletionHeightOverflow
+	}
+
+	// Validate lead time: startHeight must be at least MinScheduleLeadBlocks
+	// in the future. Using strict less-than so a request scheduled exactly
+	// MinScheduleLeadBlocks blocks ahead is accepted.
+	if msg.StartHeight < blockHeight+int64(mp.MaintenanceMinScheduleLeadBlocks) {
+		return nil, types.ErrMaintenanceInsufficientLeadTime
+	}
+
+	// Check participant does not already have a scheduled reservation
+	state := k.GetOrCreateMaintenanceState(goCtx, participantAddr)
+	if state.ScheduledReservationId != 0 {
+		return nil, types.ErrMaintenanceAlreadyScheduled
+	}
+
+	// Check sufficient credit
+	if state.CreditBlocks < msg.DurationBlocks {
+		return nil, types.ErrMaintenanceInsufficientCredit
+	}
+
+	// Check epoch-critical phase overlap (PoC and DKG/SetNewValidators)
+	if err := k.checkEpochPhaseOverlap(goCtx, msg.StartHeight, msg.DurationBlocks, mp); err != nil {
+		return nil, err
+	}
+
+	// Check concurrency limits
+	if err := k.checkConcurrencyLimits(goCtx, msg.StartHeight, msg.DurationBlocks, participantAddr, mp); err != nil {
+		return nil, err
+	}
+
+	// Check same-participant overlap with existing reservations
+	if err := k.checkParticipantOverlap(goCtx, participantAddr, msg.StartHeight, msg.DurationBlocks); err != nil {
+		return nil, err
+	}
+
+	// All checks pass — create the reservation
+	reservationID, err := k.NextMaintenanceReservationID(goCtx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to allocate reservation ID: %w", err)
+	}
+
+	reservation := types.MaintenanceReservation{
+		ReservationId:  reservationID,
+		Participant:    msg.Participant,
+		StartHeight:    msg.StartHeight,
+		DurationBlocks: msg.DurationBlocks,
+		CreatedBy:      msg.Creator,
+		Status:         types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED,
+	}
+
+	if err := k.SetMaintenanceReservation(goCtx, reservation); err != nil {
+		return nil, err
+	}
+
+	// Add to scheduled index for bounded iteration in queries.
+	if err := k.MaintenanceScheduledIndex.Set(goCtx, reservationID); err != nil {
+		return nil, fmt.Errorf("failed to index scheduled reservation: %w", err)
+	}
+
+	// Deduct credit
+	state.CreditBlocks -= msg.DurationBlocks
+	state.ScheduledReservationId = reservationID
+	if err := k.SetMaintenanceState(goCtx, state); err != nil {
+		return nil, err
+	}
+
+	// Add transition schedule entries for BeginBlock lifecycle.
+	// Window covers [startHeight, startHeight + durationBlocks - 1] inclusive,
+	// so the COMPLETE transition must fire at (startHeight + durationBlocks),
+	// the block AFTER the last covered block. Otherwise the reservation would
+	// be deactivated one block early and the effective active duration would
+	// be (DurationBlocks - 1).
+	activateType := uint32(types.MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_ACTIVATE)
+	completeType := uint32(types.MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_COMPLETE)
+	completeHeight := msg.StartHeight + int64(msg.DurationBlocks)
+
+	if err := k.SetMaintenanceTransition(goCtx, msg.StartHeight, reservationID, activateType); err != nil {
+		return nil, err
+	}
+	if err := k.SetMaintenanceTransition(goCtx, completeHeight, reservationID, completeType); err != nil {
+		return nil, err
+	}
+
+	k.LogInfo("Maintenance window scheduled",
+		types.Maintenance,
+		"reservation_id", reservationID,
+		"participant", msg.Participant,
+		"start_height", msg.StartHeight,
+		"duration_blocks", msg.DurationBlocks,
+	)
+
+	sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+		"maintenance_scheduled",
+		sdk.NewAttribute("reservation_id", fmt.Sprint(reservationID)),
+		sdk.NewAttribute("participant", msg.Participant),
+		sdk.NewAttribute("start_height", fmt.Sprint(msg.StartHeight)),
+		sdk.NewAttribute("duration_blocks", fmt.Sprint(msg.DurationBlocks)),
+	))
+
+	return &types.MsgScheduleMaintenanceResponse{ReservationId: reservationID}, nil
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_set_claim_recipients.go b/inference-chain/x/inference/keeper/msg_server_set_claim_recipients.go
new file mode 100644
index 0000000000..c190eec26c
--- /dev/null
+++ b/inference-chain/x/inference/keeper/msg_server_set_claim_recipients.go
@@ -0,0 +1,79 @@
+package keeper
+
+import (
+	"context"
+
+	errorsmod "cosmossdk.io/errors"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// SetClaimRecipients batch-configures per-epoch payout recipient overrides for
+// MsgClaimRewards. Must be signed by the participant's own (cold) key — this
+// message is intentionally NOT included in InferenceOperationKeyPerms so that
+// no authz grant is created for warm/operational keys.
+//
+// Each entry targets a future epoch. An empty recipient deletes the entry for
+// that epoch (reverting to the creator default). The whole batch is atomic:
+// any invalid entry rolls back the entire message.
+func (ms msgServer) SetClaimRecipients(goCtx context.Context, msg *types.MsgSetClaimRecipients) (*types.MsgSetClaimRecipientsResponse, error) {
+	if err := ms.CheckPermission(goCtx, msg, ParticipantPermission); err != nil {
+		return nil, err
+	}
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	creatorAddr, err := sdk.AccAddressFromBech32(msg.Creator)
+	if err != nil {
+		return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err)
+	}
+
+	currentEpoch, ok := ms.GetEffectiveEpochIndex(ctx)
+	if !ok {
+		return nil, errorsmod.Wrap(types.ErrCurrentEpochGroupNotFound, "effective epoch not set")
+	}
+
+	if len(msg.Entries) == 0 {
+		return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "entries must not be empty")
+	}
+
+	// Apply into a cache context so the whole batch is atomic: any failed
+	// entry rolls back every preceding write.
+	cacheCtx, writeFn := ctx.CacheContext()
+	for _, entry := range msg.Entries {
+		if err := ms.applyClaimRecipientEntry(cacheCtx, creatorAddr, entry, currentEpoch); err != nil {
+			return nil, err
+		}
+	}
+	writeFn()
+
+	return &types.MsgSetClaimRecipientsResponse{}, nil
+}
+
+// applyClaimRecipientEntry validates one batch entry against the lookahead
+// window and writes (or removes) the corresponding ClaimRecipients row.
+// Caller is expected to invoke this on a cache context so partial writes
+// roll back on the first error.
+func (ms msgServer) applyClaimRecipientEntry(
+	ctx sdk.Context,
+	creatorAddr sdk.AccAddress,
+	entry types.ClaimRecipientEntry,
+	currentEpoch uint64,
+) error {
+	if entry.Epoch <= currentEpoch {
+		return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "epoch %d is not in the future (current=%d)", entry.Epoch, currentEpoch)
+	}
+	if entry.Epoch > currentEpoch+MaxClaimRecipientLookahead {
+		return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "epoch %d exceeds max lookahead of %d from current epoch %d", entry.Epoch, MaxClaimRecipientLookahead, currentEpoch)
+	}
+	if entry.Recipient != "" {
+		if _, err := sdk.AccAddressFromBech32(entry.Recipient); err != nil {
+			return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid recipient for epoch %d: %s", entry.Epoch, err)
+		}
+	}
+
+	if entry.Recipient == "" {
+		return ms.RemoveClaimRecipientForEpoch(ctx, creatorAddr, entry.Epoch)
+	}
+	return ms.SetClaimRecipientForEpoch(ctx, creatorAddr, entry.Epoch, entry.Recipient)
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_set_claim_recipients_test.go b/inference-chain/x/inference/keeper/msg_server_set_claim_recipients_test.go
new file mode 100644
index 0000000000..14e8bc6aee
--- /dev/null
+++ b/inference-chain/x/inference/keeper/msg_server_set_claim_recipients_test.go
@@ -0,0 +1,231 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"cosmossdk.io/collections"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/testutil"
+	"github.com/productscience/inference/x/inference/keeper"
+	"github.com/productscience/inference/x/inference/types"
+	"github.com/stretchr/testify/require"
+)
+
+func setupSchedule(t testing.TB, currentEpoch uint64) (keeper.Keeper, types.MsgServer, sdk.Context, sdk.AccAddress) {
+	k, ms, ctx := setupMsgServer(t)
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, currentEpoch))
+	addr, err := sdk.AccAddressFromBech32(testutil.Creator)
+	require.NoError(t, err)
+	// Register the participant so ParticipantPermission passes in CheckPermission.
+	k.Participants.Set(ctx, addr, types.Participant{Index: testutil.Creator, Address: testutil.Creator, Status: types.ParticipantStatus_ACTIVE})
+	return k, ms, ctx, addr
+}
+
+func TestSetClaimRecipients_HappyPath(t *testing.T) {
+	k, ms, ctx, creatorAddr := setupSchedule(t, 100)
+	recipient := testutil.Executor
+
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{
+			{Epoch: 101, Recipient: recipient},
+			{Epoch: 105, Recipient: recipient},
+			{Epoch: 140, Recipient: recipient},
+		},
+	})
+	require.NoError(t, err)
+
+	for _, epoch := range []uint64{101, 105, 140} {
+		got, found, err := k.GetClaimRecipientForEpoch(ctx, creatorAddr, epoch)
+		require.NoError(t, err)
+		require.True(t, found, "epoch %d should be scheduled", epoch)
+		require.Equal(t, recipient, got)
+		hasIndex, err := k.ClaimRecipientsByEpoch.Has(ctx, collections.Join(epoch, creatorAddr))
+		require.NoError(t, err)
+		require.True(t, hasIndex, "epoch %d should be indexed", epoch)
+	}
+}
+
+func TestSetClaimRecipients_RejectsCurrentOrPastEpoch(t *testing.T) {
+	k, ms, ctx, creatorAddr := setupSchedule(t, 100)
+
+	// current epoch
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{{Epoch: 100, Recipient: testutil.Executor}},
+	})
+	require.Error(t, err)
+
+	// past epoch, mixed with future — full batch must roll back
+	_, err = ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{
+			{Epoch: 101, Recipient: testutil.Executor},
+			{Epoch: 50, Recipient: testutil.Executor2},
+		},
+	})
+	require.Error(t, err)
+
+	_, found, err := k.GetClaimRecipientForEpoch(ctx, creatorAddr, 101)
+	require.NoError(t, err)
+	require.False(t, found, "future entry in rejected batch must not persist")
+}
+
+func TestSetClaimRecipients_RejectsTooFarAhead(t *testing.T) {
+	_, ms, ctx, _ := setupSchedule(t, 100)
+
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{
+			{Epoch: 100 + keeper.MaxClaimRecipientLookahead + 1, Recipient: testutil.Executor},
+		},
+	})
+	require.Error(t, err)
+
+	// Exactly at the cap is allowed.
+	_, err = ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{
+			{Epoch: 100 + keeper.MaxClaimRecipientLookahead, Recipient: testutil.Executor},
+		},
+	})
+	require.NoError(t, err)
+}
+
+func TestSetClaimRecipients_RejectsInvalidRecipient(t *testing.T) {
+	k, ms, ctx, creatorAddr := setupSchedule(t, 100)
+
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{
+			{Epoch: 101, Recipient: testutil.Executor},
+			{Epoch: 102, Recipient: "not-a-bech32-address"},
+		},
+	})
+	require.Error(t, err)
+
+	_, found, err := k.GetClaimRecipientForEpoch(ctx, creatorAddr, 101)
+	require.NoError(t, err)
+	require.False(t, found, "valid entry in rejected batch must not persist")
+}
+
+func TestSetClaimRecipients_RejectsInvalidCreator(t *testing.T) {
+	_, ms, ctx, _ := setupSchedule(t, 100)
+
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: "not-a-bech32-address",
+		Entries: []types.ClaimRecipientEntry{{Epoch: 101, Recipient: testutil.Executor}},
+	})
+	require.Error(t, err)
+}
+
+func TestSetClaimRecipients_RejectsEmptyEntries(t *testing.T) {
+	_, ms, ctx, _ := setupSchedule(t, 100)
+
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: nil,
+	})
+	require.Error(t, err)
+}
+
+func TestSetClaimRecipients_EmptyRecipientDeletesEntry(t *testing.T) {
+	k, ms, ctx, creatorAddr := setupSchedule(t, 100)
+
+	// Seed an entry.
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{{Epoch: 101, Recipient: testutil.Executor}},
+	})
+	require.NoError(t, err)
+	_, found, err := k.GetClaimRecipientForEpoch(ctx, creatorAddr, 101)
+	require.NoError(t, err)
+	require.True(t, found)
+
+	// Now clear it with an empty recipient.
+	_, err = ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{{Epoch: 101, Recipient: ""}},
+	})
+	require.NoError(t, err)
+
+	_, found, err = k.GetClaimRecipientForEpoch(ctx, creatorAddr, 101)
+	require.NoError(t, err)
+	require.False(t, found)
+	hasIndex, err := k.ClaimRecipientsByEpoch.Has(ctx, collections.Join(uint64(101), creatorAddr))
+	require.NoError(t, err)
+	require.False(t, hasIndex)
+}
+
+func TestSetClaimRecipients_NoEffectiveEpoch(t *testing.T) {
+	_, ms, ctx := setupMsgServer(t)
+	// Intentionally skip SetEffectiveEpochIndex.
+
+	_, err := ms.SetClaimRecipients(ctx, &types.MsgSetClaimRecipients{
+		Creator: testutil.Creator,
+		Entries: []types.ClaimRecipientEntry{{Epoch: 1, Recipient: testutil.Executor}},
+	})
+	require.Error(t, err)
+}
+
+func TestGetClaimRecipientForEpoch(t *testing.T) {
+	k, _, ctx := setupMsgServer(t)
+	addr, err := sdk.AccAddressFromBech32(testutil.Creator)
+	require.NoError(t, err)
+
+	_, found, err := k.GetClaimRecipientForEpoch(ctx, addr, 42)
+	require.NoError(t, err)
+	require.False(t, found, "empty map returns not found")
+
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, addr, 42, testutil.Executor))
+	got, found, err := k.GetClaimRecipientForEpoch(ctx, addr, 42)
+	require.NoError(t, err)
+	require.True(t, found)
+	require.Equal(t, testutil.Executor, got)
+}
+
+func TestGetClaimRecipientsByParticipant(t *testing.T) {
+	k, _, ctx := setupMsgServer(t)
+	addr, err := sdk.AccAddressFromBech32(testutil.Creator)
+	require.NoError(t, err)
+
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, addr, 10, testutil.Executor))
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, addr, 20, testutil.Executor2))
+	// Entry for a different participant — must not leak into result.
+	otherAddr, err := sdk.AccAddressFromBech32(testutil.Executor)
+	require.NoError(t, err)
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, otherAddr, 15, testutil.Creator))
+
+	entries, err := k.GetClaimRecipientsByParticipant(ctx, addr)
+	require.NoError(t, err)
+	require.Len(t, entries, 2)
+	require.Equal(t, uint64(10), entries[0].Epoch)
+	require.Equal(t, testutil.Executor, entries[0].Recipient)
+	require.Equal(t, uint64(20), entries[1].Epoch)
+	require.Equal(t, testutil.Executor2, entries[1].Recipient)
+}
+
+func TestClaimRecipientPruningRemovesPrimaryAndIndex(t *testing.T) {
+	k, _, ctx, creatorAddr := setupSchedule(t, 100)
+	require.NoError(t, k.PruningState.Set(ctx, types.PruningState{}))
+
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, creatorAddr, 95, testutil.Executor))
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, creatorAddr, 96, testutil.Executor2))
+
+	require.NoError(t, k.Prune(ctx, 100))
+
+	_, found, err := k.GetClaimRecipientForEpoch(ctx, creatorAddr, 95)
+	require.NoError(t, err)
+	require.False(t, found)
+	hasIndex, err := k.ClaimRecipientsByEpoch.Has(ctx, collections.Join(uint64(95), creatorAddr))
+	require.NoError(t, err)
+	require.False(t, hasIndex)
+
+	got, found, err := k.GetClaimRecipientForEpoch(ctx, creatorAddr, 96)
+	require.NoError(t, err)
+	require.True(t, found)
+	require.Equal(t, testutil.Executor2, got)
+	hasIndex, err = k.ClaimRecipientsByEpoch.Has(ctx, collections.Join(uint64(96), creatorAddr))
+	require.NoError(t, err)
+	require.True(t, hasIndex)
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow.go b/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow.go
index 160b6bd9ab..312e015ecc 100644
--- a/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow.go
+++ b/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow.go
@@ -152,10 +152,6 @@ func (k msgServer) SettleDevshardEscrow(goCtx context.Context, msg *types.MsgSet
 		}
 		paidValidators[addr] = true
 
-		recipientAddr, err := sdk.AccAddressFromBech32(addr)
-		if err != nil {
-			return nil, fmt.Errorf("invalid validator address %s: %w", addr, err)
-		}
 		inCurrentEpoch := treatAsCurrentEpochSettle[addr]
 		if inCurrentEpoch {
 			participant, found := participantByAddr[addr]
@@ -167,6 +163,10 @@ func (k msgServer) SettleDevshardEscrow(goCtx context.Context, msg *types.MsgSet
 			}
 			touchedParticipants[addr] = true
 		} else {
+			recipientAddr, err := k.ResolveClaimRecipientAddress(goCtx, addr, escrow.EpochIndex)
+			if err != nil {
+				return nil, fmt.Errorf("failed to resolve validator recipient %s for epoch %d: %w", addr, escrow.EpochIndex, err)
+			}
 			if err := k.payCoinsDirectly(goCtx, payout, recipientAddr); err != nil {
 				return nil, err
 			}
diff --git a/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow_test.go b/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow_test.go
index aef02eb92a..38ef176edc 100644
--- a/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow_test.go
+++ b/inference-chain/x/inference/keeper/msg_server_settle_devshard_escrow_test.go
@@ -456,6 +456,61 @@ func TestSettleDevshardEscrow_PreviousEpochSettlementAllowedWithoutParticipantSt
 	}
 }
 
+func TestSettleDevshardEscrow_PreviousEpochSettlementUsesClaimRecipient(t *testing.T) {
+	k, ms, ctx, mocks := setupDevshardEscrowTest(t)
+	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
+
+	key, err := dcrdsecp.GeneratePrivateKey()
+	require.NoError(t, err)
+	participant := cosmosAddressFromDcrdKey(key)
+	recipient := sdk.AccAddress(make([]byte, 20))
+	recipient[0] = 0x44
+
+	keys := make([]*dcrdsecp.PrivateKey, keeper.DevshardGroupSize)
+	slots := make([]string, keeper.DevshardGroupSize)
+	for i := 0; i < keeper.DevshardGroupSize; i++ {
+		keys[i] = key
+		slots[i] = participant.String()
+	}
+	setParticipantForDevshardTest(t, k, ctx, participant.String())
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, 6))
+
+	creator := sdk.AccAddress(make([]byte, 20))
+	creator[0] = 0x33
+	escrow := types.DevshardEscrow{
+		Id:         1,
+		Creator:    creator.String(),
+		Amount:     7_000_000_000,
+		Slots:      slots,
+		EpochIndex: 5,
+		Settled:    false,
+	}
+	_, err = k.StoreDevshardEscrow(ctx, &escrow, 1)
+	require.NoError(t, err)
+	require.NoError(t, k.SetClaimRecipientForEpoch(ctx, participant, escrow.EpochIndex, recipient.String()))
+
+	costPerSlot := uint64(100_000_000)
+	msg := buildSettlementTestData(t, escrow, keys, makeHostStats(keeper.DevshardGroupSize, costPerSlot), 0)
+
+	expectedPayout, err := types.GetCoins(int64(uint64(keeper.DevshardGroupSize) * costPerSlot))
+	require.NoError(t, err)
+	mocks.BankKeeper.EXPECT().
+		SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, recipient, expectedPayout, gomock.Eq("devshard_escrow_payment")).
+		Return(nil)
+	expectedRefund := escrow.Amount - uint64(keeper.DevshardGroupSize)*costPerSlot
+	mocks.BankKeeper.EXPECT().
+		SendCoinsFromModuleToAccount(gomock.Any(), types.ModuleName, creator, gomock.Any(), gomock.Eq("devshard_escrow_refund")).
+		DoAndReturn(func(_ context.Context, _ string, _ sdk.AccAddress, coins sdk.Coins, _ string) error {
+			require.Len(t, coins, 1)
+			require.Equal(t, expectedRefund, coins[0].Amount.Uint64())
+			return nil
+		})
+
+	resp, err := ms.SettleDevshardEscrow(ctx, msg)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+}
+
 func TestSettleDevshardEscrow_PreviousEpochSettlementDoesNotRollIntoCurrentEpochActiveParticipants(t *testing.T) {
 	k, ms, ctx, mocks := setupDevshardEscrowTest(t)
 	sdk.GetConfig().SetBech32PrefixForAccount("gonka", "gonka")
diff --git a/inference-chain/x/inference/keeper/msg_server_start_inference.go b/inference-chain/x/inference/keeper/msg_server_start_inference.go
index 9a5685210a..602c3c1aa0 100644
--- a/inference-chain/x/inference/keeper/msg_server_start_inference.go
+++ b/inference-chain/x/inference/keeper/msg_server_start_inference.go
@@ -2,454 +2,27 @@ package keeper
 
 import (
 	"context"
-	"fmt"
-	"math"
-	"math/bits"
-	"time"
 
-	"encoding/base64"
-
-	sdkerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/productscience/inference/x/inference/calculations"
 	"github.com/productscience/inference/x/inference/types"
 )
 
 func (k msgServer) StartInference(goCtx context.Context, msg *types.MsgStartInference) (*types.MsgStartInferenceResponse, error) {
 	if err := k.CheckPermission(goCtx, msg, ActiveParticipantPermission); err != nil {
-		// return the failure and back out even batch transactions, since permissions will not change in a batch
 		return nil, err
 	}
 
-	ctx, err := k.Keeper.InjectParamsIntoContext(sdk.UnwrapSDKContext(goCtx))
-	if err != nil {
-		k.LogWarn("StartInference: failed to inject params", types.Inferences, "error", err)
-	}
-
-	k.LogInfo("StartInference", types.Inferences, "inferenceId", msg.InferenceId, "creator", msg.Creator, "requestedBy", msg.RequestedBy, "model", msg.Model)
-
-	// Developer access gating: before the cutoff height, only allowlisted developers may request inferences.
-	if k.IsDeveloperAccessRestricted(ctx, ctx.BlockHeight()) && !k.IsAllowedDeveloper(ctx, msg.RequestedBy) {
-		return failedStart(ctx, sdkerrors.Wrap(types.ErrDeveloperNotAllowlisted, msg.RequestedBy), msg), nil
-	}
-
-	// Transfer Agent access gating: only allowlisted TAs may submit StartInference.
-	if k.IsTransferAgentRestricted(ctx) && !k.IsAllowedTransferAgent(ctx, msg.Creator) {
-		k.LogError("StartInference: transfer agent is not allowlisted", types.Inferences,
-			"transferAgent", msg.Creator, "blockHeight", ctx.BlockHeight())
-		return failedStart(ctx, sdkerrors.Wrap(types.ErrTransferAgentNotAllowlisted, msg.Creator), msg), nil
-	}
-
-	if msg.MaxTokens > types.MaxAllowedTokens {
-		return failedStart(ctx, sdkerrors.Wrapf(types.ErrTokenCountOutOfRange, "max_tokens exceeds limit (%d > %d)", msg.MaxTokens, types.MaxAllowedTokens), msg), nil
-	}
-	if msg.PromptTokenCount > types.MaxAllowedTokens {
-		return failedStart(ctx, sdkerrors.Wrapf(types.ErrTokenCountOutOfRange, "prompt_token_count exceeds limit (%d > %d)", msg.PromptTokenCount, types.MaxAllowedTokens), msg), nil
-	}
-
-	transferAgent, found := k.GetParticipant(ctx, msg.Creator)
-	if !found {
-		k.LogError("Creator not found", types.Inferences, "creator", msg.Creator, "msg", "StartInference")
-		return failedStart(ctx, sdkerrors.Wrap(types.ErrParticipantNotFound, msg.Creator), msg), nil
-	}
-	devAddress := msg.RequestedBy
-	k.LogInfo("TransferAgentPubKey", types.Inferences, "TransferAgentPubKey", transferAgent.WorkerPublicKey, "TransferAgentAddress", transferAgent.Address)
-
-	existingInference, found := k.GetInference(ctx, msg.InferenceId)
-
-	if found && existingInference.StartProcessed() {
-		k.LogError("StartInference: inference already started", types.Inferences, "inferenceId", msg.InferenceId)
-		return failedStart(ctx, sdkerrors.Wrap(types.ErrInferenceStartProcessed, "inference has already start processed"), msg), nil
-	}
-
-	// Signature verification policy:
-	// - Start first: verify dev signature once; skip TA signature.
-	// - Finish first: start performs equality checks only (no TA/dev re-verification).
-	// - Executor signature verification is disabled by policy in both paths.
-	if existingInference.FinishedProcessed() {
-		if err := k.compareDevComponents(msg, &existingInference); err != nil {
-			k.LogError("StartInference: dev component mismatch", types.Inferences, "error", err, "inferenceId", msg.InferenceId)
-			return failedStart(ctx, err, msg), nil
-		}
-		if err := k.compareStartTAComponents(msg, &existingInference); err != nil {
-			k.LogError("StartInference: TA component mismatch", types.Inferences, "error", err, "inferenceId", msg.InferenceId)
-			return failedStart(ctx, err, msg), nil
-		}
-		if err := k.compareStartModelField(msg, &existingInference); err != nil {
-			k.LogError("StartInference: model field mismatch", types.Inferences, "error", err, "inferenceId", msg.InferenceId)
-			return failedStart(ctx, err, msg), nil
-		}
-		k.LogDebug("StartInference: cryptographic signature verification skipped; dev and TA components compared for consistency", types.Inferences, "inferenceId", msg.InferenceId)
-	} else {
-		err := k.verifyStartFirstMessageKeys(ctx, msg, devAddress)
-		if err != nil {
-			k.LogError("StartInference: verifyStartFirstMessageKeys failed", types.Inferences, "error", err)
-			return failedStart(ctx, sdkerrors.Wrap(types.ErrInvalidSignature, err.Error()), msg), nil
-		}
-		k.LogDebug("StartInference: dev signature cryptographically verified; TA signature deferred to FinishInference", types.Inferences, "inferenceId", msg.InferenceId)
-	}
-	k.LogDebug("StartInference: executor signature verification disabled by policy", types.Inferences, "inferenceId", msg.InferenceId)
-
-	// Record the current price only if this is the first message (FinishInference not processed yet)
-	// This ensures consistent pricing regardless of message arrival order
-	if !existingInference.FinishedProcessed() {
-		existingInference.Model = msg.Model
-		k.RecordInferencePrice(goCtx, &existingInference, msg.InferenceId)
-	}
-
-	blockContext := calculations.BlockContext{
-		BlockHeight:    ctx.BlockHeight(),
-		BlockTimestamp: ctx.BlockTime().UnixMilli(),
-	}
-
-	inference, payments, err := calculations.ProcessStartInference(&existingInference, msg, blockContext, k)
-	if err != nil {
-		return failedStart(ctx, err, msg), nil
-	}
-
-	var executor *types.Participant
-	if inference.ExecutedBy != "" {
-		executorValue, found := k.GetParticipant(ctx, inference.ExecutedBy)
-		if !found {
-			k.LogError("StartInference: executor not found", types.Inferences, "executed_by", inference.ExecutedBy, "inference_id", inference.InferenceId)
-			return failedStart(ctx, sdkerrors.Wrap(types.ErrParticipantNotFound, inference.ExecutedBy), msg), nil
-		}
-		executor = &executorValue
-	}
-
-	finalInference, err := k.processInferencePayments(ctx, inference, payments, false, executor)
-	if err != nil {
-		return failedStart(ctx, err, msg), nil
-	}
-
-	if finalInference.IsCompleted() {
-		k.handleInferenceCompleted(ctx, finalInference, executor)
-	}
-	if shouldPersistParticipant(finalInference, payments, executor) {
-		if err := k.SetParticipant(ctx, *executor); err != nil {
-			return failedStart(ctx, err, msg), nil
-		}
-	}
-	err = k.SetInference(ctx, *finalInference)
-	if err != nil {
-		return failedStart(ctx, err, msg), nil
-	}
-	k.addTimeout(ctx, finalInference)
-
-	return &types.MsgStartInferenceResponse{
-		InferenceIndex: msg.InferenceId,
-	}, nil
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	k.LogInfo("StartInference deprecated", types.Inferences, "inferenceId", msg.InferenceId, "creator", msg.Creator)
+	return failedStart(ctx, classicInferenceDeprecatedError(), msg), nil
 }
 
-func failedStart(ctx sdk.Context, error error, message *types.MsgStartInference) *types.MsgStartInferenceResponse {
+func failedStart(ctx sdk.Context, err error, msg *types.MsgStartInference) *types.MsgStartInferenceResponse {
 	ctx.EventManager().EmitEvent(
 		sdk.NewEvent("start_inference",
 			sdk.NewAttribute("result", "failed")))
 	return &types.MsgStartInferenceResponse{
-		InferenceIndex: message.InferenceId,
-		ErrorMessage:   error.Error(),
-	}
-}
-
-func (k msgServer) verifyStartFirstMessageKeys(ctx sdk.Context, msg *types.MsgStartInference, devAddress string) error {
-	devComponents := getDevSignatureComponents(msg)
-
-	if err := k.validateTimestamp(ctx, devComponents, msg.InferenceId, 60); err != nil {
-		return err
-	}
-
-	// Verify dev signature (original_prompt_hash)
-	if err := calculations.VerifyKeys(ctx, devComponents, calculations.SignatureData{
-		DevSignature: msg.InferenceId, Dev: devAddress,
-	}, k); err != nil {
-		k.LogError("StartInference: dev signature failed", types.Inferences, "error", err)
-		return err
-	}
-
-	return nil
-}
-
-type HasDevComponents interface {
-	GetOriginalPromptHash() string
-	GetRequestTimestamp() int64
-	GetRequestedBy() string
-	GetTransferredBy() string
-}
-
-func (k msgServer) compareDevComponents(msg HasDevComponents, inference *types.Inference) error {
-	if inference.OriginalPromptHash != msg.GetOriginalPromptHash() {
-		return sdkerrors.Wrapf(
-			types.ErrDevComponentMismatch,
-			"original_prompt_hash mismatch: message=%s inference=%s",
-			msg.GetOriginalPromptHash(),
-			inference.OriginalPromptHash,
-		)
-	}
-	if inference.RequestTimestamp != msg.GetRequestTimestamp() {
-		return sdkerrors.Wrapf(
-			types.ErrDevComponentMismatch,
-			"request_timestamp mismatch: message=%d inference=%d",
-			msg.GetRequestTimestamp(),
-			inference.RequestTimestamp,
-		)
-	}
-	if inference.TransferredBy != msg.GetTransferredBy() {
-		return sdkerrors.Wrapf(
-			types.ErrDevComponentMismatch,
-			"transfer agent mismatch: message=%s inference=%s",
-			msg.GetTransferredBy(),
-			inference.TransferredBy,
-		)
-	}
-	if inference.RequestedBy != msg.GetRequestedBy() {
-		return sdkerrors.Wrapf(
-			types.ErrDevComponentMismatch,
-			"requested_by mismatch: message=%s inference=%s",
-			msg.GetRequestedBy(),
-			inference.RequestedBy,
-		)
-	}
-	return nil
-}
-
-// TODO: We need to include inferenceId in the TA signature to make sure executor can't substitute the modified prompt
-// TODO: any error here should lead to punishing the TA
-func (k msgServer) compareStartTAComponents(msg *types.MsgStartInference, inference *types.Inference) error {
-	if inference.PromptHash != msg.PromptHash {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"prompt_hash mismatch: start=%s finish=%s",
-			msg.PromptHash,
-			inference.PromptHash,
-		)
-	}
-	if inference.RequestTimestamp != msg.RequestTimestamp {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"request_timestamp mismatch: start=%d finish=%d",
-			msg.RequestTimestamp,
-			inference.RequestTimestamp,
-		)
-	}
-	if inference.TransferredBy != msg.Creator {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"transfer agent mismatch: start=%s finish=%s",
-			msg.Creator,
-			inference.TransferredBy,
-		)
-	}
-	if inference.ExecutedBy != msg.AssignedTo {
-		return sdkerrors.Wrapf(
-			types.ErrTAComponentMismatch,
-			"executor mismatch: start.assigned_to=%s finish.executed_by=%s",
-			msg.AssignedTo,
-			inference.ExecutedBy,
-		)
-	}
-	return nil
-}
-
-func (k msgServer) compareStartModelField(msg *types.MsgStartInference, inference *types.Inference) error {
-	if inference.Model != "" && inference.Model != msg.Model {
-		return sdkerrors.Wrapf(
-			types.ErrInferenceRoleMismatch,
-			"model mismatch: start=%s finish=%s",
-			msg.Model,
-			inference.Model,
-		)
-	}
-	return nil
-}
-
-func (k msgServer) validateTimestamp(
-	ctx sdk.Context,
-	components calculations.SignatureComponents,
-	inferenceId string,
-	extraSeconds int64,
-) error {
-	params, err := k.GetParams(ctx)
-	if err != nil {
-		k.LogError("StartInference: validateTimestamp failed to get params", types.Inferences, "error", err)
-		return err
-	}
-	k.LogInfo("Validating timestamp for StartInference:", types.Inferences,
-		"timestamp", components.Timestamp,
-		"inferenceId", inferenceId,
-		"currentBlockTime", ctx.BlockTime().UnixNano(),
-		"timestampExpiration", params.ValidationParams.TimestampExpiration,
-		"timestampAdvance", params.ValidationParams.TimestampAdvance,
-	)
-	err = calculations.ValidateTimestamp(
-		components.Timestamp,
-		ctx.BlockTime().UnixNano(),
-		params.ValidationParams.TimestampExpiration,
-		params.ValidationParams.TimestampAdvance,
-		// signature dedupe (via inferenceID) will prevent most replay, this is for
-		// replay attacks of pruned inferences only
-		extraSeconds*int64(time.Second),
-	)
-	if err != nil {
-		k.LogError("StartInference: validateTimestamp failed", types.Inferences, "error", err)
-		return err
-	}
-	return nil
-}
-
-func (k msgServer) addTimeout(ctx sdk.Context, inference *types.Inference) {
-	params, err := k.GetParams(ctx)
-	if err != nil {
-		k.LogError("Unable to get params for inference timeout", types.Inferences, "error", err)
-		return
-	}
-	expirationBlocks := params.ValidationParams.ExpirationBlocks
-	expirationHeight := uint64(inference.StartBlockHeight + expirationBlocks)
-	err = k.SetInferenceTimeout(ctx, types.InferenceTimeout{
-		ExpirationHeight: expirationHeight,
-		InferenceId:      inference.InferenceId,
-	})
-
-	if err != nil {
-		// Not fatal, we try to continue
-		k.LogError("Unable to set inference timeout", types.Inferences, err)
-	}
-
-	k.LogInfo("Inference Timeout Set:", types.Inferences,
-		"InferenceId", inference.InferenceId,
-		"ExpirationHeight", inference.StartBlockHeight+expirationBlocks)
-}
-
-func (k msgServer) processInferencePayments(
-	ctx sdk.Context,
-	inference *types.Inference,
-	payments *calculations.Payments,
-	allowRefund bool,
-	executor *types.Participant,
-) (*types.Inference, error) {
-	if payments.EscrowAmount > 0 {
-		escrowAmount, err := k.PutPaymentInEscrow(ctx, inference, payments.EscrowAmount)
-		if err != nil {
-			return nil, err
-		}
-		inference.EscrowAmount = escrowAmount
-	}
-	if payments.EscrowAmount < 0 {
-		if !allowRefund {
-			return nil, sdkerrors.Wrapf(types.ErrInvalidEscrowAmount, "escrow amount cannot be negative here: %d", payments.EscrowAmount)
-		}
-		err := k.IssueRefund(ctx, -payments.EscrowAmount, inference.RequestedBy, "inference_refund:"+inference.InferenceId)
-		if err != nil {
-			k.LogError("Unable to Issue Refund for started inference", types.Payments,
-				"error", err, "inferenceId", inference.InferenceId)
-			return nil, sdkerrors.Wrapf(types.ErrIllegalState, "refund failed for inference %s: %v", inference.InferenceId, err)
-		}
-	}
-	if payments.ExecutorPayment > 0 {
-		err := k.AddToCoinBalance(ctx, executor, uint64(payments.ExecutorPayment), "inference_finished")
-		if err != nil {
-			return nil, err
-		}
-	}
-	return inference, nil
-}
-
-// AddToCoinBalance adds payout to the participant's claimable work balance and
-// current-epoch earned coins, with overflow protection for both fields.
-func (k Keeper) AddToCoinBalance(ctx context.Context, participant *types.Participant, payout uint64, memo string) error {
-	if participant == nil {
-		return sdkerrors.Wrap(types.ErrParticipantNotFound, "nil participant")
-	}
-	if payout > math.MaxInt64 {
-		return sdkerrors.Wrap(types.ErrIntOverflowSettleAmount, "payout exceeds maximum integer value")
-	}
-	ensureParticipantEpochStats(participant)
-	nextCoinBalance := participant.CoinBalance + int64(payout)
-	if nextCoinBalance < participant.CoinBalance {
-		return fmt.Errorf("participant coin balance overflow for %s", participant.Address)
-	}
-	nextEarnedCoins, carry := bits.Add64(participant.CurrentEpochStats.EarnedCoins, payout, 0)
-	if carry != 0 {
-		return fmt.Errorf("participant earned coins overflow for %s", participant.Address)
-	}
-	participant.CoinBalance = nextCoinBalance
-	participant.CurrentEpochStats.EarnedCoins = nextEarnedCoins
-	k.SafeLogSubAccountTransaction(ctx, participant.Address, types.ModuleName, types.OwedSubAccount, participant.CoinBalance, memo)
-	return nil
-}
-
-func shouldPersistParticipant(inference *types.Inference, payments *calculations.Payments, executor *types.Participant) bool {
-	if inference == nil || payments == nil || executor == nil {
-		return false
-	}
-	return inference.IsCompleted() || payments.ExecutorPayment > 0
-}
-
-func ensureParticipantEpochStats(participant *types.Participant) {
-	if participant == nil {
-		return
-	}
-	if participant.CurrentEpochStats == nil {
-		participant.CurrentEpochStats = &types.CurrentEpochStats{}
-	}
-}
-
-// getDevSignatureComponents returns components for dev signature verification
-// Dev signs: original_prompt_hash + timestamp + ta_address (no executor)
-func getDevSignatureComponents(msg *types.MsgStartInference) calculations.SignatureComponents {
-	return calculations.SignatureComponents{
-		Payload:         msg.OriginalPromptHash,
-		Timestamp:       msg.RequestTimestamp,
-		TransferAddress: msg.Creator,
-		ExecutorAddress: "", // Dev doesn't include executor address
-	}
-}
-
-// getTASignatureComponents returns components for TA signature verification
-// TA signs: prompt_hash + timestamp + ta_address + executor_address
-func getTASignatureComponents(msg *types.MsgStartInference) calculations.SignatureComponents {
-	return calculations.SignatureComponents{
-		Payload:         msg.PromptHash,
-		Timestamp:       msg.RequestTimestamp,
-		TransferAddress: msg.Creator,
-		ExecutorAddress: msg.AssignedTo,
-	}
-}
-
-func (k msgServer) GetAccountPubKey(ctx context.Context, address string) (string, error) {
-	addr, err := sdk.AccAddressFromBech32(address)
-	if err != nil {
-		k.LogError("getAccountPubKey: Invalid address", types.Participants, "address", address, "error", err)
-		return "", err
-	}
-	acc := k.AccountKeeper.GetAccount(ctx, addr)
-	if acc == nil {
-		k.LogError("getAccountPubKey: Account not found", types.Participants, "address", address)
-		return "", sdkerrors.Wrap(types.ErrParticipantNotFound, address)
-	}
-	// Not all accounts are guaranteed to have a pubkey
-	if acc.GetPubKey() == nil {
-		k.LogError("getAccountPubKey: Account has no pubkey", types.Participants, "address", address)
-		return "", types.ErrPubKeyUnavailable
-	}
-	return base64.StdEncoding.EncodeToString(acc.GetPubKey().Bytes()), nil
-}
-
-func (k msgServer) GetAccountPubKeysWithGrantees(ctx context.Context, granterAddress string) ([]string, error) {
-	grantees, err := k.GranteesByMessageType(ctx, &types.QueryGranteesByMessageTypeRequest{
-		GranterAddress: granterAddress,
-		MessageTypeUrl: "/inference.inference.MsgStartInference",
-	})
-	if err != nil {
-		return nil, err
-	}
-	pubKeys := make([]string, len(grantees.Grantees)+1)
-	for i, grantee := range grantees.Grantees {
-		pubKeys[i] = grantee.PubKey
-	}
-	granterPubKey, err := k.GetAccountPubKey(ctx, granterAddress)
-	if err != nil {
-		return nil, err
+		InferenceIndex: msg.InferenceId,
+		ErrorMessage:   err.Error(),
 	}
-	pubKeys[len(pubKeys)-1] = granterPubKey
-	return pubKeys, nil
 }
diff --git a/inference-chain/x/inference/keeper/msg_server_start_inference_test.go b/inference-chain/x/inference/keeper/msg_server_start_inference_test.go
deleted file mode 100644
index 5e152b0d97..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_start_inference_test.go
+++ /dev/null
@@ -1,189 +0,0 @@
-package keeper_test
-
-import (
-	"testing"
-
-	"github.com/productscience/inference/testutil"
-	"github.com/productscience/inference/x/inference/calculations"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/productscience/inference/x/inference/types"
-)
-
-func TestMsgServer_StartInferenceWithUnregesteredParticipant(t *testing.T) {
-	k, ms, ctx := setupMsgServer(t)
-	_ = k.SetEffectiveEpochIndex(ctx, 1)
-	_ = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: 1,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: testutil.Creator,
-			},
-		},
-	})
-	response, err := ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:   "inferenceId",
-		PromptHash:    "promptHash",
-		PromptPayload: "promptPayload",
-		RequestedBy:   testutil.Requester,
-		Creator:       testutil.Creator,
-	})
-	require.NoError(t, err)
-	require.NotEmpty(t, response.ErrorMessage)
-}
-
-func TestMsgServer_StartInference_DeveloperNotAllowlisted(t *testing.T) {
-	k, ms, ctx := setupMsgServer(t)
-	_ = k.SetEffectiveEpochIndex(ctx, 1)
-	_ = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: 1,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: testutil.Creator,
-			},
-		},
-	})
-	_ = k.SetModelCurrentPrice(ctx, "", calculations.PerTokenCost)
-
-	// Enable gating at current height + 100, with an allowlist that does NOT include testutil.Requester.
-	p, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	p.DeveloperAccessParams = &types.DeveloperAccessParams{
-		UntilBlockHeight:          ctx.BlockHeight() + 100,
-		AllowedDeveloperAddresses: []string{"gonka1notallowlistedxxxxxxxxxxxxxxxxxxxxxx"},
-	}
-	require.NoError(t, k.SetParams(ctx, p))
-
-	response, err := ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:   "inferenceId",
-		PromptHash:    "promptHash",
-		PromptPayload: "promptPayload",
-		RequestedBy:   testutil.Requester,
-		Creator:       testutil.Creator,
-	})
-	require.NoError(t, err)
-	require.NotEmpty(t, response.ErrorMessage)
-}
-
-func TestMsgServer_StartInference(t *testing.T) {
-	const (
-		epochId = 1
-	)
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	requestTimestamp := inferenceHelper.context.BlockTime().UnixNano()
-	initialBlockHeight := int64(10)
-	ctx, err := advanceEpoch(ctx, &k, inferenceHelper.Mocks, initialBlockHeight, epochId)
-	if err != nil {
-		t.Fatalf("Failed to advance epoch: %v", err)
-	}
-	require.Equal(t, initialBlockHeight, ctx.BlockHeight())
-
-	expected, err := inferenceHelper.StartInference("promptPayload", "model1", requestTimestamp,
-		calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	savedInference, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, expected, &savedInference)
-	_, found = k.GetDevelopersStatsByEpoch(ctx, testutil.Requester, epochId)
-	require.False(t, found)
-}
-
-func TestMsgServer_StartInferenceWithMaxTokens(t *testing.T) {
-	const (
-		epochId = 1
-	)
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	requestTimestamp := inferenceHelper.context.BlockTime().UnixNano()
-	initialBlockHeight := int64(10)
-	ctx, err := advanceEpoch(ctx, &k, inferenceHelper.Mocks, initialBlockHeight, epochId)
-	if err != nil {
-		t.Fatalf("Failed to advance epoch: %v", err)
-	}
-	require.Equal(t, initialBlockHeight, ctx.BlockHeight())
-
-	expected, err := inferenceHelper.StartInference("promptPayload", "model1", requestTimestamp,
-		2000) // Using a custom max tokens value
-	require.NoError(t, err)
-	savedInference, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, expected, &savedInference)
-	_, found = k.GetDevelopersStatsByEpoch(ctx, testutil.Requester, epochId)
-	require.False(t, found)
-}
-
-func TestMsgServer_StartInference_DoesNotUpdateExecutorBeforeCompletion(t *testing.T) {
-	inferenceHelper, k, _ := NewMockInferenceHelper(t)
-	requestTimestamp := inferenceHelper.context.BlockTime().UnixNano()
-
-	beforeExecutor, found := k.GetParticipant(inferenceHelper.context, testutil.Executor)
-	require.True(t, found)
-	if beforeExecutor.CurrentEpochStats == nil {
-		beforeExecutor.CurrentEpochStats = &types.CurrentEpochStats{}
-	}
-	beforeEarned := beforeExecutor.CurrentEpochStats.EarnedCoins
-	beforeInferenceCount := beforeExecutor.CurrentEpochStats.InferenceCount
-
-	_, err := inferenceHelper.StartInference("promptPayload", "model1", requestTimestamp, calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-
-	afterExecutor, found := k.GetParticipant(inferenceHelper.context, testutil.Executor)
-	require.True(t, found)
-	require.NotNil(t, afterExecutor.CurrentEpochStats)
-	require.Equal(t, beforeEarned, afterExecutor.CurrentEpochStats.EarnedCoins)
-	require.Equal(t, beforeInferenceCount, afterExecutor.CurrentEpochStats.InferenceCount)
-}
-
-func TestMsgServer_StartInference_ParamsCacheDoesNotLeakAcrossCalls(t *testing.T) {
-	k, ms, ctx := setupMsgServer(t)
-
-	err := k.SetEffectiveEpochIndex(ctx, 1)
-	require.NoError(t, err)
-	err = k.SetActiveParticipants(ctx, types.ActiveParticipants{
-		EpochId: 1,
-		Participants: []*types.ActiveParticipant{
-			{
-				Index: testutil.Creator,
-			},
-		},
-	})
-	require.NoError(t, err)
-
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	params.DeveloperAccessParams = &types.DeveloperAccessParams{
-		UntilBlockHeight:          ctx.BlockHeight() + 100,
-		AllowedDeveloperAddresses: []string{testutil.Requester},
-	}
-	require.NoError(t, k.SetParams(ctx, params))
-
-	firstResp, err := ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:   "cache-test-1",
-		PromptHash:    "promptHash",
-		PromptPayload: "promptPayload",
-		RequestedBy:   testutil.Requester,
-		Creator:       testutil.Creator,
-	})
-	require.NoError(t, err)
-	require.NotContains(t, firstResp.ErrorMessage, types.ErrDeveloperNotAllowlisted.Error())
-	require.Contains(t, firstResp.ErrorMessage, types.ErrParticipantNotFound.Error())
-
-	params.DeveloperAccessParams = &types.DeveloperAccessParams{
-		UntilBlockHeight:          ctx.BlockHeight() + 100,
-		AllowedDeveloperAddresses: []string{"gonka1notallowlistedxxxxxxxxxxxxxxxxxxxxxx"},
-	}
-	require.NoError(t, k.SetParams(ctx, params))
-
-	secondResp, err := ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:   "cache-test-2",
-		PromptHash:    "promptHash",
-		PromptPayload: "promptPayload",
-		RequestedBy:   testutil.Requester,
-		Creator:       testutil.Creator,
-	})
-	require.NoError(t, err)
-	require.Contains(t, secondResp.ErrorMessage, types.ErrDeveloperNotAllowlisted.Error())
-}
-
-// TODO: Need a way to test that blockheight is set to newer values, but can't figure out how to change the
-// test value of the blockheight
diff --git a/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff.go b/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff.go
index 013e0dc40b..cc58817f10 100644
--- a/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff.go
+++ b/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff.go
@@ -71,6 +71,17 @@ func (k msgServer) SubmitHardwareDiff(goCtx context.Context, msg *types.MsgSubmi
 		return strings.Compare(a.LocalId, b.LocalId)
 	})
 
+	// Skip the write when the resulting node set is operationally identical
+	// to what's already stored. Catches the chatty-DAPI case where the same
+	// diff fires every block. NOT a security control — a malicious sender
+	// can defeat this by flipping any compared field. The point is to stop
+	// honest no-op spam, not to rate-limit.
+	if HardwareNodesUnchanged(updatedNodes.HardwareNodes, existingNodes.HardwareNodes) {
+		k.LogDebug("SubmitHardwareDiff no-op: skipping write", types.Nodes,
+			"participant", msg.Creator, "nodeCount", len(updatedNodes.HardwareNodes))
+		return &types.MsgSubmitHardwareDiffResponse{}, nil
+	}
+
 	k.LogInfo("Updating hardware nodes", types.Nodes, "nodes", updatedNodes)
 	if err := k.SetHardwareNodes(ctx, updatedNodes); err != nil {
 		k.LogError("Error setting hardware nodes", types.Nodes, "err", err)
@@ -79,3 +90,55 @@ func (k msgServer) SubmitHardwareDiff(goCtx context.Context, msg *types.MsgSubmi
 
 	return &types.MsgSubmitHardwareDiffResponse{}, nil
 }
+
+// HardwareNodesUnchanged reports whether two sorted hardware-node lists are
+// equivalent in their *operational* fields: local_id, status, models,
+// hardware, host, port. The Version field is excluded because it's
+// explicitly informational (see hardware_node.proto) and a flapping value
+// shouldn't trigger spurious writes.
+//
+// This is a best-effort idempotency check, not a security boundary. A
+// caller that wants to bypass it can flip any operational field.
+// Exported for testing.
+func HardwareNodesUnchanged(after, before []*types.HardwareNode) bool {
+	if len(after) != len(before) {
+		return false
+	}
+	for i := range after {
+		if !hardwareNodeOperationalEqual(after[i], before[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// hardwareNodeOperationalEqual compares the load-bearing fields of two
+// HardwareNode protos. Add to this list if hardware_node.proto adds new
+// state-affecting fields.
+func hardwareNodeOperationalEqual(a, b *types.HardwareNode) bool {
+	if a == b {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	if a.LocalId != b.LocalId ||
+		a.Status != b.Status ||
+		a.Host != b.Host ||
+		a.Port != b.Port {
+		return false
+	}
+	if !slices.Equal(a.Models, b.Models) {
+		return false
+	}
+	if len(a.Hardware) != len(b.Hardware) {
+		return false
+	}
+	for i := range a.Hardware {
+		if a.Hardware[i].Type != b.Hardware[i].Type ||
+			a.Hardware[i].Count != b.Hardware[i].Count {
+			return false
+		}
+	}
+	return true
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff_test.go b/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff_test.go
index 8ff5c1734e..bf1e78ae3a 100644
--- a/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff_test.go
+++ b/inference-chain/x/inference/keeper/msg_server_submit_hardware_diff_test.go
@@ -217,3 +217,121 @@ func TestMsgServer_SubmitHardwareDiff_RemoveAll(t *testing.T) {
 	require.True(t, found)
 	require.Equal(t, 0, len(hardwareNodes.HardwareNodes))
 }
+
+// TestHardwareNodesUnchanged is a focused unit test for the helper that
+// gates the SubmitHardwareDiff no-op skip. Compares operational fields
+// only — see hardwareNodeOperationalEqual — so flapping informational
+// fields like Version don't trigger spurious writes.
+func TestHardwareNodesUnchanged(t *testing.T) {
+	n1 := &types.HardwareNode{LocalId: "n1", Status: types.HardwareNodeStatus_INFERENCE}
+	n2 := &types.HardwareNode{LocalId: "n2", Status: types.HardwareNodeStatus_POC,
+		Models: []string{"model1"}, Host: "h", Port: "8080",
+		Hardware: []*types.Hardware{{Type: "GPU", Count: 2}}}
+
+	// Both empty: equal.
+	require.True(t, keeper.HardwareNodesUnchanged(nil, nil))
+	require.True(t, keeper.HardwareNodesUnchanged([]*types.HardwareNode{}, []*types.HardwareNode{}))
+
+	// Identical content, identical order.
+	require.True(t, keeper.HardwareNodesUnchanged(
+		[]*types.HardwareNode{n1, n2}, []*types.HardwareNode{n1, n2}))
+
+	// Different lengths.
+	require.False(t, keeper.HardwareNodesUnchanged(
+		[]*types.HardwareNode{n1}, []*types.HardwareNode{n1, n2}))
+
+	// Operational field differs: detected.
+	n2DiffStatus := &types.HardwareNode{LocalId: "n2", Status: types.HardwareNodeStatus_INFERENCE,
+		Models: n2.Models, Host: n2.Host, Port: n2.Port, Hardware: n2.Hardware}
+	require.False(t, keeper.HardwareNodesUnchanged(
+		[]*types.HardwareNode{n1, n2DiffStatus}, []*types.HardwareNode{n1, n2}))
+
+	// Models reordered: detected (slices.Equal is positional).
+	n2DiffModels := &types.HardwareNode{LocalId: "n2", Status: n2.Status,
+		Models: []string{"model2"}, Host: n2.Host, Port: n2.Port, Hardware: n2.Hardware}
+	require.False(t, keeper.HardwareNodesUnchanged(
+		[]*types.HardwareNode{n1, n2DiffModels}, []*types.HardwareNode{n1, n2}))
+
+	// Hardware count differs: detected.
+	n2DiffHW := &types.HardwareNode{LocalId: "n2", Status: n2.Status,
+		Models: n2.Models, Host: n2.Host, Port: n2.Port,
+		Hardware: []*types.Hardware{{Type: "GPU", Count: 4}}}
+	require.False(t, keeper.HardwareNodesUnchanged(
+		[]*types.HardwareNode{n1, n2DiffHW}, []*types.HardwareNode{n1, n2}))
+
+	// Version differs but everything else identical: NOT detected (the
+	// version field is informational only — flipping it shouldn't defeat
+	// the no-op check).
+	n2VerA := &types.HardwareNode{LocalId: "n2", Status: n2.Status,
+		Models: n2.Models, Host: n2.Host, Port: n2.Port, Hardware: n2.Hardware,
+		Version: "v1"}
+	n2VerB := &types.HardwareNode{LocalId: "n2", Status: n2.Status,
+		Models: n2.Models, Host: n2.Host, Port: n2.Port, Hardware: n2.Hardware,
+		Version: "v2"}
+	require.True(t, keeper.HardwareNodesUnchanged(
+		[]*types.HardwareNode{n1, n2VerA}, []*types.HardwareNode{n1, n2VerB}),
+		"flapping the informational Version field should NOT count as a change")
+}
+
+// TestMsgServer_SubmitHardwareDiff_IdempotentOnNoChange exercises the
+// happy path of the no-op skip end-to-end: a participant submits a diff
+// once, then submits an identical (no-op) diff. Both calls succeed and
+// the stored state matches the original write.
+//
+// We can't directly assert "SetHardwareNodes was not called the second
+// time" without a keeper spy, so this test pairs with TestHardwareNodesUnchanged
+// (unit-level) for full coverage.
+func TestMsgServer_SubmitHardwareDiff_IdempotentOnNoChange(t *testing.T) {
+	k, ms, ctx := setupMsgServer(t)
+
+	mockCreator := NewMockAccount(testutil.Creator)
+	MustAddParticipant(t, ms, ctx, *mockCreator)
+	registerTestModels(t, k, ms, ctx, "model1")
+
+	node := &types.HardwareNode{
+		LocalId:  "node1",
+		Status:   types.HardwareNodeStatus_INFERENCE,
+		Models:   []string{"model1"},
+		Hardware: []*types.Hardware{{Type: "GPU", Count: 1}},
+		Host:     "localhost",
+		Port:     "8080",
+	}
+
+	// First submit: writes the node.
+	_, err := ms.SubmitHardwareDiff(ctx, &types.MsgSubmitHardwareDiff{
+		Creator:       testutil.Creator,
+		NewOrModified: []*types.HardwareNode{node},
+	})
+	require.NoError(t, err)
+
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	got, found := k.GetHardwareNodes(sdkCtx, testutil.Creator)
+	require.True(t, found)
+	require.Equal(t, 1, len(got.HardwareNodes))
+
+	// Second submit with the identical node: no-op path. Must still succeed
+	// and leave state untouched.
+	_, err = ms.SubmitHardwareDiff(ctx, &types.MsgSubmitHardwareDiff{
+		Creator:       testutil.Creator,
+		NewOrModified: []*types.HardwareNode{node},
+	})
+	require.NoError(t, err)
+
+	gotAgain, found := k.GetHardwareNodes(sdkCtx, testutil.Creator)
+	require.True(t, found)
+	require.Equal(t, 1, len(gotAgain.HardwareNodes))
+	require.Equal(t, got.HardwareNodes[0].LocalId, gotAgain.HardwareNodes[0].LocalId)
+	require.Equal(t, got.HardwareNodes[0].Status, gotAgain.HardwareNodes[0].Status)
+
+	// Empty diff (no add, no remove) is also a no-op.
+	_, err = ms.SubmitHardwareDiff(ctx, &types.MsgSubmitHardwareDiff{
+		Creator:       testutil.Creator,
+		NewOrModified: []*types.HardwareNode{},
+		Removed:       []*types.HardwareNode{},
+	})
+	require.NoError(t, err)
+
+	stillThere, found := k.GetHardwareNodes(sdkCtx, testutil.Creator)
+	require.True(t, found)
+	require.Equal(t, 1, len(stillThere.HardwareNodes))
+}
diff --git a/inference-chain/x/inference/keeper/msg_server_validation.go b/inference-chain/x/inference/keeper/msg_server_validation.go
index 2410ebcc6c..7bb0ffee42 100644
--- a/inference-chain/x/inference/keeper/msg_server_validation.go
+++ b/inference-chain/x/inference/keeper/msg_server_validation.go
@@ -2,18 +2,8 @@ package keeper
 
 import (
 	"context"
-	"strconv"
 
-	"cosmossdk.io/collections"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/group"
-	"github.com/productscience/inference/x/inference/calculations"
 	"github.com/productscience/inference/x/inference/types"
-	"github.com/shopspring/decimal"
-)
-
-const (
-	TokenCost = 1_000
 )
 
 func (k msgServer) Validation(goCtx context.Context, msg *types.MsgValidation) (*types.MsgValidationResponse, error) {
@@ -21,488 +11,6 @@ func (k msgServer) Validation(goCtx context.Context, msg *types.MsgValidation) (
 		return nil, err
 	}
 
-	ctx, err := k.Keeper.InjectParamsIntoContext(sdk.UnwrapSDKContext(goCtx))
-	if err != nil {
-		k.LogWarn("Validation: failed to inject params", types.Validation, "error", err)
-	}
-
-	k.LogInfo("Received MsgValidation", types.Validation,
-		"msg.Creator", msg.Creator,
-		"inferenceId", msg.InferenceId)
-
-	if msg.ResponsePayload != "" {
-		return nil, types.ErrValidationPayloadDeprecated
-	}
-
-	creator, found := k.GetParticipant(ctx, msg.Creator)
-	if !found {
-		return nil, types.ErrParticipantNotFound
-	}
-	inference, found := k.GetInference(ctx, msg.InferenceId)
-	if !found {
-		k.LogError("Inference not found", types.Validation, "inferenceId", msg.InferenceId)
-		return nil, types.ErrInferenceNotFound
-	}
-
-	currentEpochIndex, found := k.GetEffectiveEpochIndex(ctx)
-	if !found {
-		k.LogError("Failed to get current epoch", types.Validation)
-		return nil, types.ErrEffectiveEpochNotFound
-	}
-
-	// Ignore stale validations that arrive later than one epoch after inference epoch.
-	if currentEpochIndex > inference.EpochId+1 {
-		k.LogWarn(
-			"Ignoring stale validation from old epoch",
-			types.Validation,
-			"inferenceId", inference.InferenceId,
-			"inferenceEpoch", inference.EpochId,
-			"currentEpoch", currentEpochIndex,
-		)
-		return &types.MsgValidationResponse{}, nil
-	}
-
-	if !msg.Revalidation {
-		err := k.addInferenceToEpochGroupValidations(ctx, msg, inference)
-		if err != nil {
-			k.LogError("Failed to add inference to epoch group validations", types.Validation, "inferenceId", msg.InferenceId, "error", err)
-			return nil, err
-		}
-	}
-
-	if inference.Status == types.InferenceStatus_INVALIDATED {
-		k.LogInfo("Inference already invalidated", types.Validation, "inference", inference)
-		return &types.MsgValidationResponse{}, nil
-	}
-	if inference.Status == types.InferenceStatus_STARTED {
-		k.LogError("Inference not finished", types.Validation, "status", inference.Status, "inference", inference)
-		return nil, types.ErrInferenceNotFinished
-	}
-	previousStatus := inference.Status
-
-	executor, found := k.GetParticipant(ctx, inference.ExecutedBy)
-	if !found {
-		k.LogError("Executor participant not found", types.Validation, "participantId", inference.ExecutedBy)
-		return nil, types.ErrParticipantNotFound
-	}
-
-	if executor.Address == msg.Creator && !msg.Revalidation {
-		k.LogError("Participant cannot validate own inference", types.Validation, "participant", msg.Creator, "inferenceId", msg.InferenceId)
-		return nil, types.ErrParticipantCannotValidateOwnInference
-	}
-
-	if inference.EpochId != currentEpochIndex {
-		k.LogInfo("Validation for different epoch", types.Validation, "inferenceEpoch", inference.EpochId, "currentEpochIndex", currentEpochIndex)
-	}
-
-	var (
-		modelThreshold      *types.Decimal
-		participantWeight   int64
-		participantRepution int32
-		totalWeight         int64
-		modelEpochPolicy    string
-	)
-	cachedModelMeta, cacheFound, cacheErr := k.GetCachedEpochDataModelMeta(ctx, inference.EpochId, inference.Model)
-	if cacheErr != nil {
-		k.LogError("Validation: failed to load transient validation cache entry", types.Validation, "error", cacheErr, "model", inference.Model, "epochIndex", inference.EpochId)
-		return nil, cacheErr
-	}
-	if !cacheFound {
-		k.LogError("Validation: transient validation cache entry not found", types.Validation, "model", inference.Model, "epochIndex", inference.EpochId)
-		return nil, types.ErrEpochGroupDataNotFound
-	}
-	modelThreshold = cachedModelMeta.ValidationThreshold
-	modelEpochPolicy = cachedModelMeta.EpochPolicy
-	totalWeight = cachedModelMeta.TotalWeight
-
-	validatorMeta, weightFound, weightErr := k.GetCachedEpochDataModelWeight(ctx, inference.EpochId, inference.Model, msg.Creator)
-	if weightErr != nil {
-		k.LogError("Validation: failed to load transient validation weight entry", types.Validation, "error", weightErr, "participant", msg.Creator, "model", inference.Model, "epochIndex", inference.EpochId)
-		return nil, weightErr
-	}
-	if !weightFound {
-		k.LogError("Participant not found in transient validation cache for model", types.Validation, "participant", msg.Creator, "epochIndex", inference.EpochId, "model", inference.Model)
-		return nil, types.ErrParticipantNotFound
-	}
-	participantWeight = validatorMeta.Weight
-	participantRepution = validatorMeta.Reputation
-	if modelThreshold == nil {
-		k.LogError("Validation threshold missing", types.Validation, "model", inference.Model, "epochIndex", inference.EpochId)
-		return nil, types.ErrModelSnapshotNotFound
-	}
-
-	passValue := modelThreshold.ToDecimal()
-	messageValue := getValidationValue(msg)
-
-	passed := messageValue.GreaterThan(passValue)
-	k.LogInfo(
-		"Validation details", types.Validation,
-		"passValue", passValue,
-		"passed", passed,
-		"msgValue", messageValue,
-		"model", inference.Model,
-	)
-	needsRevalidation := false
-
-	k.LogInfo("Validating inner loop", types.Validation, "inferenceId", inference.InferenceId, "validator", msg.Creator, "passed", passed, "revalidation", msg.Revalidation)
-	if msg.Revalidation {
-		if inference.ProposalDetails == nil {
-			k.LogError("Inference proposal details not set", types.Validation, "inference", inference)
-			return nil, types.ErrInferenceNotFinished
-		}
-		return k.revalidateInferenceVote(ctx, passed, inference, msg.Creator)
-	} else if passed {
-		inference.Status = types.InferenceStatus_VALIDATED
-		shouldShare, information := k.inferenceIsBeforeClaimsSet(ctx, inference, currentEpochIndex)
-		k.LogInfo("Validation sharing decision", types.Validation, "inferenceId", inference.InferenceId, "validator", msg.Creator, "shouldShare", shouldShare, "information", information)
-		if shouldShare {
-			k.shareWorkWithValidators(ctx, inference, msg, &executor)
-			inference.ValidatedBy = append(inference.ValidatedBy, msg.Creator)
-		}
-		executor.ConsecutiveInvalidInferences = 0
-		executor.CurrentEpochStats.ValidatedInferences++
-	} else if currentEpochIndex == inference.EpochId {
-		// Only run invalidation voting if we're still in the same Epoch as the inference
-		creatorAddr, err := sdk.AccAddressFromBech32(creator.Address)
-		if err != nil {
-			return nil, err
-		}
-		if k.MaximumInvalidationsReached(ctx, creatorAddr, inference.Model, participantWeight, participantRepution, totalWeight) {
-			k.LogWarn("Maximum invalidations reached.", types.Validation,
-				"creator", msg.Creator,
-				"model", inference.Model,
-				"epochIndex", inference.EpochId,
-			)
-			return &types.MsgValidationResponse{}, nil
-		}
-		inference.Status = types.InferenceStatus_VOTING
-		proposalDetails, err := k.startValidationVoteWithPolicy(ctx, modelEpochPolicy, &inference, msg.Creator)
-		if err != nil {
-			return nil, err
-		}
-		msgCreatorAddr, err := sdk.AccAddressFromBech32(msg.Creator)
-		if err != nil {
-			return nil, err
-		}
-		err = k.ActiveInvalidations.Set(ctx, collections.Join(msgCreatorAddr, inference.InferenceId))
-		if err != nil {
-			k.LogError("Failed to set active invalidation", types.Validation, "error", err)
-		}
-
-		inference.ProposalDetails = proposalDetails
-		needsRevalidation = true
-	} else if currentEpochIndex != inference.EpochId {
-		k.LogWarn("Ignoring invalidation submitted after epoch changeover", types.Validation, "inferenceId", inference.InferenceId, "inferenceEpoch", inference.EpochId, "currentEpoch", currentEpochIndex)
-		inference.Status = types.InferenceStatus_FINISHED
-	}
-
-	err = k.SetParticipant(ctx, executor)
-	if err != nil {
-		k.LogError("Failed to set executor", types.Validation, "executor", executor.Address, "error", err)
-		return nil, err
-	}
-
-	k.LogInfo("Saving inference", types.Validation, "inferenceId", inference.InferenceId, "status", inference.Status, "proposalDetails", inference.ProposalDetails)
-	err = k.SetInferenceWithoutPruning(ctx, inference)
-	if err != nil {
-		k.LogError("Failed to set inference", types.Validation, "inferenceId", inference.InferenceId, "error", err)
-		return nil, err
-	}
-	if inference.Status != previousStatus {
-		emitInferenceStatusUpdatedEvent(ctx, inference.InferenceId, inference.Status)
-	}
-
-	ctx.EventManager().EmitEvent(
-		sdk.NewEvent(
-			"inference_validation",
-			sdk.NewAttribute("inference_id", msg.InferenceId),
-			sdk.NewAttribute("validator", msg.Creator),
-			sdk.NewAttribute("needs_revalidation", strconv.FormatBool(needsRevalidation)),
-			sdk.NewAttribute("passed", strconv.FormatBool(passed)),
-		))
-	return &types.MsgValidationResponse{}, nil
-}
-
-func (k msgServer) revalidateInferenceVote(
-	ctx sdk.Context,
-	passed bool,
-	inference types.Inference,
-	voter string,
-) (*types.MsgValidationResponse, error) {
-	invalidateOption := group.VOTE_OPTION_YES
-	revalidationOption := group.VOTE_OPTION_NO
-	if passed {
-		invalidateOption = group.VOTE_OPTION_NO
-		revalidationOption = group.VOTE_OPTION_YES
-	}
-
-	voteMsg := &group.MsgVote{
-		ProposalId: inference.ProposalDetails.InvalidatePolicyId,
-		Voter:      voter,
-		Option:     invalidateOption,
-		Metadata:   "Invalidate inference " + inference.InferenceId,
-		Exec:       group.Exec_EXEC_TRY,
-	}
-	if err := k.voteValidationProposal(ctx, voteMsg); err != nil {
-		return nil, err
-	}
-
-	voteMsg.ProposalId = inference.ProposalDetails.ReValidatePolicyId
-	voteMsg.Option = revalidationOption
-	voteMsg.Metadata = "Revalidate inference " + inference.InferenceId
-	if err := k.voteValidationProposal(ctx, voteMsg); err != nil {
-		return nil, err
-	}
-	return &types.MsgValidationResponse{}, nil
-}
-
-func (k msgServer) voteValidationProposal(ctx sdk.Context, vote *group.MsgVote) error {
-	k.LogInfo("Voting", types.Validation, "vote", vote)
-	_, err := k.group.Vote(ctx, vote)
-	if err != nil {
-		if err.Error() == "proposal not open for voting: invalid value" {
-			k.LogInfo("Proposal already decided", types.Validation, "vote", vote)
-			return nil
-		}
-		k.LogError("Error voting", types.Validation, "error", err, "vote", vote)
-		return err
-	}
-	k.LogInfo("Voted on validation", types.Validation, "vote", vote)
-	return nil
-}
-
-func (k msgServer) startValidationVoteWithPolicy(
-	ctx sdk.Context,
-	policyAddress string,
-	inference *types.Inference,
-	invalidator string,
-) (*types.ProposalDetails, error) {
-	invalidateResponse, revalidateResponse, err := k.submitValidationProposalsWithPolicy(ctx, policyAddress, inference.InferenceId, invalidator, inference.ExecutedBy)
-	if err != nil {
-		return nil, err
-	}
-	return &types.ProposalDetails{
-		InvalidatePolicyId: invalidateResponse.ProposalId,
-		ReValidatePolicyId: revalidateResponse.ProposalId,
-		PolicyAddress:      policyAddress,
-	}, nil
-}
-
-func (k msgServer) submitValidationProposalsWithPolicy(
-	ctx sdk.Context,
-	policyAddress string,
-	inferenceID string,
-	invalidator string,
-	executor string,
-) (*group.MsgSubmitProposalResponse, *group.MsgSubmitProposalResponse, error) {
-	invalidateMessage := &types.MsgInvalidateInference{
-		InferenceId: inferenceID,
-		Creator:     policyAddress,
-		Invalidator: invalidator,
-	}
-	revalidateMessage := &types.MsgRevalidateInference{
-		InferenceId: inferenceID,
-		Creator:     policyAddress,
-		Invalidator: invalidator,
-	}
-	invalidateProposal := group.MsgSubmitProposal{
-		GroupPolicyAddress: policyAddress,
-		Proposers:          []string{invalidator},
-		Metadata:           "Invalidation of inference " + inferenceID,
-	}
-	revalidateProposal := group.MsgSubmitProposal{
-		GroupPolicyAddress: policyAddress,
-		Proposers:          []string{executor},
-		Metadata:           "Revalidation of inference " + inferenceID,
-	}
-	if err := invalidateProposal.SetMsgs([]sdk.Msg{invalidateMessage}); err != nil {
-		return nil, nil, err
-	}
-	if err := revalidateProposal.SetMsgs([]sdk.Msg{revalidateMessage}); err != nil {
-		return nil, nil, err
-	}
-	invalidateResponse, err := k.group.SubmitProposal(ctx, &invalidateProposal)
-	if err != nil {
-		return nil, nil, err
-	}
-	revalidateResponse, err := k.group.SubmitProposal(ctx, &revalidateProposal)
-	if err != nil {
-		return nil, nil, err
-	}
-	return invalidateResponse, revalidateResponse, nil
-}
-
-func getValidationValue(msg *types.MsgValidation) decimal.Decimal {
-	if msg.ValueDecimal != nil {
-		return msg.ValueDecimal.ToDecimal()
-	}
-	return decimal.NewFromFloat(msg.Value)
-}
-
-func (k msgServer) MaximumInvalidationsReached(
-	ctx sdk.Context,
-	creator sdk.AccAddress,
-	modelID string,
-	participantWeight int64,
-	participantReputation int32,
-	totalWeight int64,
-) bool {
-	currentInvalidations, err := k.CountInvalidations(ctx, creator)
-	if err != nil {
-		k.LogError("Failed to get current invalidations", types.Validation, "error", err)
-		return false
-	}
-	// Quick return for the default case
-	if currentInvalidations == 0 {
-		return false
-	}
-
-	params, err := k.GetParams(ctx)
-	if err != nil {
-		k.LogError("Failed to get params", types.Validation, "error", err)
-		return false
-	}
-	if params.BandwidthLimitsParams == nil {
-		k.LogError("Failed to get bandwidth limits params", types.Validation)
-		return false
-	}
-
-	windowBlocks := types.InvalidationsSamplePeriodToBlocks(params.BandwidthLimitsParams.InvalidationsSamplePeriod)
-	inferencesForModel := int64(0)
-	rollingInferenceCount, found, err := k.GetModelInferenceCountRollingSum(ctx, modelID, windowBlocks)
-	if err != nil {
-		k.LogError("Failed to get rolling inference count", types.Validation, "model", modelID, "error", err)
-		return false
-	}
-	if found {
-		inferencesForModel = int64(rollingInferenceCount)
-	} else {
-		// Default to zero when there is no model state yet.
-		k.LogInfo("No rolling inference count for model", types.Validation, "model", modelID)
-	}
-	var participantWeightPercent = decimal.Zero
-	if totalWeight != 0 {
-		participantWeightPercent = decimal.NewFromInt(participantWeight).Div(decimal.NewFromInt(totalWeight))
-	}
-	maxValidations := calculations.CalculateInvalidations(
-		inferencesForModel,
-		participantWeightPercent,
-		participantReputation,
-		int64(params.BandwidthLimitsParams.InvalidationsLimit),
-		int64(params.BandwidthLimitsParams.InvalidationsLimitCurve),
-		int64(params.BandwidthLimitsParams.MinimumConcurrentInvalidations),
-	)
-
-	return currentInvalidations >= maxValidations
-}
-
-func (k msgServer) CountInvalidations(ctx sdk.Context, address sdk.AccAddress) (int64, error) {
-	iter, err := k.ActiveInvalidations.Iterate(ctx, collections.NewPrefixedPairRange[sdk.AccAddress, string](address))
-	if err != nil {
-		return 0, err
-	}
-	defer iter.Close()
-	count := int64(0)
-	for ; iter.Valid(); iter.Next() {
-		count++
-	}
-	return count, nil
-}
-
-func (k msgServer) inferenceIsBeforeClaimsSet(ctx context.Context, inference types.Inference, currentEpochIndex uint64) (bool, string) {
-	// Submitted after epoch changeover (onSetNewValidatorsStage)
-	if inference.EpochId < currentEpochIndex {
-		return false, "Validation submitted in next epoch. InferenceEpoch: " + strconv.FormatUint(inference.EpochId, 10) + ", EpochGroupEpoch: " + strconv.FormatUint(currentEpochIndex, 10)
-	}
-	upcomingEpoch, found := k.GetUpcomingEpoch(ctx)
-	// During regular inference time (majority case)
-	if !found {
-		// This would be before IsStartOfPocStage
-		return true, "Validation during inference epoch"
-	}
-	// Somewhere inbetween StartOfPocStage and SetNewValidatorsStage
-	// ActiveParticipants are set during EndOfPoCValidationStage, which is also when we set claims
-	_, found = k.GetActiveParticipants(ctx, upcomingEpoch.Index)
-	if found {
-		// We're AFTER EndOfPocValidationStage
-		return false, "Validation submitted after claims set but before next epoch starts"
-	} else {
-		// We're in between StartOfPocStage and EndOfPocValidationStage, before claims
-		return true, "Validation submitted after PoC start but before claims set"
-	}
-}
-
-func (k msgServer) shareWorkWithValidators(ctx sdk.Context, inference types.Inference, msg *types.MsgValidation, executor *types.Participant) {
-	originalWorkers := append([]string{inference.ExecutedBy}, inference.ValidatedBy...)
-	adjustments := calculations.ShareWork(originalWorkers, []string{msg.Creator}, inference.ActualCost)
-	k.validateAdjustments(adjustments, msg)
-	for _, adjustment := range adjustments {
-		// A note about the bookkeeping here:
-		// ShareWork will return negative adjustments for all existing shareholders, and a positive for the new (msg.Creator)
-		// We account for this by adding a negative amount to the CoinBalance. BUT, we only register the NEGATIVE adjustments,
-		// and we model them as moving money from the existing worker TO the positive
-		if adjustment.ParticipantId == executor.Address {
-			executor.CoinBalance += adjustment.WorkAdjustment
-			k.LogInfo("Adjusting executor balance for validation", types.Validation, "executor", executor.Address, "adjustment", adjustment.WorkAdjustment)
-			k.LogInfo("Adjusting executor CoinBalance for validation", types.Balances, "executor", executor.Address, "adjustment", adjustment.WorkAdjustment, "coin_balance", executor.CoinBalance)
-			if adjustment.WorkAdjustment < 0 {
-				k.SafeLogSubAccountTransaction(ctx, msg.Creator, adjustment.ParticipantId, types.OwedSubAccount, -adjustment.WorkAdjustment, "share_validation_executor:"+inference.InferenceId)
-			}
-		} else {
-			worker, found := k.GetParticipant(ctx, adjustment.ParticipantId)
-			if !found {
-				k.LogError("Participant not found for redistribution", types.Validation, "participantId", adjustment.ParticipantId)
-				continue
-			}
-			worker.CoinBalance += adjustment.WorkAdjustment
-			k.LogInfo("Adjusting worker balance for validation", types.Validation, "worker", worker.Address, "adjustment", adjustment.WorkAdjustment)
-			k.LogInfo("Adjusting worker CoinBalance for validation", types.Balances, "worker", worker.Address, "adjustment", adjustment.WorkAdjustment, "coin_balance", worker.CoinBalance)
-			if adjustment.WorkAdjustment < 0 {
-				k.SafeLogSubAccountTransaction(ctx, msg.Creator, adjustment.ParticipantId, types.OwedSubAccount, -adjustment.WorkAdjustment, "share_validation_worker:"+inference.InferenceId)
-			}
-			err := k.SetParticipant(ctx, worker)
-			if err != nil {
-				k.LogError("Unable to update participant to share work", types.Validation, "worker", worker.Address)
-			}
-		}
-	}
-}
-
-func (k msgServer) validateAdjustments(adjustments []calculations.Adjustment, msg *types.MsgValidation) {
-	positiveAdjustmentTotal := int64(0)
-	negativeAdjustmentTotal := int64(0)
-	for _, adjustment := range adjustments {
-		if adjustment.ParticipantId == msg.Creator {
-			if adjustment.WorkAdjustment < 0 {
-				k.LogError("Validation adjustment for new validator cannot be negative", types.Validation, "adjustment", adjustment)
-			} else {
-				// must be a positive number or zero
-				positiveAdjustmentTotal += adjustment.WorkAdjustment
-			}
-		} else {
-			if adjustment.WorkAdjustment > 0 {
-				k.LogError("Validation adjustment for existing validator cannot be positive", types.Validation, "adjustment", adjustment)
-			} else {
-				// must be a negative number or zero
-				negativeAdjustmentTotal += -adjustment.WorkAdjustment
-			}
-		}
-	}
-	if positiveAdjustmentTotal != negativeAdjustmentTotal {
-		k.LogError("Validation adjustment totals do not match", types.Validation, "positiveAdjustmentTotal", positiveAdjustmentTotal, "negativeAdjustmentTotal", negativeAdjustmentTotal)
-	}
-}
-
-func (k msgServer) addInferenceToEpochGroupValidations(ctx sdk.Context, msg *types.MsgValidation, inference types.Inference) error {
-	entryKey := collections.Join3(inference.EpochId, msg.Creator, msg.InferenceId)
-	alreadyValidated, err := k.EpochGroupValidationEntry.Has(ctx, entryKey)
-	if err != nil {
-		return err
-	}
-	if alreadyValidated {
-		k.LogInfo("Inference already validated", types.Validation, "inferenceId", msg.InferenceId)
-		return types.ErrDuplicateValidation
-	}
-	k.LogInfo("Adding inference to epoch group validations", types.Validation, "inferenceId", msg.InferenceId, "validator", msg.Creator, "height", inference.EpochPocStartBlockHeight)
-	return k.SetEpochGroupValidation(ctx, inference.EpochId, msg.Creator, msg.InferenceId)
+	k.LogInfo("MsgValidation deprecated", types.Validation, "msg.Creator", msg.Creator, "inferenceId", msg.InferenceId)
+	return nil, classicInferenceDeprecatedError()
 }
diff --git a/inference-chain/x/inference/keeper/msg_server_validation_test.go b/inference-chain/x/inference/keeper/msg_server_validation_test.go
deleted file mode 100644
index ed6bd9d901..0000000000
--- a/inference-chain/x/inference/keeper/msg_server_validation_test.go
+++ /dev/null
@@ -1,369 +0,0 @@
-package keeper_test
-
-import (
-	"context"
-	"log"
-	"testing"
-	"time"
-
-	"cosmossdk.io/collections"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/group"
-	"github.com/productscience/inference/testutil"
-	keeper2 "github.com/productscience/inference/testutil/keeper"
-	"github.com/productscience/inference/x/inference/calculations"
-	"github.com/productscience/inference/x/inference/keeper"
-	"github.com/productscience/inference/x/inference/types"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-)
-
-const INFERENCE_ID = "inferenceId"
-const MODEL_ID = "Qwen/QwQ-32B"
-
-func TestMsgServer_Validation(t *testing.T) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-	addMembersToGroupData(k, ctx)
-
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-	buildValidationCacheForTest(t, k, ctx)
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.9999),
-	})
-	require.NoError(t, err)
-	inference, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VALIDATED, inference.Status)
-}
-
-func createParticipants(t *testing.T, ms types.MsgServer, ctx context.Context) {
-	mockRequester := NewMockAccount(testutil.Requester)
-	mockExecutor := NewMockAccount(testutil.Executor)
-	mockValidator := NewMockAccount(testutil.Validator)
-	mockCreator := NewMockAccount(testutil.Creator)
-	MustAddParticipant(t, ms, ctx, *mockRequester)
-	MustAddParticipant(t, ms, ctx, *mockExecutor)
-	MustAddParticipant(t, ms, ctx, *mockValidator)
-	MustAddParticipant(t, ms, ctx, *mockCreator)
-}
-
-func TestMsgServer_Validation_Invalidate(t *testing.T) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-
-	addMembersToGroupData(k, ctx)
-
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-	buildValidationCacheForTest(t, k, ctx)
-	mocks := inferenceHelper.Mocks
-	mocks.GroupKeeper.EXPECT().SubmitProposal(gomock.Any(), gomock.Any()).Return(&group.MsgSubmitProposalResponse{
-		ProposalId: 1,
-	}, nil)
-	mocks.GroupKeeper.EXPECT().SubmitProposal(gomock.Any(), gomock.Any()).Return(&group.MsgSubmitProposalResponse{
-		ProposalId: 2,
-	}, nil)
-	ms := inferenceHelper.MessageServer
-	_, err = ms.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.80),
-	})
-	require.NoError(t, err)
-	inference, found := k.GetInference(ctx, expected.InferenceId)
-	log.Print(inference)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VOTING, inference.Status)
-	mocks.GroupKeeper.EXPECT().Vote(gomock.Any(), gomock.Eq(&group.MsgVote{
-		ProposalId: 1,
-		Voter:      testutil.Requester,
-		Option:     group.VOTE_OPTION_YES,
-		Metadata:   "Invalidate inference " + expected.InferenceId,
-		Exec:       group.Exec_EXEC_TRY,
-	}))
-	mocks.GroupKeeper.EXPECT().Vote(gomock.Any(), gomock.Eq(&group.MsgVote{
-		ProposalId: 2,
-		Voter:      testutil.Requester,
-		Option:     group.VOTE_OPTION_NO,
-		Metadata:   "Revalidate inference " + expected.InferenceId,
-		Exec:       group.Exec_EXEC_TRY,
-	}))
-
-	_, err = ms.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Requester,
-		ValueDecimal: types.DecimalFromFloat(0.80),
-		Revalidation: true,
-	})
-	inference, found = k.GetInference(ctx, expected.InferenceId)
-
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VOTING, inference.Status)
-
-	has, err := k.ActiveInvalidations.Has(ctx, collections.Join(sdk.MustAccAddressFromBech32(testutil.Validator), expected.InferenceId))
-	require.NoError(t, err)
-	require.True(t, has)
-}
-
-func addMembersToGroupData(k keeper.Keeper, ctx sdk.Context) {
-	groupData, _ := k.GetEpochGroupData(ctx, 0, MODEL_ID)
-	groupData.ValidationWeights = []*types.ValidationWeight{
-		{
-			MemberAddress: testutil.Validator,
-			Weight:        100,
-			Reputation:    50,
-		},
-		{
-			MemberAddress: testutil.Requester,
-			Weight:        100,
-			Reputation:    100,
-		},
-	}
-	// Ensure TotalWeight is set to avoid division by zero in calculations
-	var total int64 = 0
-	for _, vw := range groupData.ValidationWeights {
-		total += vw.Weight
-	}
-	groupData.TotalWeight = total
-	k.SetEpochGroupData(ctx, groupData)
-}
-
-func buildValidationCacheForTest(t *testing.T, k keeper.Keeper, ctx sdk.Context) {
-	t.Helper()
-	require.NoError(t, k.BuildEpochDataTransientCache(ctx))
-}
-
-func TestMsgServer_NoInference(t *testing.T) {
-	_, ms, ctx := setupMsgServer(t)
-	createParticipants(t, ms, ctx)
-	_, err := ms.Validation(ctx, &types.MsgValidation{
-		InferenceId:  INFERENCE_ID,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.9999),
-	})
-	require.Error(t, err)
-}
-
-func TestMsgServer_NotFinished(t *testing.T) {
-	inferenceHelper, _, ctx := NewMockInferenceHelper(t)
-	requestTimestamp := time.Now().UnixNano()
-	expected, err := inferenceHelper.StartInference("promptPayload", "model1", requestTimestamp, calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.9999),
-	})
-	require.Error(t, err)
-}
-
-func TestMsgServer_InvalidExecutor(t *testing.T) {
-	_, ms, ctx := setupMsgServer(t)
-	mockValidator := NewMockAccount(testutil.Validator)
-	MustAddParticipant(t, ms, ctx, *mockValidator)
-	_, err := ms.Validation(ctx, &types.MsgValidation{
-		InferenceId:  INFERENCE_ID,
-		Creator:      testutil.Executor,
-		ValueDecimal: types.DecimalFromFloat(0.9999),
-	})
-	require.Error(t, err)
-}
-
-func TestMsgServer_ValidatorCannotBeExecutor(t *testing.T) {
-	_, ms, ctx := setupMsgServer(t)
-	createParticipants(t, ms, ctx)
-	_, err := ms.Validation(ctx, &types.MsgValidation{
-		InferenceId:  INFERENCE_ID,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.9999),
-	})
-	require.Error(t, err)
-}
-
-func createCompletedInference(t *testing.T, ms types.MsgServer, ctx context.Context, mocks *keeper2.InferenceMocks) {
-	_, err := ms.StartInference(ctx, &types.MsgStartInference{
-		InferenceId:   "inferenceId",
-		PromptHash:    "promptHash",
-		PromptPayload: "promptPayload",
-		RequestedBy:   testutil.Requester,
-		Creator:       testutil.Creator,
-		Model:         "Qwen/QwQ-32B",
-	})
-	require.NoError(t, err)
-	_, err = ms.FinishInference(ctx, &types.MsgFinishInference{
-		Creator:              testutil.Executor,
-		InferenceId:          "inferenceId",
-		ResponseHash:         "responseHash",
-		ResponsePayload:      "responsePayload",
-		PromptTokenCount:     10,
-		CompletionTokenCount: 20,
-		ExecutedBy:           testutil.Executor,
-	})
-	require.NoError(t, err)
-}
-
-// New tests for invalidation limits and duplicate validations
-func TestMsgServer_Validation_InvalidationsLimit_NoStatusChange_ButRecordsCredit(t *testing.T) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-	addMembersToGroupData(k, ctx)
-
-	// Make the maximum allowed invalidations very small and deterministic
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	if params.BandwidthLimitsParams == nil {
-		params.BandwidthLimitsParams = &types.BandwidthLimitsParams{}
-	}
-	params.BandwidthLimitsParams.InvalidationsLimit = 1
-	params.BandwidthLimitsParams.InvalidationsLimitCurve = 1
-	params.BandwidthLimitsParams.InvalidationsSamplePeriod = 60
-	err = k.SetParams(ctx, params)
-	require.NoError(t, err)
-
-	// Pre-populate one active invalidation for the validator so we hit the limit (>= 1)
-	err = k.ActiveInvalidations.Set(ctx, collections.Join(sdk.MustAccAddressFromBech32(testutil.Validator), "prev-inference"))
-	require.NoError(t, err)
-
-	// Create and finish an inference
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-	buildValidationCacheForTest(t, k, ctx)
-
-	// Attempt a failing validation; since limit reached, it should early-return without changing status
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.10), // below threshold so it would normally trigger invalidation
-	})
-	require.NoError(t, err)
-
-	// Inference status should remain FINISHED (no transition to VOTING)
-	saved, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_FINISHED, saved.Status)
-
-	// Validator should still get credit for performing validation in EpochGroupValidations
-	egv, ok := k.GetEpochGroupValidations(ctx, testutil.Validator, saved.EpochId)
-	require.True(t, ok)
-	// The recorded list should contain this inference id
-	foundId := false
-	for _, id := range egv.ValidatedInferences {
-		if id == expected.InferenceId {
-			foundId = true
-			break
-		}
-	}
-	require.True(t, foundId, "expected inference id to be recorded in epoch group validations")
-}
-
-func TestMsgServer_Validation_InvalidationsLimit_AllowsVote_WithHighRollingActivity(t *testing.T) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-	addMembersToGroupData(k, ctx)
-
-	// Configure limit curve so max invalidations grows above 1 when recent activity is high.
-	params, err := k.GetParams(ctx)
-	require.NoError(t, err)
-	if params.BandwidthLimitsParams == nil {
-		params.BandwidthLimitsParams = &types.BandwidthLimitsParams{}
-	}
-	params.BandwidthLimitsParams.InvalidationsLimit = 10
-	params.BandwidthLimitsParams.InvalidationsLimitCurve = 1
-	params.BandwidthLimitsParams.InvalidationsSamplePeriod = 60
-	k.SetParams(ctx, params)
-
-	// Current active invalidations = 1.
-	validatorAddr := sdk.MustAccAddressFromBech32(testutil.Validator)
-	err = k.ActiveInvalidations.Set(ctx, collections.Join(validatorAddr, "prev-inference"))
-	require.NoError(t, err)
-
-	// Seed rolling inference-count state with high recent traffic for this model.
-	err = k.UpdateModelRollingWindowsForActiveModels(
-		ctx,
-		[]string{model.Id},
-		map[string]uint64{model.Id: 0},
-		60,
-		map[string]uint64{model.Id: 100},
-		60,
-	)
-	require.NoError(t, err)
-
-	// Create and finish an inference.
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-	buildValidationCacheForTest(t, k, ctx)
-
-	// With high rolling activity, invalidation should proceed to voting (not early-return).
-	inferenceHelper.Mocks.GroupKeeper.EXPECT().SubmitProposal(gomock.Any(), gomock.Any()).Return(&group.MsgSubmitProposalResponse{ProposalId: 1}, nil)
-	inferenceHelper.Mocks.GroupKeeper.EXPECT().SubmitProposal(gomock.Any(), gomock.Any()).Return(&group.MsgSubmitProposalResponse{ProposalId: 2}, nil)
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.10), // below threshold so it triggers invalidation voting
-	})
-	require.NoError(t, err)
-
-	saved, found := k.GetInference(ctx, expected.InferenceId)
-	require.True(t, found)
-	require.Equal(t, types.InferenceStatus_VOTING, saved.Status)
-}
-
-func TestMsgServer_Validation_DuplicateValidation_ReturnsErrDuplicateValidation(t *testing.T) {
-	inferenceHelper, k, ctx := NewMockInferenceHelper(t)
-	createParticipants(t, inferenceHelper.MessageServer, ctx)
-
-	model := &types.Model{Id: MODEL_ID, ValidationThreshold: &types.Decimal{Value: 85, Exponent: -2}}
-	k.SetModel(ctx, model)
-	StubModelSubgroup(t, ctx, k, inferenceHelper.Mocks, model)
-	addMembersToGroupData(k, ctx)
-
-	expected, err := inferenceHelper.StartInference("promptPayload", model.Id, time.Now().UnixNano(), calculations.DefaultMaxTokens)
-	require.NoError(t, err)
-	_, err = inferenceHelper.FinishInference()
-	require.NoError(t, err)
-	buildValidationCacheForTest(t, k, ctx)
-
-	// First validation should succeed
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.99),
-	})
-	require.NoError(t, err)
-
-	// Second validation (same validator, same inference, not a revalidation) should return ErrDuplicateValidation
-	_, err = inferenceHelper.MessageServer.Validation(ctx, &types.MsgValidation{
-		InferenceId:  expected.InferenceId,
-		Creator:      testutil.Validator,
-		ValueDecimal: types.DecimalFromFloat(0.99),
-	})
-	require.Error(t, err)
-	require.ErrorIs(t, err, types.ErrDuplicateValidation)
-}
diff --git a/inference-chain/x/inference/keeper/params.go b/inference-chain/x/inference/keeper/params.go
index 2a9fe8fd6a..574b7b75ba 100644
--- a/inference-chain/x/inference/keeper/params.go
+++ b/inference-chain/x/inference/keeper/params.go
@@ -310,3 +310,16 @@ func (k Keeper) IsAllowedEscrowCreator(ctx context.Context, address string) bool
 	}
 	return false
 }
+
+// GetMaintenanceParams returns maintenance params, falling back to defaults if unset.
+func (k Keeper) GetMaintenanceParams(ctx context.Context) *types.MaintenanceParams {
+	p, err := k.GetParams(ctx)
+	if err != nil {
+		k.LogError("Unable to get Params in GetMaintenanceParams", types.System, "error", err)
+		return types.DefaultMaintenanceParams()
+	}
+	if p.MaintenanceParams == nil {
+		return types.DefaultMaintenanceParams()
+	}
+	return p.MaintenanceParams
+}
diff --git a/inference-chain/x/inference/keeper/partial_upgrade.go b/inference-chain/x/inference/keeper/partial_upgrade.go
index 95c9a0c066..99d44a341e 100644
--- a/inference-chain/x/inference/keeper/partial_upgrade.go
+++ b/inference-chain/x/inference/keeper/partial_upgrade.go
@@ -57,12 +57,12 @@ func (k Keeper) GetUpgradePlan(ctx context.Context) (upgradetypes.Plan, error) {
 
 // SetLastUpgradeHeight stores the block height of the most recent upgrade
 func (k Keeper) SetLastUpgradeHeight(ctx context.Context, height int64) error {
-	return k.LastUpgradeHeight.Set(ctx, height)
+	return k.LastUpgradeHeightItem.Set(ctx, height)
 }
 
 // GetLastUpgradeHeight returns the block height of the most recent upgrade
 func (k Keeper) GetLastUpgradeHeight(ctx context.Context) (int64, bool) {
-	height, err := k.LastUpgradeHeight.Get(ctx)
+	height, err := k.LastUpgradeHeightItem.Get(ctx)
 	if err != nil {
 		return 0, false
 	}
diff --git a/inference-chain/x/inference/keeper/permissions.go b/inference-chain/x/inference/keeper/permissions.go
index af7c578289..7d18348b84 100644
--- a/inference-chain/x/inference/keeper/permissions.go
+++ b/inference-chain/x/inference/keeper/permissions.go
@@ -112,6 +112,7 @@ var MessagePermissions = map[reflect.Type][]Permission{
 	reflect.TypeOf((*types.MsgRevalidateInference)(nil)): {NoPermission},
 
 	reflect.TypeOf((*types.MsgClaimRewards)(nil)):                     {ActiveParticipantPermission, PreviousActiveParticipantPermission},
+	reflect.TypeOf((*types.MsgSetClaimRecipients)(nil)):               {ParticipantPermission},
 	reflect.TypeOf((*types.MsgSubmitHardwareDiff)(nil)):               {ParticipantPermission},
 	reflect.TypeOf((*types.MsgSubmitPocBatch)(nil)):                   {ParticipantPermission},
 	reflect.TypeOf((*types.MsgSubmitPocValidationsV2)(nil)):           {NoPermission},
@@ -129,6 +130,9 @@ var MessagePermissions = map[reflect.Type][]Permission{
 	reflect.TypeOf((*types.MsgSettleDevshardEscrow)(nil)):       {EscrowAllowListPermission},
 	reflect.TypeOf((*types.MsgSetDevshardRequestsEnabled)(nil)): {GuardianPermission},
 
+	reflect.TypeOf((*types.MsgScheduleMaintenance)(nil)): {AccountPermission},
+	reflect.TypeOf((*types.MsgCancelMaintenance)(nil)):   {AccountPermission},
+
 	reflect.TypeOf((*types.MsgSetPoCDelegation)(nil)):    {ParticipantPermission},
 	reflect.TypeOf((*types.MsgRefusePoCDelegation)(nil)): {ParticipantPermission},
 	reflect.TypeOf((*types.MsgDeclarePoCIntent)(nil)):    {ParticipantPermission},
diff --git a/inference-chain/x/inference/keeper/pruning.go b/inference-chain/x/inference/keeper/pruning.go
index 7aabe32278..1af1a7b3dc 100644
--- a/inference-chain/x/inference/keeper/pruning.go
+++ b/inference-chain/x/inference/keeper/pruning.go
@@ -9,7 +9,9 @@ import (
 )
 
 const (
-	LookbackMultiplier = int64(5)
+	LookbackMultiplier               = int64(5)
+	ClaimRecipientPruningThreshold   = uint64(5)
+	ClaimRecipientPruningMaxPerBlock = int64(1000)
 )
 
 func (k Keeper) Prune(ctx context.Context, currentEpochIndex int64) error {
@@ -53,6 +55,10 @@ func (k Keeper) Prune(ctx context.Context, currentEpochIndex int64) error {
 	if err != nil {
 		return err
 	}
+	err = k.GetClaimRecipientPruner(params).Prune(ctx, k, currentEpochIndex)
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -287,6 +293,27 @@ func (k Keeper) GetDevshardPruner(params types.Params) Pruner[collections.Pair[u
 	}
 }
 
+func (k Keeper) GetClaimRecipientPruner(params types.Params) Pruner[collections.Pair[uint64, sdk.AccAddress], collections.NoValue] {
+	return Pruner[collections.Pair[uint64, sdk.AccAddress], collections.NoValue]{
+		Threshold:  ClaimRecipientPruningThreshold,
+		PruningMax: ClaimRecipientPruningMaxPerBlock,
+		List:       collections.Map[collections.Pair[uint64, sdk.AccAddress], collections.NoValue](k.ClaimRecipientsByEpoch),
+		Ranger: func(ctx context.Context, epoch int64) collections.Ranger[collections.Pair[uint64, sdk.AccAddress]] {
+			return collections.NewPrefixedPairRange[uint64, sdk.AccAddress](uint64(epoch))
+		},
+		GetLastPruned: func(state types.PruningState) int64 {
+			return state.ClaimRecipientsPrunedEpoch
+		},
+		SetLastPruned: func(state *types.PruningState, epoch int64) {
+			state.ClaimRecipientsPrunedEpoch = epoch
+		},
+		Remover: func(ctx context.Context, key collections.Pair[uint64, sdk.AccAddress]) error {
+			return k.RemoveClaimRecipientForEpoch(sdk.UnwrapSDKContext(ctx), key.K2(), key.K1())
+		},
+		Logger: k,
+	}
+}
+
 func (k Keeper) GetPoCValidationsPruner(params types.Params) Pruner[collections.Triple[int64, sdk.AccAddress, sdk.AccAddress], types.PoCValidation] {
 	return Pruner[collections.Triple[int64, sdk.AccAddress, sdk.AccAddress], types.PoCValidation]{
 		Threshold:  params.PocParams.PocDataPruningEpochThreshold,
diff --git a/inference-chain/x/inference/keeper/query_bitcoin_reward_estimate.go b/inference-chain/x/inference/keeper/query_bitcoin_reward_estimate.go
new file mode 100644
index 0000000000..ac4a822f40
--- /dev/null
+++ b/inference-chain/x/inference/keeper/query_bitcoin_reward_estimate.go
@@ -0,0 +1,66 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (k Keeper) EstimateBitcoinReward(ctx context.Context, req *types.QueryEstimateBitcoinRewardRequest) (*types.QueryEstimateBitcoinRewardResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+	if _, err := sdk.AccAddressFromBech32(req.Participant); err != nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid participant address")
+	}
+
+	snapshot, snapshotFound := k.GetDelegationRewardTransferSnapshot(ctx)
+	if !snapshotFound || snapshot.EpochIndex == 0 {
+		return nil, status.Error(codes.NotFound, "delegation reward snapshot not found")
+	}
+	epochIndex := snapshot.EpochIndex
+
+	inputs, found, err := k.loadBitcoinRewardInputs(ctx, epochIndex)
+	if !found {
+		return nil, status.Error(codes.NotFound, "active participants not found for epoch")
+	}
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	amounts, _, err := GetBitcoinSettleAmountsWithTransfers(
+		inputs.Participants,
+		&inputs.EpochGroupData,
+		inputs.Params.BitcoinRewardParams,
+		inputs.ValidationParams,
+		inputs.SettleParameters,
+		inputs.ParticipantMLNodes,
+		inputs.RewardTransfers,
+		inputs.RewardPenalties,
+		k.Logger(),
+	)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+
+	for _, amount := range amounts {
+		if amount == nil || amount.Settle == nil || amount.Settle.Participant != req.Participant {
+			continue
+		}
+		settleAmount := *amount.Settle
+		settleAmount.EpochIndex = epochIndex
+
+		if amount.Error != nil {
+			return nil, status.Error(codes.Internal, amount.Error.Error())
+		}
+
+		return &types.QueryEstimateBitcoinRewardResponse{
+			SettleAmount: settleAmount,
+		}, nil
+	}
+
+	return nil, status.Error(codes.NotFound, "participant not found in epoch reward estimate")
+}
diff --git a/inference-chain/x/inference/keeper/query_bitcoin_reward_estimate_test.go b/inference-chain/x/inference/keeper/query_bitcoin_reward_estimate_test.go
new file mode 100644
index 0000000000..315640b97d
--- /dev/null
+++ b/inference-chain/x/inference/keeper/query_bitcoin_reward_estimate_test.go
@@ -0,0 +1,101 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/productscience/inference/testutil"
+	keepertest "github.com/productscience/inference/testutil/keeper"
+	"github.com/productscience/inference/testutil/sample"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func TestEstimateBitcoinReward_InvalidRequest(t *testing.T) {
+	k, ctx := keepertest.InferenceKeeper(t)
+
+	_, err := k.EstimateBitcoinReward(ctx, nil)
+	require.ErrorIs(t, err, status.Error(codes.InvalidArgument, "invalid request"))
+
+	_, err = k.EstimateBitcoinReward(ctx, &types.QueryEstimateBitcoinRewardRequest{
+		Participant: "invalid",
+	})
+	require.ErrorIs(t, err, status.Error(codes.InvalidArgument, "invalid participant address"))
+}
+
+func TestEstimateBitcoinReward_SnapshotNotFound(t *testing.T) {
+	k, ctx := keepertest.InferenceKeeper(t)
+
+	_, err := k.EstimateBitcoinReward(ctx, &types.QueryEstimateBitcoinRewardRequest{
+		Participant: sample.AccAddress(),
+	})
+
+	require.ErrorIs(t, err, status.Error(codes.NotFound, "delegation reward snapshot not found"))
+}
+
+func TestEstimateBitcoinReward_ActiveParticipantsNotFound(t *testing.T) {
+	k, ctx := keepertest.InferenceKeeper(t)
+	require.NoError(t, k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: 12,
+	}))
+
+	_, err := k.EstimateBitcoinReward(ctx, &types.QueryEstimateBitcoinRewardRequest{
+		Participant: sample.AccAddress(),
+	})
+
+	require.ErrorIs(t, err, status.Error(codes.NotFound, "active participants not found for epoch"))
+}
+
+func TestEstimateBitcoinReward_AppliesSnapshotPenalty(t *testing.T) {
+	k, ctx, _ := keepertest.InferenceKeeperReturningMocks(t)
+
+	const epoch = uint64(5)
+	addr1 := testutil.Executor
+	addr2 := testutil.Executor2
+
+	for _, addr := range []string{addr1, addr2} {
+		require.NoError(t, k.SetParticipant(ctx, types.Participant{
+			Index:             addr,
+			Address:           addr,
+			Status:            types.ParticipantStatus_ACTIVE,
+			CurrentEpochStats: &types.CurrentEpochStats{InferenceCount: 100, MissedRequests: 0},
+		}))
+	}
+
+	k.SetEpochGroupData(ctx, types.EpochGroupData{
+		EpochIndex: epoch,
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: addr1, Weight: 1000, ConfirmationWeight: 1000},
+			{MemberAddress: addr2, Weight: 1000, ConfirmationWeight: 1000},
+		},
+	})
+	require.NoError(t, k.SetActiveParticipants(ctx, types.ActiveParticipants{
+		EpochId: epoch,
+		Participants: []*types.ActiveParticipant{
+			{Index: addr1},
+			{Index: addr2},
+		},
+	}))
+	_, err := k.EstimateBitcoinReward(ctx, &types.QueryEstimateBitcoinRewardRequest{Participant: addr1})
+	require.ErrorIs(t, err, status.Error(codes.NotFound, "delegation reward snapshot not found"))
+
+	require.NoError(t, k.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: epoch,
+		Penalties: []*types.DelegationRewardPenalty{
+			{Participant: addr1, PenaltyFraction: types.DecimalFromFloat(0.5)},
+		},
+	}))
+
+	resp1, err := k.EstimateBitcoinReward(ctx, &types.QueryEstimateBitcoinRewardRequest{Participant: addr1})
+	require.NoError(t, err)
+	require.Equal(t, addr1, resp1.SettleAmount.Participant)
+	require.Equal(t, epoch, resp1.SettleAmount.EpochIndex)
+
+	resp2, err := k.EstimateBitcoinReward(ctx, &types.QueryEstimateBitcoinRewardRequest{Participant: addr2})
+	require.NoError(t, err)
+
+	require.Greater(t, resp2.SettleAmount.RewardCoins, uint64(0))
+	require.Less(t, resp1.SettleAmount.RewardCoins, resp2.SettleAmount.RewardCoins)
+}
diff --git a/inference-chain/x/inference/keeper/query_get_random_executor.go b/inference-chain/x/inference/keeper/query_get_random_executor.go
index 8f9ba45a7a..4337657109 100644
--- a/inference-chain/x/inference/keeper/query_get_random_executor.go
+++ b/inference-chain/x/inference/keeper/query_get_random_executor.go
@@ -13,28 +13,37 @@ import (
 
 func (k Keeper) GetRandomExecutor(goCtx context.Context, req *types.QueryGetRandomExecutorRequest) (*types.QueryGetRandomExecutorResponse, error) {
 	if req == nil {
-		k.Logger().Error("GetRandomExecutor: received nil request")
+		k.LogError("Received nil request", types.EpochGroup)
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
 
-	k.Logger().Info("GetRandomExecutor: Starting executor selection",
+	k.LogDebug("GetRandomExecutor: Starting executor selection", types.EpochGroup,
 		"model_id", req.Model)
 
 	filterFn, err := k.createFilterFn(goCtx, req.Model)
 	if err != nil {
-		k.Logger().Error("GetRandomExecutor: failed to create filter function",
+		k.LogError("GetRandomExecutor: failed to create filter function", types.EpochGroup,
 			"model_id", req.Model, "error", err.Error())
 		return nil, err
 	}
 
+	// Wrap filter to exclude participants in active maintenance windows.
+	// Maintenance-covered participants remain in epoch groups but must not
+	// receive new inference assignments during their maintenance window.
+	originalFilter := filterFn
+	filterFn = func(members []*group.GroupMember) []*group.GroupMember {
+		filtered := originalFilter(members)
+		return k.filterOutMaintenanceParticipants(goCtx, filtered)
+	}
+
 	epochGroup, err := k.GetCurrentEpochGroup(goCtx)
 	if err != nil {
-		k.Logger().Error("GetRandomExecutor: failed to get current epoch group",
+		k.LogError("GetRandomExecutor: failed to get current epoch group", types.EpochGroup,
 			"model_id", req.Model, "error", err.Error())
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	k.Logger().Info("GetRandomExecutor: Retrieved epoch group",
+	k.LogDebug("GetRandomExecutor: Retrieved epoch group", types.EpochGroup,
 		"model_id", req.Model, "epoch_id", epochGroup.GroupData.EpochIndex)
 
 	modelFound := false
@@ -50,12 +59,12 @@ func (k Keeper) GetRandomExecutor(goCtx context.Context, req *types.QueryGetRand
 
 	participant, err := epochGroup.GetRandomMemberForModel(goCtx, req.Model, filterFn)
 	if err != nil {
-		k.Logger().Error("GetRandomExecutor: failed to get random member",
+		k.LogError("GetRandomExecutor: failed to get random member", types.EpochGroup,
 			"model_id", req.Model, "error", err.Error())
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	k.Logger().Info("GetRandomExecutor: Selected participant",
+	k.LogDebug("GetRandomExecutor: Selected participant", types.EpochGroup,
 		"model_id", req.Model, "participant_address", participant.Address)
 
 	return &types.QueryGetRandomExecutorResponse{
@@ -66,12 +75,12 @@ func (k Keeper) GetRandomExecutor(goCtx context.Context, req *types.QueryGetRand
 func (k Keeper) createFilterFn(goCtx context.Context, modelId string) (func(members []*group.GroupMember) []*group.GroupMember, error) {
 	sdkCtx := sdk.UnwrapSDKContext(goCtx)
 
-	k.Logger().Info("GetRandomExecutor: createFilterFn: Starting filter creation",
+	k.LogDebug("GetRandomExecutor: createFilterFn: Starting filter creation", types.EpochGroup,
 		"model_id", modelId, "block_height", sdkCtx.BlockHeight())
 
 	effectiveEpoch, found := k.GetEffectiveEpoch(goCtx)
 	if !found || effectiveEpoch == nil {
-		k.Logger().Error("GetRandomExecutor: createFilterFn: no effective epoch found",
+		k.LogError("GetRandomExecutor: createFilterFn: no effective epoch found", types.EpochGroup,
 			"model_id", modelId)
 		return nil, status.Error(codes.Unavailable, "GetRandomExecutor: no effective epoch found")
 	}
@@ -81,27 +90,27 @@ func (k Keeper) createFilterFn(goCtx context.Context, modelId string) (func(memb
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 	if epochParams.EpochParams == nil {
-		k.Logger().Error("GetRandomExecutor: createFilterFn: epoch params are nil",
+		k.LogError("GetRandomExecutor: createFilterFn: epoch params are nil", types.EpochGroup,
 			"model_id", modelId, "epoch_index", effectiveEpoch.Index)
 		return nil, status.Error(codes.Unavailable, "GetRandomExecutor: epoch params are nil")
 	}
 
 	epochContext, err := types.NewEpochContextFromEffectiveEpoch(*effectiveEpoch, *epochParams.EpochParams, sdkCtx.BlockHeight())
 	if err != nil {
-		k.Logger().Error("GetRandomExecutor: createFilterFn: failed to create epoch context",
+		k.LogError("GetRandomExecutor: createFilterFn: failed to create epoch context", types.EpochGroup,
 			"model_id", modelId, "epoch_index", effectiveEpoch.Index, "error", err.Error())
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 	currentPhase := epochContext.GetCurrentPhase(sdkCtx.BlockHeight())
 
-	k.Logger().Info("GetRandomExecutor: createFilterFn: Determined current phase",
+	k.LogDebug("GetRandomExecutor: createFilterFn: Determined current phase", types.EpochGroup,
 		"model_id", modelId, "current_phase", string(currentPhase),
 		"epoch_index", effectiveEpoch.Index, "latest_epoch_index", epochContext.EpochIndex,
 		"block_height", sdkCtx.BlockHeight(), "set_new_validators_block_height", epochContext.SetNewValidators())
 
 	_, isActive, err := k.GetActiveConfirmationPoCEvent(goCtx)
 	if err != nil {
-		k.Logger().Error("GetRandomExecutor: createFilterFn: failed to check confirmation PoC",
+		k.LogError("GetRandomExecutor: createFilterFn: failed to check confirmation PoC", types.EpochGroup,
 			"model_id", modelId, "error", err.Error())
 		return nil, status.Error(codes.Internal, err.Error())
 	}
diff --git a/inference-chain/x/inference/keeper/query_last_upgrade_height.go b/inference-chain/x/inference/keeper/query_last_upgrade_height.go
new file mode 100644
index 0000000000..269a9e7556
--- /dev/null
+++ b/inference-chain/x/inference/keeper/query_last_upgrade_height.go
@@ -0,0 +1,22 @@
+package keeper
+
+import (
+	"context"
+
+	"github.com/productscience/inference/x/inference/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (k Keeper) LastUpgradeHeight(ctx context.Context, req *types.QueryGetLastUpgradeHeightRequest) (*types.QueryGetLastUpgradeHeightResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	height, found := k.GetLastUpgradeHeight(ctx)
+
+	return &types.QueryGetLastUpgradeHeightResponse{
+		LastUpgradeHeight: height,
+		Found:             found,
+	}, nil
+}
diff --git a/inference-chain/x/inference/keeper/query_last_upgrade_height_test.go b/inference-chain/x/inference/keeper/query_last_upgrade_height_test.go
new file mode 100644
index 0000000000..a41b67c594
--- /dev/null
+++ b/inference-chain/x/inference/keeper/query_last_upgrade_height_test.go
@@ -0,0 +1,68 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	keepertest "github.com/productscience/inference/testutil/keeper"
+	"github.com/productscience/inference/testutil/nullify"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func TestLastUpgradeHeightQuery(t *testing.T) {
+	t.Parallel()
+
+	keeper, ctx := keepertest.InferenceKeeper(t)
+
+	require.NoError(t, keeper.SetLastUpgradeHeight(ctx, 1234))
+
+	tests := []struct {
+		desc     string
+		request  *types.QueryGetLastUpgradeHeightRequest
+		response *types.QueryGetLastUpgradeHeightResponse
+		err      error
+	}{
+		{
+			desc:    "Found",
+			request: &types.QueryGetLastUpgradeHeightRequest{},
+			response: &types.QueryGetLastUpgradeHeightResponse{
+				LastUpgradeHeight: 1234,
+				Found:             true,
+			},
+		},
+		{
+			desc: "InvalidRequest",
+			err:  status.Error(codes.InvalidArgument, "invalid request"),
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
+
+			response, err := keeper.LastUpgradeHeight(ctx, tc.request)
+			if tc.err != nil {
+				require.ErrorIs(t, err, tc.err)
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, nullify.Fill(tc.response), nullify.Fill(response))
+		})
+	}
+}
+
+func TestLastUpgradeHeightQueryNotFound(t *testing.T) {
+	t.Parallel()
+
+	keeper, ctx := keepertest.InferenceKeeper(t)
+
+	response, err := keeper.LastUpgradeHeight(ctx, &types.QueryGetLastUpgradeHeightRequest{})
+	require.NoError(t, err)
+	require.False(t, response.Found)
+	require.Zero(t, response.LastUpgradeHeight)
+}
diff --git a/inference-chain/x/inference/keeper/query_list_claim_recipients.go b/inference-chain/x/inference/keeper/query_list_claim_recipients.go
new file mode 100644
index 0000000000..1f06f39c10
--- /dev/null
+++ b/inference-chain/x/inference/keeper/query_list_claim_recipients.go
@@ -0,0 +1,27 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// ListClaimRecipients returns every currently-scheduled (epoch, recipient)
+// override for the given participant, ordered by epoch.
+func (k Keeper) ListClaimRecipients(ctx context.Context, req *types.QueryListClaimRecipientsRequest) (*types.QueryListClaimRecipientsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+	addr, err := sdk.AccAddressFromBech32(req.Participant)
+	if err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "invalid participant address: %s", err)
+	}
+	entries, err := k.GetClaimRecipientsByParticipant(ctx, addr)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "failed to read schedule: %s", err)
+	}
+	return &types.QueryListClaimRecipientsResponse{Entries: entries}, nil
+}
diff --git a/inference-chain/x/inference/keeper/query_maintenance.go b/inference-chain/x/inference/keeper/query_maintenance.go
new file mode 100644
index 0000000000..b704f49d43
--- /dev/null
+++ b/inference-chain/x/inference/keeper/query_maintenance.go
@@ -0,0 +1,262 @@
+package keeper
+
+import (
+	"context"
+
+	cosmossdk_math "cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (k Keeper) MaintenanceCredit(ctx context.Context, req *types.QueryMaintenanceCreditRequest) (*types.QueryMaintenanceCreditResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	participantAddr, err := sdk.AccAddressFromBech32(req.Participant)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid participant address")
+	}
+
+	state, found := k.GetMaintenanceState(ctx, participantAddr)
+	if !found {
+		return &types.QueryMaintenanceCreditResponse{CreditBlocks: 0, Found: false}, nil
+	}
+
+	return &types.QueryMaintenanceCreditResponse{
+		CreditBlocks: state.CreditBlocks,
+		Found:        true,
+	}, nil
+}
+
+func (k Keeper) MaintenanceScheduled(ctx context.Context, req *types.QueryMaintenanceScheduledRequest) (*types.QueryMaintenanceScheduledResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	participantAddr, err := sdk.AccAddressFromBech32(req.Participant)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid participant address")
+	}
+
+	state, found := k.GetMaintenanceState(ctx, participantAddr)
+	if !found || state.ScheduledReservationId == 0 {
+		return &types.QueryMaintenanceScheduledResponse{Found: false}, nil
+	}
+
+	reservation, found := k.GetMaintenanceReservation(ctx, state.ScheduledReservationId)
+	if !found {
+		return &types.QueryMaintenanceScheduledResponse{Found: false}, nil
+	}
+
+	return &types.QueryMaintenanceScheduledResponse{
+		Reservation: &reservation,
+		Found:       true,
+	}, nil
+}
+
+func (k Keeper) MaintenanceActive(ctx context.Context, req *types.QueryMaintenanceActiveRequest) (*types.QueryMaintenanceActiveResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	var activeReservations []*types.MaintenanceReservation
+
+	// Iterate the active-reservation index instead of the full participant
+	// state map. This is O(A) where A is the number of currently active
+	// reservations (bounded by MaintenanceMaxConcurrentValidators) and
+	// further capped by maxMaintenanceIterationLimit as a DoS safeguard.
+	if err := k.iterateIndexedReservations(ctx, k.MaintenanceActiveIndex, func(r types.MaintenanceReservation) {
+		if r.Status == types.MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE {
+			r := r
+			activeReservations = append(activeReservations, &r)
+		}
+	}); err != nil {
+		return nil, status.Error(codes.Internal, "failed to iterate active maintenance index")
+	}
+
+	return &types.QueryMaintenanceActiveResponse{
+		Reservations: activeReservations,
+	}, nil
+}
+
+func (k Keeper) MaintenanceStatus(ctx context.Context, req *types.QueryMaintenanceStatusRequest) (*types.QueryMaintenanceStatusResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	participantAddr, err := sdk.AccAddressFromBech32(req.Participant)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid participant address")
+	}
+
+	state, found := k.GetMaintenanceState(ctx, participantAddr)
+	if !found {
+		return &types.QueryMaintenanceStatusResponse{Found: false}, nil
+	}
+
+	resp := &types.QueryMaintenanceStatusResponse{
+		State: &state,
+		Found: true,
+	}
+
+	if state.ActiveReservationId != 0 {
+		r, found := k.GetMaintenanceReservation(ctx, state.ActiveReservationId)
+		if found {
+			resp.ActiveReservation = &r
+		}
+	}
+
+	if state.ScheduledReservationId != 0 {
+		r, found := k.GetMaintenanceReservation(ctx, state.ScheduledReservationId)
+		if found {
+			resp.ScheduledReservation = &r
+		}
+	}
+
+	return resp, nil
+}
+
+func (k Keeper) MaintenanceConcurrency(ctx context.Context, req *types.QueryMaintenanceConcurrencyRequest) (*types.QueryMaintenanceConcurrencyResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	mp := k.GetMaintenanceParams(ctx)
+	if mp == nil {
+		return &types.QueryMaintenanceConcurrencyResponse{}, nil
+	}
+
+	targetHeight := req.Height
+	if targetHeight == 0 {
+		sdkCtx := sdk.UnwrapSDKContext(ctx)
+		targetHeight = sdkCtx.BlockHeight()
+	}
+
+	// Iterate the bounded set of ACTIVE + SCHEDULED reservations to find
+	// those covering targetHeight.
+	reservations, err := k.collectActiveAndScheduledReservations(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Internal, "failed to collect maintenance reservations")
+	}
+
+	concurrentCount := uint32(0)
+	concurrentPower := cosmossdk_math.ZeroInt()
+
+	// Per-query power cache: a participant may appear with both a scheduled and
+	// an active reservation that overlap targetHeight, and the bounded-but-
+	// large iteration cap (maxMaintenanceIterationLimit) means an attacker who
+	// stuffs the index could otherwise force up to 10000 staking lookups per
+	// public query. Memoize per bech32 string so each distinct participant
+	// costs exactly one staking lookup, regardless of reservation count.
+	powerCache := make(map[string]cosmossdk_math.Int)
+	seen := make(map[string]struct{})
+	for _, r := range reservations {
+		rEnd := r.StartHeight + int64(r.DurationBlocks) - 1
+		if r.StartHeight > targetHeight || rEnd < targetHeight {
+			continue
+		}
+		concurrentCount++
+		// Only count each participant's power once even if they appear in
+		// multiple overlapping reservations (e.g., scheduled + active edge).
+		if _, dup := seen[r.Participant]; dup {
+			continue
+		}
+		seen[r.Participant] = struct{}{}
+		power, cached := powerCache[r.Participant]
+		if !cached {
+			rAddr, addrErr := sdk.AccAddressFromBech32(r.Participant)
+			if addrErr != nil {
+				powerCache[r.Participant] = cosmossdk_math.ZeroInt()
+				continue
+			}
+			power = k.getParticipantPower(ctx, rAddr)
+			powerCache[r.Participant] = power
+		}
+		concurrentPower = concurrentPower.Add(power)
+	}
+
+	// Express power as basis points of total. All integer math; clamp to int64
+	// at the response boundary (bps fits comfortably in int64).
+	totalPower := k.getTotalConsensusPower(ctx)
+	var concurrentPowerBps int64
+	if totalPower.IsPositive() {
+		bps := concurrentPower.MulRaw(10000).Quo(totalPower)
+		if bps.IsInt64() {
+			concurrentPowerBps = bps.Int64()
+		} else {
+			concurrentPowerBps = 10000 // saturate
+		}
+	}
+
+	return &types.QueryMaintenanceConcurrencyResponse{
+		ConcurrentCount:    concurrentCount,
+		ConcurrentPowerBps: concurrentPowerBps,
+	}, nil
+}
+
+func (k Keeper) MaintenanceSchedulability(ctx context.Context, req *types.QueryMaintenanceSchedulabilityRequest) (*types.QueryMaintenanceSchedulabilityResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	blockHeight := sdkCtx.BlockHeight()
+
+	reject := func(reason string) (*types.QueryMaintenanceSchedulabilityResponse, error) {
+		return &types.QueryMaintenanceSchedulabilityResponse{Schedulable: false, RejectionReason: reason}, nil
+	}
+
+	mp := k.GetMaintenanceParams(ctx)
+	if mp == nil || !mp.MaintenanceEnabled {
+		return reject("maintenance windows are disabled")
+	}
+
+	participantAddr, err := sdk.AccAddressFromBech32(req.Participant)
+	if err != nil {
+		return reject("invalid participant address")
+	}
+
+	_, err = k.Participants.Get(ctx, participantAddr)
+	if err != nil {
+		return reject("participant not found")
+	}
+
+	if req.DurationBlocks == 0 {
+		return reject("duration_blocks must be positive")
+	}
+	if req.DurationBlocks > mp.MaintenanceMaxWindowBlocks {
+		return reject("duration exceeds maximum maintenance window blocks")
+	}
+
+	// Mirror the strict less-than check in ScheduleMaintenance: a request scheduled
+	// exactly MinScheduleLeadBlocks blocks ahead is accepted.
+	if req.StartHeight < blockHeight+int64(mp.MaintenanceMinScheduleLeadBlocks) {
+		return reject("start height does not satisfy minimum scheduling lead time")
+	}
+
+	state := k.GetOrCreateMaintenanceState(ctx, participantAddr)
+	if state.ScheduledReservationId != 0 {
+		return reject("participant already has a scheduled maintenance window")
+	}
+
+	if state.CreditBlocks < req.DurationBlocks {
+		return reject("insufficient maintenance credit")
+	}
+
+	if err := k.checkEpochPhaseOverlap(ctx, req.StartHeight, req.DurationBlocks, mp); err != nil {
+		return reject(err.Error())
+	}
+
+	if err := k.checkConcurrencyLimits(ctx, req.StartHeight, req.DurationBlocks, participantAddr, mp); err != nil {
+		return reject(err.Error())
+	}
+
+	if err := k.checkParticipantOverlap(ctx, participantAddr, req.StartHeight, req.DurationBlocks); err != nil {
+		return reject(err.Error())
+	}
+
+	return &types.QueryMaintenanceSchedulabilityResponse{Schedulable: true}, nil
+}
diff --git a/inference-chain/x/inference/keeper/safecast.go b/inference-chain/x/inference/keeper/safecast.go
index 73af46c305..3155a8857b 100644
--- a/inference-chain/x/inference/keeper/safecast.go
+++ b/inference-chain/x/inference/keeper/safecast.go
@@ -24,6 +24,15 @@ func safeUint32FromInt64(v int64) (uint32, error) {
 	return uint32(v), nil
 }
 
+// safeUint64FromInt64 converts int64 to uint64, returning error if the value
+// is negative.
+func safeUint64FromInt64(v int64) (uint64, error) {
+	if v < 0 {
+		return 0, fmt.Errorf("int64 value %d cannot be cast to uint64 (negative)", v)
+	}
+	return uint64(v), nil
+}
+
 // safeUint32FromUint64 converts uint64 to uint32, returning error if the value
 // exceeds MaxUint32.
 func safeUint32FromUint64(v uint64) (uint32, error) {
diff --git a/inference-chain/x/inference/keeper/safecast_test.go b/inference-chain/x/inference/keeper/safecast_test.go
index 1e0f804e32..d27920076b 100644
--- a/inference-chain/x/inference/keeper/safecast_test.go
+++ b/inference-chain/x/inference/keeper/safecast_test.go
@@ -67,6 +67,36 @@ func TestSafeUint32FromInt64(t *testing.T) {
 	}
 }
 
+func TestSafeUint64FromInt64(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   int64
+		want    uint64
+		wantErr bool
+	}{
+		{"zero", 0, 0, false},
+		{"one", 1, 1, false},
+		{"negative one", -1, 0, true},
+		{"MaxUint32", math.MaxUint32, math.MaxUint32, false},
+		{"MaxUint32+1", math.MaxUint32 + 1, math.MaxUint32 + 1, false},
+		{"MaxInt64", math.MaxInt64, math.MaxInt64, false},
+		{"negative MaxInt64", -math.MaxInt64, 0, true},
+		{"MinInt64", math.MinInt64, 0, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := safeUint64FromInt64(tt.input)
+			if tt.wantErr {
+				require.Error(t, err)
+				require.Equal(t, uint64(0), got)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
 func TestSafeUint32FromUint64(t *testing.T) {
 	tests := []struct {
 		name    string
diff --git a/inference-chain/x/inference/keeper/settle_amount_extreme_test.go b/inference-chain/x/inference/keeper/settle_amount_extreme_test.go
new file mode 100644
index 0000000000..54e4e40d63
--- /dev/null
+++ b/inference-chain/x/inference/keeper/settle_amount_extreme_test.go
@@ -0,0 +1,54 @@
+package keeper_test
+
+import (
+	"math"
+	"math/bits"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/testutil"
+	keepertest "github.com/productscience/inference/testutil/keeper"
+	"github.com/productscience/inference/x/inference/types"
+	"github.com/stretchr/testify/require"
+)
+
+// GetTotalCoins must saturate to MaxInt64 when RewardCoins+WorkCoins overflows uint64.
+func TestSettleAmount_StoredExtremeCoins_GetTotalCoinsSaturates(t *testing.T) {
+	k, ctx := keepertest.InferenceKeeper(t)
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	sa := types.SettleAmount{
+		Participant:   testutil.Creator,
+		EpochIndex:    1,
+		RewardCoins:   math.MaxUint64,
+		WorkCoins:     1,
+		SeedSignature: "",
+	}
+	require.NoError(t, k.SetSettleAmount(sdkCtx, sa))
+	loaded, found := k.GetSettleAmount(sdkCtx, testutil.Creator)
+	require.True(t, found)
+	require.Equal(t, uint64(math.MaxUint64), loaded.RewardCoins)
+	require.Equal(t, uint64(1), loaded.WorkCoins)
+	require.Equal(t, int64(math.MaxInt64), loaded.GetTotalCoins())
+}
+
+// SettleAccounts must distinguish a genuine zero payout (skip) from a uint64
+// wrap-to-zero (real payout owed). The bits.Add64 carry is the discriminator
+// the post-fix guard relies on at accountsettle.go:262
+// (`if paymentCarry == 0 && paymentSum == 0`).
+func TestSettleAmount_PaymentGuard_DistinguishesWrapFromGenuineZero(t *testing.T) {
+	// Wrap case: MaxUint64 + 1 yields paymentSum=0 with a real carry.
+	// The naive pre-fix check `WorkCoins+RewardCoins == 0` would skip; the
+	// post-fix `carry == 0 && sum == 0` does not.
+	wrapSum, wrapCarry := bits.Add64(math.MaxUint64, 1, 0)
+	require.Equal(t, uint64(0), wrapSum, "naive uint64 sum wraps to zero")
+	require.Equal(t, uint64(1), wrapCarry, "carry signals real overflow")
+	require.False(t, wrapCarry == 0 && wrapSum == 0,
+		"post-fix guard must NOT skip wrap-to-zero participant")
+
+	// Genuine zero: 0 + 0 yields paymentSum=0 with no carry. The guard skips.
+	zeroSum, zeroCarry := bits.Add64(0, 0, 0)
+	require.Equal(t, uint64(0), zeroSum)
+	require.Equal(t, uint64(0), zeroCarry)
+	require.True(t, zeroCarry == 0 && zeroSum == 0,
+		"post-fix guard must still skip genuine-zero participant")
+}
diff --git a/inference-chain/x/inference/keeper/test_account_helpers_test.go b/inference-chain/x/inference/keeper/test_account_helpers_test.go
new file mode 100644
index 0000000000..c0b89c5409
--- /dev/null
+++ b/inference-chain/x/inference/keeper/test_account_helpers_test.go
@@ -0,0 +1,94 @@
+package keeper_test
+
+import (
+	"context"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/productscience/inference/x/inference/keeper"
+	"github.com/productscience/inference/x/inference/types"
+	"github.com/stretchr/testify/require"
+)
+
+const MODEL_ID = "Qwen/QwQ-32B"
+
+type MockAccount struct {
+	*authtypes.BaseAccount
+	key     *secp256k1.PrivKey
+	address string
+}
+
+var _ sdk.AccountI = (*MockAccount)(nil)
+
+func NewMockAccount(address string) *MockAccount {
+	addr := sdk.MustAccAddressFromBech32(address)
+	key := secp256k1.GenPrivKey()
+	baseAccount := authtypes.NewBaseAccountWithAddress(addr)
+	_ = baseAccount.SetPubKey(key.PubKey())
+	return &MockAccount{
+		BaseAccount: baseAccount,
+		key:         key,
+		address:     address,
+	}
+}
+
+func (m MockAccount) GetAddress() sdk.AccAddress {
+	return sdk.MustAccAddressFromBech32(m.address)
+}
+
+func (m MockAccount) SetAddress(sdk.AccAddress) error {
+	return nil
+}
+
+func (m MockAccount) GetPubKey() cryptotypes.PubKey {
+	return m.key.PubKey()
+}
+
+func (m MockAccount) SetPubKey(cryptotypes.PubKey) error {
+	return nil
+}
+
+func (m MockAccount) GetAccountNumber() uint64 {
+	return 0
+}
+
+func (m MockAccount) SetAccountNumber(uint64) error {
+	return nil
+}
+
+func (m MockAccount) GetSequence() uint64 {
+	return 0
+}
+
+func (m MockAccount) SetSequence(uint64) error {
+	return nil
+}
+
+func (m MockAccount) String() string {
+	return m.address
+}
+
+func (m MockAccount) GetBechAddress() sdk.AccAddress {
+	return m.GetAddress()
+}
+
+func MustAddParticipant(t require.TestingT, ms types.MsgServer, ctx context.Context, mockAccount MockAccount) {
+	_, err := ms.SubmitNewParticipant(ctx, &types.MsgSubmitNewParticipant{
+		Creator:      mockAccount.address,
+		Url:          "url",
+		ValidatorKey: mockAccount.GetPubKey().String(),
+	})
+	require.NoError(t, err)
+}
+
+func AddParticipantToActive(ctx sdk.Context, k *keeper.Keeper, address string, epochID int64) {
+	participant := types.Participant{
+		Index:   address,
+		Address: address,
+		Status:  types.ParticipantStatus_ACTIVE,
+	}
+	_ = k.SetParticipant(ctx, participant)
+	_ = k.SetActiveParticipants(ctx, ParticipantsToActive(epochID, participant))
+}
diff --git a/inference-chain/x/inference/module/autocli.go b/inference-chain/x/inference/module/autocli.go
index d9579f2aad..1f7344933e 100644
--- a/inference-chain/x/inference/module/autocli.go
+++ b/inference-chain/x/inference/module/autocli.go
@@ -217,6 +217,12 @@ func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
 					Short:          "Shows a partial_upgrade",
 					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "height"}},
 				},
+				{
+					RpcMethod:      "LastUpgradeHeight",
+					Use:            "last-upgrade-height",
+					Short:          "Shows the most recent applied upgrade height",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{},
+				},
 				{
 					RpcMethod:      "GetAllModelCapacities",
 					Use:            "all-model-capacities",
@@ -288,12 +294,60 @@ func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
 					Short:          "Query a devshard escrow by ID",
 					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "id"}},
 				},
+				{
+					RpcMethod:      "MaintenanceCredit",
+					Use:            "maintenance-credit [participant]",
+					Short:          "Query maintenance credit for a participant",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}},
+				},
+				{
+					RpcMethod:      "MaintenanceScheduled",
+					Use:            "maintenance-scheduled [participant]",
+					Short:          "Query scheduled maintenance windows for a participant",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}},
+				},
+				{
+					RpcMethod:      "MaintenanceActive",
+					Use:            "maintenance-active",
+					Short:          "Query all currently active maintenance windows",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{},
+				},
+				{
+					RpcMethod:      "MaintenanceStatus",
+					Use:            "maintenance-status [participant]",
+					Short:          "Query maintenance status for a participant",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}},
+				},
+				{
+					RpcMethod:      "MaintenanceConcurrency",
+					Use:            "maintenance-concurrency [target-height]",
+					Short:          "Query concurrent reserved participant count and power at a given height",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "height"}},
+				},
+				{
+					RpcMethod:      "MaintenanceSchedulability",
+					Use:            "maintenance-schedulability [participant] [start-height] [duration-blocks]",
+					Short:          "Query whether a proposed maintenance window is schedulable",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}, {ProtoField: "start_height"}, {ProtoField: "duration_blocks"}},
+				},
 				{
 					RpcMethod:      "PoCDelegation",
 					Use:            "poc-delegation [participant] [model-id]",
 					Short:          "Query PoC delegation state for a participant",
 					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}, {ProtoField: "model_id", Optional: true}},
 				},
+				{
+					RpcMethod:      "EstimateBitcoinReward",
+					Use:            "estimate-bitcoin-reward [participant]",
+					Short:          "Estimate Bitcoin-style reward for a participant using the current reward snapshot",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}},
+				},
+				{
+					RpcMethod:      "ListClaimRecipients",
+					Use:            "list-claim-recipients [participant]",
+					Short:          "List the scheduled per-epoch claim recipient overrides for a participant",
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "participant"}},
+				},
 				// this line is used by ignite scaffolding # autocli/query
 			},
 		},
diff --git a/inference-chain/x/inference/module/chainvalidation.go b/inference-chain/x/inference/module/chainvalidation.go
index 102eb3aadb..bb9cc7b560 100644
--- a/inference-chain/x/inference/module/chainvalidation.go
+++ b/inference-chain/x/inference/module/chainvalidation.go
@@ -169,11 +169,14 @@ func (wc *PoCWeightCalculator) validatedParticipant(key types.PoCParticipantMode
 		return nil
 	}
 
-	vals := wc.getParticipantValidations(key)
-	if len(vals) == 0 {
+	// Reject only when nobody voted at all. The weight-filtered list may be
+	// empty while guardian votes are still present in the raw list; those must
+	// reach the guardian tiebreaker in pocValidated.
+	if len(wc.Validations[key]) == 0 {
 		wc.Logger.LogError("Calculate: No validations for participant found", types.PoC, "participant", key.ParticipantAddress, "modelId", key.ModelID)
 		return nil
 	}
+	vals := wc.getParticipantValidations(key)
 
 	// Get claimed weight from store commit and per-node weights from distribution
 	nodeWeights, claimedWeight := wc.calculateParticipantWeight(key)
@@ -236,9 +239,11 @@ func (wc *PoCWeightCalculator) getParticipantValidations(key types.PoCParticipan
 		"participant", key.ParticipantAddress, "modelId", key.ModelID, "len(vals)", len(vals), "validators", validators)
 
 	// Filter to validations from participants with voting power for this model.
+	// The filtered list feeds the majority math only; the guardian tiebreaker
+	// reads the raw wc.Validations[key] list directly (see guardianProtection).
 	// When no voting-power snapshot exists for the model yet, keep the original
-	// validations list for logging and guardian handling. pocValidated() still
-	// rejects later if the model has no voting-power data.
+	// validations list. pocValidated() still rejects later if the model has no
+	// voting-power data.
 	modelVP := wc.ModelVotingPowers[key.ModelID]
 	filteredVals := make([]types.PoCValidationV2, 0, len(vals))
 	if len(modelVP) == 0 {
@@ -314,7 +319,7 @@ func (wc *PoCWeightCalculator) pocValidated(vals []types.PoCValidationV2, key ty
 				"invalidSlots", invalidSlots, "totalSlots", totalSlots)
 			return false
 		}
-		return wc.guardianProtection(vals, key, ValidationOutcome{
+		return wc.guardianProtection(key, ValidationOutcome{
 			TotalWeight:   totalSlots,
 			ValidWeight:   validSlots,
 			InvalidWeight: invalidSlots,
@@ -337,7 +342,7 @@ func (wc *PoCWeightCalculator) pocValidated(vals []types.PoCValidationV2, key ty
 			"invalidWeight", outcome.InvalidWeight, "totalNetworkWeight", wc.TotalNetworkWeight)
 		return false
 	}
-	return wc.guardianProtection(vals, key, outcome)
+	return wc.guardianProtection(key, outcome)
 }
 
 // ValidationOutcome holds aggregated vote weight sums.
@@ -349,7 +354,12 @@ type ValidationOutcome struct {
 
 // guardianProtection handles tie-breaking when no clear majority exists.
 // All voting guardians must agree unanimously for the decision to pass.
-func (wc *PoCWeightCalculator) guardianProtection(vals []types.PoCValidationV2, key types.PoCParticipantModelKey, outcome ValidationOutcome) bool {
+// Guardian votes are read from the raw (unfiltered) validation list: a guardian
+// may have no voting weight for the model (e.g. it could not run the model this
+// epoch), and its tiebreaker vote must still count. This does not affect the
+// majority math above, which only ever counts weight-filtered or slot-assigned
+// votes.
+func (wc *PoCWeightCalculator) guardianProtection(key types.PoCParticipantModelKey, outcome ValidationOutcome) bool {
 	if !wc.GuardianEnabled || len(wc.GuardianAddresses) == 0 {
 		wc.Logger.LogWarn("Calculate: No majority and no guardians. Rejecting.", types.PoC,
 			"participant", key.ParticipantAddress,
@@ -362,7 +372,7 @@ func (wc *PoCWeightCalculator) guardianProtection(vals []types.PoCValidationV2,
 	}
 
 	guardianValidCount, guardianInvalidCount := 0, 0
-	for _, v := range vals {
+	for _, v := range wc.Validations[key] {
 		if wc.GuardianAddresses[v.ValidatorParticipantAddress] {
 			if v.ValidatedWeight > 0 {
 				guardianValidCount++
diff --git a/inference-chain/x/inference/module/commands.go b/inference-chain/x/inference/module/commands.go
index 5e28792b3b..fa5bfc016d 100644
--- a/inference-chain/x/inference/module/commands.go
+++ b/inference-chain/x/inference/module/commands.go
@@ -122,8 +122,8 @@ type settlementHostStatsJSON struct {
 	Missed               uint32 `json:"missed"`
 	Invalid              uint32 `json:"invalid"`
 	Cost                 uint64 `json:"cost"`
-	RequiredValidations  uint32 `json:"required_validations"`
-	CompletedValidations uint32 `json:"completed_validations"`
+	RequiredValidations  uint32 `json:"required_validations,omitempty"`
+	CompletedValidations uint32 `json:"completed_validations,omitempty"`
 }
 
 type slotSignatureJSON struct {
@@ -213,3 +213,39 @@ func SettleDevshardEscrowCmd() *cobra.Command {
 	flags.AddTxFlagsToCmd(cmd)
 	return cmd
 }
+
+func SetClaimRecipientsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "set-claim-recipients <entries-json>",
+		Short: "Configure per-epoch claim recipient overrides (cold key only)",
+		Long: `Batch-configures recipient overrides for MsgClaimRewards on future epochs.
+
+Pass a JSON array of {epoch, recipient} entries. An empty recipient clears the
+override for that epoch.
+
+Example:
+  inferenced tx inference set-claim-recipients '[{"epoch":123,"recipient":"gonka1..."}]' --from cold-key`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			var entries []types.ClaimRecipientEntry
+			if err := json.Unmarshal([]byte(args[0]), &entries); err != nil {
+				return fmt.Errorf("parse entries JSON: %w", err)
+			}
+
+			msg := &types.MsgSetClaimRecipients{
+				Creator: clientCtx.GetFromAddress().String(),
+				Entries: entries,
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+	return cmd
+}
diff --git a/inference-chain/x/inference/module/confirmation_poc.go b/inference-chain/x/inference/module/confirmation_poc.go
index ed3ced544c..3424f6f6cf 100644
--- a/inference-chain/x/inference/module/confirmation_poc.go
+++ b/inference-chain/x/inference/module/confirmation_poc.go
@@ -434,7 +434,12 @@ func (am AppModule) evaluateConfirmation(
 	preserved := preservedWeightByParticipant(activeParticipants, &preservedSnapshot, presentScales)
 	totalExpected := weightByParticipant(activeParticipants, presentScales)
 
-	updated, ratios := foldEventReadings(epochGroupData, measured, preserved, totalExpected)
+	// Maintenance-covered participants are expected to be offline: skip both the
+	// ConfirmationWeight haircut and the CPoC ratio write so absence is not
+	// punished via rewards or INACTIVE status.
+	maintenanceAddrs := am.keeper.CollectActiveMaintenanceAddresses(ctx)
+
+	updated, ratios := foldEventReadings(epochGroupData, measured, preserved, totalExpected, maintenanceAddrs)
 	if updated {
 		am.LogInfo("evaluateConfirmation: confirmation weights lowered", types.PoC,
 			"epochIndex", event.EpochIndex,
@@ -468,14 +473,20 @@ func (am AppModule) evaluateConfirmation(
 
 // foldEventReadings applies this event's reading (preserved + measured) to every
 // ValidationWeight via min-take and returns the per-participant slashing ratio.
+// Participants in skipAddrs (e.g. active maintenance) are left untouched: no
+// ConfirmationWeight change and no ratio entry.
 // Pure: no keeper reads, no logging. Caller persists the result.
 func foldEventReadings(
 	epochGroupData *types.EpochGroupData,
 	measured, preserved, totalExpected map[string]int64,
+	skipAddrs map[string]struct{},
 ) (updated bool, ratios map[string]*types.Decimal) {
 	ratios = make(map[string]*types.Decimal, len(epochGroupData.ValidationWeights))
 	for i, vw := range epochGroupData.ValidationWeights {
 		addr := vw.MemberAddress
+		if _, skip := skipAddrs[addr]; skip {
+			continue
+		}
 		reading := preserved[addr] + measured[addr]
 		if totalExpected[addr] == 0 {
 			continue
diff --git a/inference-chain/x/inference/module/confirmation_poc_test.go b/inference-chain/x/inference/module/confirmation_poc_test.go
index 4eca8c751c..46845d92b4 100644
--- a/inference-chain/x/inference/module/confirmation_poc_test.go
+++ b/inference-chain/x/inference/module/confirmation_poc_test.go
@@ -27,6 +27,7 @@ func TestFoldEventReadings_RotatingPreservedHonestThenDishonest(t *testing.T) {
 		map[string]int64{addr: 1},  // measured from node-B
 		map[string]int64{addr: 10}, // preservedHere
 		map[string]int64{addr: 11}, // formation-time expected
+		nil,
 	)
 	require.False(t, updated, "honest reading equal to initial must not lower ConfirmationWeight")
 	require.Equal(t, int64(11), initial.ValidationWeights[0].ConfirmationWeight)
@@ -39,6 +40,7 @@ func TestFoldEventReadings_RotatingPreservedHonestThenDishonest(t *testing.T) {
 		map[string]int64{addr: 10},
 		map[string]int64{addr: 1},
 		map[string]int64{addr: 11},
+		nil,
 	)
 	require.False(t, updated, "honest reading with rotated preservation must also stay at 11")
 	require.Equal(t, int64(11), initial.ValidationWeights[0].ConfirmationWeight)
@@ -51,6 +53,7 @@ func TestFoldEventReadings_RotatingPreservedHonestThenDishonest(t *testing.T) {
 		map[string]int64{addr: 4},
 		map[string]int64{addr: 1},
 		map[string]int64{addr: 11},
+		nil,
 	)
 	require.True(t, updated, "dishonest event must lower ConfirmationWeight")
 	require.Equal(t, int64(5), initial.ValidationWeights[0].ConfirmationWeight)
@@ -78,6 +81,7 @@ func TestFoldEventReadings_AllPreservedZeroMeasuredIsNotPenalized(t *testing.T)
 		map[string]int64{addr: 0},   // participant submitted nothing for this event
 		map[string]int64{addr: 100}, // every one of their nodes was preserved this event
 		map[string]int64{addr: 100},
+		nil,
 	)
 
 	require.False(t, updated)
@@ -102,6 +106,7 @@ func TestFoldEventReadings_EmptyEventKeepsRatioAtOne(t *testing.T) {
 		map[string]int64{},
 		map[string]int64{},
 		map[string]int64{},
+		nil,
 	)
 
 	require.False(t, updated)
@@ -109,6 +114,34 @@ func TestFoldEventReadings_EmptyEventKeepsRatioAtOne(t *testing.T) {
 	require.NotContains(t, ratios, addr)
 }
 
+// Maintenance-covered participants must keep prior ConfirmationWeight and get
+// no ratio entry, even when measured weight is zero (offline during the window).
+func TestFoldEventReadings_MaintenanceExemptSkipsWeightAndRatio(t *testing.T) {
+	maint := "maintenance-host"
+	other := "online-host"
+	ege := &types.EpochGroupData{
+		EpochIndex: 1,
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: maint, Weight: 100, ConfirmationWeight: 100},
+			{MemberAddress: other, Weight: 50, ConfirmationWeight: 50},
+		},
+	}
+
+	updated, ratios := foldEventReadings(
+		ege,
+		map[string]int64{maint: 0, other: 10},
+		map[string]int64{maint: 0, other: 0},
+		map[string]int64{maint: 100, other: 50},
+		map[string]struct{}{maint: {}},
+	)
+
+	require.True(t, updated, "online host with poor reading must still be folded")
+	require.Equal(t, int64(100), ege.ValidationWeights[0].ConfirmationWeight, "maintenance host weight preserved")
+	require.Equal(t, int64(10), ege.ValidationWeights[1].ConfirmationWeight, "online host weight lowered")
+	require.NotContains(t, ratios, maint)
+	require.Contains(t, ratios, other)
+}
+
 func TestConfirmationScalesInSnapshot(t *testing.T) {
 	scales := []*types.ConfirmationWeightScale{
 		{ModelId: "model-a", WeightScaleFactor: types.DecimalFromFloat(1)},
diff --git a/inference-chain/x/inference/module/delegation_pipeline.go b/inference-chain/x/inference/module/delegation_pipeline.go
index 8b1efcefaa..896aef768f 100644
--- a/inference-chain/x/inference/module/delegation_pipeline.go
+++ b/inference-chain/x/inference/module/delegation_pipeline.go
@@ -923,7 +923,7 @@ func emitWeightPipelineLogs(
 	eligibleModels []string,
 	participants []*types.ActiveParticipant,
 	modes map[string]map[string]ParticipationMode,
-	consensus, afterPenalty map[string]int64,
+	consensus, beforeCollateral map[string]int64,
 	acc *PenaltyAccumulator,
 ) {
 	for _, g := range groups {
@@ -949,10 +949,8 @@ func emitWeightPipelineLogs(
 			"addr", p.Index,
 			"modes", formatModes(p.Index, eligibleModels, modes),
 			"consensus", consensus[p.Index],
-			"penalty", acc.AppliedFraction(p.Index).String(),
-			"transfer_in", acc.TransferIn(p.Index),
-			"transfer_out", acc.TransferOut(p.Index),
-			"after_penalty", afterPenalty[p.Index],
+			"reward_penalty", acc.AppliedFraction(p.Index).String(),
+			"before_collateral", beforeCollateral[p.Index],
 			"final", p.Weight,
 			"vp", formatVotingPowers(p.VotingPowers),
 		)
diff --git a/inference-chain/x/inference/module/delegation_weight_adjustment.go b/inference-chain/x/inference/module/delegation_weight_adjustment.go
index 677cdeea00..79188a004a 100644
--- a/inference-chain/x/inference/module/delegation_weight_adjustment.go
+++ b/inference-chain/x/inference/module/delegation_weight_adjustment.go
@@ -6,6 +6,7 @@ import (
 
 	mathsdk "cosmossdk.io/math"
 	"github.com/productscience/inference/x/inference/types"
+	"github.com/shopspring/decimal"
 )
 
 type DelegationAdjustmentParams struct {
@@ -18,32 +19,18 @@ func (p DelegationAdjustmentParams) IsNoOp() bool {
 	return p.RefusalPenalty.IsZero() && p.NoParticipationPenalty.IsZero() && p.DelegationShare.IsZero()
 }
 
-type pendingTransfer struct {
-	from string
-	to   string
-	rate mathsdk.LegacyDec
-}
-
 // PenaltyAccumulator collects penalty fractions from all sources (delegation +
-// bootstrap) and applies them as a single additive deduction capped at 1.0.
+// bootstrap) and emits them as reward-only penalties capped at 1.0.
 //
 // DIRECT participants are never penalized. For non-DIRECT participants:
 //   - REFUSE:   fraction += refusal_penalty per model
 //   - NONE:     fraction += no_participation_penalty per model
-//   - DELEGATE: transfers delegation_share of original weight to delegate target
 //
-// Penalties sum across models and cap at 1.0. Transfer delta is based on
-// original weight but clamped to the sender's remaining weight to preserve
-// weight conservation.
+// Penalties sum across models and cap at 1.0.
 // When all delegation adjustment values are 0, this is a complete no-op.
 type PenaltyAccumulator struct {
 	penalties      map[string]mathsdk.LegacyDec
-	transfers      []pendingTransfer
 	originalWeight map[string]int64
-
-	appliedFraction map[string]mathsdk.LegacyDec
-	transferIn      map[string]int64
-	transferOut     map[string]int64
 }
 
 func NewPenaltyAccumulator(participants []*types.ActiveParticipant) *PenaltyAccumulator {
@@ -52,24 +39,26 @@ func NewPenaltyAccumulator(participants []*types.ActiveParticipant) *PenaltyAccu
 		original[p.Index] = p.Weight
 	}
 	return &PenaltyAccumulator{
-		penalties:       make(map[string]mathsdk.LegacyDec),
-		originalWeight:  original,
-		appliedFraction: make(map[string]mathsdk.LegacyDec),
-		transferIn:      make(map[string]int64),
-		transferOut:     make(map[string]int64),
+		penalties:      make(map[string]mathsdk.LegacyDec),
+		originalWeight: original,
 	}
 }
 
 func (pa *PenaltyAccumulator) AppliedFraction(addr string) mathsdk.LegacyDec {
-	if f, ok := pa.appliedFraction[addr]; ok {
-		return f
+	if pa == nil {
+		return mathsdk.LegacyZeroDec()
 	}
-	return mathsdk.LegacyZeroDec()
+	f, ok := pa.penalties[addr]
+	if !ok {
+		return mathsdk.LegacyZeroDec()
+	}
+	one := mathsdk.LegacyOneDec()
+	if f.GT(one) {
+		return one
+	}
+	return f
 }
 
-func (pa *PenaltyAccumulator) TransferIn(addr string) int64  { return pa.transferIn[addr] }
-func (pa *PenaltyAccumulator) TransferOut(addr string) int64 { return pa.transferOut[addr] }
-
 func (pa *PenaltyAccumulator) AddPenalty(addr string, fraction mathsdk.LegacyDec) {
 	if existing, ok := pa.penalties[addr]; ok {
 		pa.penalties[addr] = existing.Add(fraction)
@@ -78,61 +67,44 @@ func (pa *PenaltyAccumulator) AddPenalty(addr string, fraction mathsdk.LegacyDec
 	}
 }
 
-func (pa *PenaltyAccumulator) AddTransfer(from, to string, rate mathsdk.LegacyDec) {
-	pa.transfers = append(pa.transfers, pendingTransfer{from: from, to: to, rate: rate})
-}
-
-func (pa *PenaltyAccumulator) Apply(participants []*types.ActiveParticipant) {
-	one := mathsdk.LegacyOneDec()
-	weightIndex := make(map[string]*types.ActiveParticipant, len(participants))
-	for _, p := range participants {
-		weightIndex[p.Index] = p
+func (pa *PenaltyAccumulator) RewardPenalties() []*types.DelegationRewardPenalty {
+	if pa == nil {
+		return nil
 	}
-
+	penalties := make([]*types.DelegationRewardPenalty, 0, len(pa.penalties))
 	for _, addr := range sortedKeys(pa.penalties) {
-		totalFrac := pa.penalties[addr]
-		p := weightIndex[addr]
-		if p == nil || pa.originalWeight[addr] <= 0 {
+		if pa.originalWeight[addr] <= 0 {
 			continue
 		}
-		if totalFrac.GT(one) {
-			totalFrac = one
-		}
-		pa.appliedFraction[addr] = totalFrac
-		penalty := totalFrac.MulInt64(pa.originalWeight[addr]).TruncateInt64()
-		p.Weight -= penalty
-		if p.Weight < 0 {
-			p.Weight = 0
+		fraction := pa.AppliedFraction(addr)
+		if fraction.IsZero() {
+			continue
 		}
+		penalties = append(penalties, &types.DelegationRewardPenalty{
+			Participant:     addr,
+			PenaltyFraction: legacyDecToProto(fraction),
+		})
 	}
+	return penalties
+}
 
-	slices.SortFunc(pa.transfers, func(a, b pendingTransfer) int {
-		return cmp.Or(
-			cmp.Compare(a.from, b.from),
-			cmp.Compare(a.to, b.to),
-		)
-	})
-	for _, t := range pa.transfers {
-		from := weightIndex[t.from]
-		if from == nil {
-			continue
-		}
-		to := weightIndex[t.to]
-		if to == nil {
-			continue
-		}
-		delta := t.rate.MulInt64(pa.originalWeight[t.from]).TruncateInt64()
-		if delta > from.Weight {
-			delta = from.Weight
-		}
-		if delta < 0 {
-			delta = 0
-		}
-		from.Weight -= delta
-		to.Weight += delta
-		pa.transferOut[t.from] += delta
-		pa.transferIn[t.to] += delta
+type DelegationRewardTransfers struct {
+	transfers []*types.DelegationRewardTransfer
+}
+
+func (rt *DelegationRewardTransfers) Records() []*types.DelegationRewardTransfer {
+	if rt == nil {
+		return nil
+	}
+	return rt.transfers
+}
+
+func legacyDecToProto(d mathsdk.LegacyDec) *types.Decimal {
+	parsed, err := decimal.NewFromString(d.String())
+	if err != nil {
+		return &types.Decimal{Value: 0, Exponent: 0}
 	}
+	return types.DecimalFromDecimal(parsed)
 }
 
 func penaltyStartReached(modelID string, upcomingEpochIndex uint64, penaltyStartEpochByModel map[string]uint64) bool {
@@ -185,14 +157,65 @@ func AccumulateDelegationPenalties(
 					acc.AddPenalty(addr, params.NoParticipationPenalty)
 				}
 			case ModeDelegate:
-				if !params.DelegationShare.IsZero() {
-					if modelDelegations, ok := dwc.Delegations[modelID]; ok {
-						if delegateTo, ok := modelDelegations[addr]; ok {
-							acc.AddTransfer(addr, delegateTo, params.DelegationShare)
-						}
-					}
-				}
+				continue
 			}
 		}
 	}
 }
+
+func BuildDelegationRewardTransfers(
+	dwc *DelegationWeightCalculator,
+	eligibleModels []string,
+	modes map[string]map[string]ParticipationMode,
+	params DelegationAdjustmentParams,
+	upcomingEpochIndex uint64,
+	penaltyStartEpochByModel map[string]uint64,
+) *DelegationRewardTransfers {
+	if dwc == nil || params.DelegationShare.IsZero() {
+		return &DelegationRewardTransfers{}
+	}
+
+	var transfers []*types.DelegationRewardTransfer
+	for _, modelID := range eligibleModels {
+		if !penaltyStartReached(modelID, upcomingEpochIndex, penaltyStartEpochByModel) {
+			continue
+		}
+		groupModes := modes[modelID]
+		if groupModes == nil {
+			continue
+		}
+		modelDelegations := dwc.Delegations[modelID]
+		if modelDelegations == nil {
+			continue
+		}
+
+		for _, addr := range sortedKeys(groupModes) {
+			if groupModes[addr] != ModeDelegate {
+				continue
+			}
+			delegateTo := modelDelegations[addr]
+			if delegateTo == "" {
+				continue
+			}
+			transfers = append(transfers, &types.DelegationRewardTransfer{
+				ModelId: modelID,
+				From:    addr,
+				To:      delegateTo,
+				Share:   legacyDecToProto(params.DelegationShare),
+			})
+		}
+	}
+
+	sortDelegationRewardTransfers(transfers)
+	return &DelegationRewardTransfers{transfers: transfers}
+}
+
+func sortDelegationRewardTransfers(transfers []*types.DelegationRewardTransfer) {
+	slices.SortFunc(transfers, func(a, b *types.DelegationRewardTransfer) int {
+		return cmp.Or(
+			cmp.Compare(a.GetFrom(), b.GetFrom()),
+			cmp.Compare(a.GetTo(), b.GetTo()),
+			cmp.Compare(a.GetModelId(), b.GetModelId()),
+		)
+	})
+}
diff --git a/inference-chain/x/inference/module/delegation_weight_adjustment_test.go b/inference-chain/x/inference/module/delegation_weight_adjustment_test.go
index aa77505386..13dbdf85cd 100644
--- a/inference-chain/x/inference/module/delegation_weight_adjustment_test.go
+++ b/inference-chain/x/inference/module/delegation_weight_adjustment_test.go
@@ -8,7 +8,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func applyDelegationPenalties(
+func buildAdjustmentsForTest(
+	t *testing.T,
 	participants []*types.ActiveParticipant,
 	dwc *DelegationWeightCalculator,
 	eligibleModels []string,
@@ -16,10 +17,30 @@ func applyDelegationPenalties(
 	params DelegationAdjustmentParams,
 	upcomingEpochIndex uint64,
 	penaltyStartEpochByModel map[string]uint64,
-) {
+) ([]*types.DelegationRewardPenalty, []*types.DelegationRewardTransfer) {
+	t.Helper()
 	acc := NewPenaltyAccumulator(participants)
 	AccumulateDelegationPenalties(acc, dwc, eligibleModels, modes, params, upcomingEpochIndex, penaltyStartEpochByModel)
-	acc.Apply(participants)
+	rewardTransfers := BuildDelegationRewardTransfers(dwc, eligibleModels, modes, params, upcomingEpochIndex, penaltyStartEpochByModel)
+	return acc.RewardPenalties(), rewardTransfers.Records()
+}
+
+func requireTransfer(t *testing.T, transfer *types.DelegationRewardTransfer, modelID, from, to string, share mathsdk.LegacyDec) {
+	t.Helper()
+	require.Equal(t, modelID, transfer.ModelId)
+	require.Equal(t, from, transfer.From)
+	require.Equal(t, to, transfer.To)
+	got, err := transfer.Share.ToLegacyDec()
+	require.NoError(t, err)
+	require.True(t, share.Equal(got), "expected %s, got %s", share.String(), got.String())
+}
+
+func requirePenalty(t *testing.T, penalty *types.DelegationRewardPenalty, participant string, fraction mathsdk.LegacyDec) {
+	t.Helper()
+	require.Equal(t, participant, penalty.Participant)
+	got, err := penalty.PenaltyFraction.ToLegacyDec()
+	require.NoError(t, err)
+	require.True(t, fraction.Equal(got), "expected %s, got %s", fraction.String(), got.String())
 }
 
 func TestAccumulateDelegationPenalties_NoOp(t *testing.T) {
@@ -33,8 +54,10 @@ func TestAccumulateDelegationPenalties_NoOp(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyZeroDec(),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, nil, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, nil, params, 1, nil)
 	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, penalties)
+	require.Empty(t, transfers)
 }
 
 func TestAccumulateDelegationPenalties_DirectNoPenalty(t *testing.T) {
@@ -51,8 +74,10 @@ func TestAccumulateDelegationPenalties_DirectNoPenalty(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.05"),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, modes, params, 1, nil)
 	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, penalties)
+	require.Empty(t, transfers)
 }
 
 func TestAccumulateDelegationPenalties_RefusePenalty(t *testing.T) {
@@ -69,8 +94,11 @@ func TestAccumulateDelegationPenalties_RefusePenalty(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyZeroDec(),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, modes, params, 1, nil)
-	require.Equal(t, int64(850), participants[0].Weight)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, modes, params, 1, nil)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, transfers)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyMustNewDecFromStr("0.15"))
 }
 
 func TestAccumulateDelegationPenalties_DelegateTransfer(t *testing.T) {
@@ -95,11 +123,46 @@ func TestAccumulateDelegationPenalties_DelegateTransfer(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.1"),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, modes, params, 1, nil)
 
 	// alice delegates 10% to bob
-	require.Equal(t, int64(900), participants[0].Weight)
-	require.Equal(t, int64(600), participants[1].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Equal(t, int64(500), participants[1].Weight)
+	require.Empty(t, penalties)
+	require.Len(t, transfers, 1)
+	requireTransfer(t, transfers[0], "model1", "alice", "bob", mathsdk.LegacyMustNewDecFromStr("0.1"))
+}
+
+func TestBuildDelegationRewardTransfers_RewardOnlyDoesNotChangeConsensusWeight(t *testing.T) {
+	participants := []*types.ActiveParticipant{
+		{Index: "alice", Weight: 1000},
+		{Index: "bob", Weight: 500},
+	}
+	dwc := &DelegationWeightCalculator{
+		Delegations: map[string]map[string]string{
+			"model1": {"alice": "bob"},
+		},
+	}
+	modes := map[string]map[string]ParticipationMode{
+		"model1": {
+			"alice": ModeDelegate,
+			"bob":   ModeDirect,
+		},
+	}
+	params := DelegationAdjustmentParams{
+		RefusalPenalty:         mathsdk.LegacyZeroDec(),
+		NoParticipationPenalty: mathsdk.LegacyZeroDec(),
+		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.1"),
+	}
+
+	acc := NewPenaltyAccumulator(participants)
+	AccumulateDelegationPenalties(acc, dwc, []string{"model1"}, modes, params, 1, nil)
+	rewardTransfers := BuildDelegationRewardTransfers(dwc, []string{"model1"}, modes, params, 1, nil)
+
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Equal(t, int64(500), participants[1].Weight)
+	require.Len(t, rewardTransfers.Records(), 1)
+	requireTransfer(t, rewardTransfers.Records()[0], "model1", "alice", "bob", mathsdk.LegacyMustNewDecFromStr("0.1"))
 }
 
 func TestAccumulateDelegationPenalties_MissingRecipientDoesNotBurnTransfer(t *testing.T) {
@@ -123,16 +186,19 @@ func TestAccumulateDelegationPenalties_MissingRecipientDoesNotBurnTransfer(t *te
 		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.1"),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, modes, params, 1, nil)
 
 	// bob is absent from the active participant set, so delegation_share
-	// must be skipped rather than burned.
+	// is recorded for settlement, where zero-rewardable receivers are not revived.
 	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, penalties)
+	require.Len(t, transfers, 1)
+	requireTransfer(t, transfers[0], "model1", "alice", "bob", mathsdk.LegacyMustNewDecFromStr("0.1"))
 }
 
 func TestAccumulateDelegationPenalties_TransferClampedByPenalty(t *testing.T) {
-	// When penalties reduce weight below the transfer delta, the recipient
-	// should only receive what remains -- not the full original-weight-based delta.
+	// Penalties and transfers are recorded separately; settlement applies the
+	// penalty before the transfer so the transfer reads post-penalty weight.
 	participants := []*types.ActiveParticipant{
 		{Index: "alice", Weight: 1000},
 		{Index: "bob", Weight: 500},
@@ -154,18 +220,14 @@ func TestAccumulateDelegationPenalties_TransferClampedByPenalty(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.3"),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1", "model2", "model3", "model4"}, modes, params, 1, nil)
-
-	// Penalty: 3 refusals * 0.2 = 0.6, deducts 600 from 1000 -> 400 remaining
-	// Transfer: 0.3 * 1000 = 300 desired, but only 400 available -> transfers 300
-	// Alice: 1000 - 600 - 300 = 100
-	// Bob: 500 + 300 = 800
-	require.Equal(t, int64(100), participants[0].Weight)
-	require.Equal(t, int64(800), participants[1].Weight)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1", "model2", "model3", "model4"}, modes, params, 1, nil)
 
-	// Verify weight conservation: total before = 1500, penalty destroys 600
-	// total after should be 1500 - 600 = 900
-	require.Equal(t, int64(900), participants[0].Weight+participants[1].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Equal(t, int64(500), participants[1].Weight)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyMustNewDecFromStr("0.6"))
+	require.Len(t, transfers, 1)
+	requireTransfer(t, transfers[0], "model2", "alice", "bob", mathsdk.LegacyMustNewDecFromStr("0.3"))
 }
 
 func TestAccumulateDelegationPenalties_TransferFullyClampedByPenalty(t *testing.T) {
@@ -192,14 +254,14 @@ func TestAccumulateDelegationPenalties_TransferFullyClampedByPenalty(t *testing.
 		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.3"),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1", "model2", "model3", "model4", "model5"}, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1", "model2", "model3", "model4", "model5"}, modes, params, 1, nil)
 
-	// Penalty: 4 refusals * 0.3 = 1.2, capped at 1.0, deducts 1000 -> 0 remaining
-	// Transfer: 0.3 * 1000 = 300 desired, but 0 available -> transfers 0
-	// Alice: 0
-	// Bob: 500 + 0 = 500
-	require.Equal(t, int64(0), participants[0].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
 	require.Equal(t, int64(500), participants[1].Weight)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyOneDec())
+	require.Len(t, transfers, 1)
+	requireTransfer(t, transfers[0], "model2", "alice", "bob", mathsdk.LegacyMustNewDecFromStr("0.3"))
 }
 
 func TestAccumulateDelegationPenalties_AdditiveAcrossGroups(t *testing.T) {
@@ -217,10 +279,12 @@ func TestAccumulateDelegationPenalties_AdditiveAcrossGroups(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyZeroDec(),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1", "model2"}, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1", "model2"}, modes, params, 1, nil)
 
-	// Additive: penalty = 0.1 + 0.1 = 0.2, result = 1000 * (1 - 0.2) = 800
-	require.Equal(t, int64(800), participants[0].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, transfers)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyMustNewDecFromStr("0.2"))
 }
 
 func TestUnifiedPenalties_DelegationAndBootstrap_Additive(t *testing.T) {
@@ -244,10 +308,11 @@ func TestUnifiedPenalties_DelegationAndBootstrap_Additive(t *testing.T) {
 	acc := NewPenaltyAccumulator(participants)
 	AccumulateDelegationPenalties(acc, dwc, []string{"model1"}, delegationModes, params, 1, nil)
 	AccumulateBootstrapPenalties(acc, bootstrapModes, nil, params, 1, nil)
-	acc.Apply(participants)
+	penalties := acc.RewardPenalties()
 
-	// Additive: 0.1 (delegation) + 0.1 (bootstrap) = 0.2, result = 1000 * 0.8 = 800
-	require.Equal(t, int64(800), participants[0].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyMustNewDecFromStr("0.2"))
 }
 
 func TestAccumulatePenalties_CappedAtOne(t *testing.T) {
@@ -269,10 +334,12 @@ func TestAccumulatePenalties_CappedAtOne(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyZeroDec(),
 	}
 
-	applyDelegationPenalties(participants, dwc, eligibleModels, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, eligibleModels, modes, params, 1, nil)
 
-	// 11 * 0.1 = 1.1, capped at 1.0, weight -> 0
-	require.Equal(t, int64(0), participants[0].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, transfers)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyOneDec())
 }
 
 func TestResolveBootstrapPenaltyModes_PreEligibleFalse(t *testing.T) {
@@ -352,12 +419,15 @@ func TestAccumulateBootstrapPenalties_MapsIntentMissedAndNone(t *testing.T) {
 
 	acc := NewPenaltyAccumulator(participants)
 	AccumulateBootstrapPenalties(acc, modes, nil, params, 1, nil)
-	acc.Apply(participants)
+	penalties := acc.RewardPenalties()
 
 	require.Equal(t, int64(100), participants[0].Weight) // Direct: no penalty
 	require.Equal(t, int64(80), participants[1].Weight)  // Delegate: no penalty
-	require.Equal(t, int64(25), participants[2].Weight)  // IntentMissed: no_participation_penalty 50*0.5=25
-	require.Equal(t, int64(25), participants[3].Weight)  // None: no_participation_penalty 50*0.5=25
+	require.Equal(t, int64(50), participants[2].Weight)  // IntentMissed: reward-only penalty
+	require.Equal(t, int64(50), participants[3].Weight)  // None: reward-only penalty
+	require.Len(t, penalties, 2)
+	requirePenalty(t, penalties[0], "intent_missed", mathsdk.LegacyMustNewDecFromStr("0.5"))
+	requirePenalty(t, penalties[1], "none", mathsdk.LegacyMustNewDecFromStr("0.5"))
 }
 
 func TestAccumulateBootstrapPenalties_DirectCommitterOnNonPreEligibleNotPenalized(t *testing.T) {
@@ -383,10 +453,12 @@ func TestAccumulateBootstrapPenalties_DirectCommitterOnNonPreEligibleNotPenalize
 	}
 	acc := NewPenaltyAccumulator(participants)
 	AccumulateBootstrapPenalties(acc, modes, nil, params, 1, nil)
-	acc.Apply(participants)
+	penalties := acc.RewardPenalties()
 
 	require.Equal(t, int64(100), participants[0].Weight) // Direct: untouched
-	require.Equal(t, int64(50), participants[1].Weight)  // None: 100*0.5=50
+	require.Equal(t, int64(100), participants[1].Weight) // None: reward-only penalty
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "none", mathsdk.LegacyMustNewDecFromStr("0.5"))
 }
 
 func TestAccumulateDelegationPenalties_MixedModesAcrossModels(t *testing.T) {
@@ -404,10 +476,12 @@ func TestAccumulateDelegationPenalties_MixedModesAcrossModels(t *testing.T) {
 		DelegationShare:        mathsdk.LegacyZeroDec(),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1", "model2"}, modes, params, 1, nil)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1", "model2"}, modes, params, 1, nil)
 
-	// Additive: 0.05 (refuse) + 0.1 (none) = 0.15, result = 1000 * 0.85 = 850
-	require.Equal(t, int64(850), participants[0].Weight)
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, transfers)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyMustNewDecFromStr("0.15"))
 }
 
 func TestAccumulateDelegationPenalties_SkipsUntilPenaltyStartEpoch(t *testing.T) {
@@ -424,8 +498,10 @@ func TestAccumulateDelegationPenalties_SkipsUntilPenaltyStartEpoch(t *testing.T)
 		DelegationShare:        mathsdk.LegacyMustNewDecFromStr("0.05"),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, modes, params, 4, map[string]uint64{"model1": 5})
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, modes, params, 4, map[string]uint64{"model1": 5})
 	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, penalties)
+	require.Empty(t, transfers)
 }
 
 func TestAccumulateDelegationPenalties_UsesUpcomingEpochIndexForPenaltyStart(t *testing.T) {
@@ -442,8 +518,11 @@ func TestAccumulateDelegationPenalties_UsesUpcomingEpochIndexForPenaltyStart(t *
 		DelegationShare:        mathsdk.LegacyZeroDec(),
 	}
 
-	applyDelegationPenalties(participants, dwc, []string{"model1"}, modes, params, 5, map[string]uint64{"model1": 5})
-	require.Equal(t, int64(900), participants[0].Weight)
+	penalties, transfers := buildAdjustmentsForTest(t, participants, dwc, []string{"model1"}, modes, params, 5, map[string]uint64{"model1": 5})
+	require.Equal(t, int64(1000), participants[0].Weight)
+	require.Empty(t, transfers)
+	require.Len(t, penalties, 1)
+	requirePenalty(t, penalties[0], "alice", mathsdk.LegacyMustNewDecFromStr("0.1"))
 }
 
 func TestAccumulateBootstrapPenalties_SkipsUntilPenaltyStartEpoch(t *testing.T) {
@@ -463,7 +542,8 @@ func TestAccumulateBootstrapPenalties_SkipsUntilPenaltyStartEpoch(t *testing.T)
 
 	acc := NewPenaltyAccumulator(participants)
 	AccumulateBootstrapPenalties(acc, modes, nil, params, 4, map[string]uint64{"bootstrap-model": 5})
-	acc.Apply(participants)
+	penalties := acc.RewardPenalties()
 
 	require.Equal(t, int64(50), participants[0].Weight)
+	require.Empty(t, penalties)
 }
diff --git a/inference-chain/x/inference/module/epoch_fallback.go b/inference-chain/x/inference/module/epoch_fallback.go
new file mode 100644
index 0000000000..f33dcc7f63
--- /dev/null
+++ b/inference-chain/x/inference/module/epoch_fallback.go
@@ -0,0 +1,259 @@
+package inference
+
+import (
+	"context"
+	"slices"
+
+	"cosmossdk.io/collections"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+// Epoch fallback: safety mechanism for an epoch transition where PoC validation
+// produced zero active participants.
+//
+// Without a fallback, an empty result wipes the upcoming epoch: no active
+// participants, no epoch group members, no voting powers. Since the next PoC
+// round derives voting powers from the (now empty) effective epoch group,
+// nobody can ever be validated again and the network is permanently stuck.
+//
+// The fallback re-seats the current epoch's validators into the upcoming epoch,
+// with three restrictions so that nobody excluded during the current epoch gets
+// a second life:
+//  1. Only live SDK-group members are carried. Mid-epoch invalidation and
+//     deactivation (invalid inferences, downtime, failed confirmation PoC)
+//     remove the member from the group, so removed participants are not live.
+//  2. The ExcludedParticipantsMap record for the current epoch is honored.
+//  3. The participant's current Status must not be INVALID or INACTIVE.
+//
+// Carried participants are initialized like freshly validated ones: a new
+// ActiveParticipant record is built from scratch (no statistics or per-epoch
+// state is copied) and the result flows through the exact same epoch-formation
+// pipeline (model assignment, delegation weights, collateral adjustment, power
+// capping, epoch group membership) as a normal PoC outcome.
+
+// fallbackActiveParticipantsFromCurrentEpoch rebuilds the active participant
+// list for upcomingEpoch from the current (about-to-end) epoch group.
+// Returns nil/empty when no participant can be safely carried over.
+func (am AppModule) fallbackActiveParticipantsFromCurrentEpoch(ctx context.Context, upcomingEpoch types.Epoch) []*types.ActiveParticipant {
+	if upcomingEpoch.Index <= 1 {
+		am.LogWarn("EpochFallback: not applicable for the first epoch", types.PoC,
+			"upcomingEpoch.Index", upcomingEpoch.Index)
+		return nil
+	}
+
+	rootData, liveSet, err := am.keeper.GetRootGroupDataWithLiveMembers(ctx)
+	if err != nil {
+		am.LogError("EpochFallback: unable to load current epoch group", types.PoC, "error", err.Error())
+		return nil
+	}
+	if rootData.EpochIndex != upcomingEpoch.Index-1 {
+		am.LogError("EpochFallback: current epoch group does not precede upcoming epoch", types.PoC,
+			"currentEpochGroup.EpochIndex", rootData.EpochIndex,
+			"upcomingEpoch.Index", upcomingEpoch.Index)
+		return nil
+	}
+
+	modelNodesByParticipant := am.currentEpochModelNodes(ctx, rootData)
+
+	participantsByAddr := make(map[string]*types.ActiveParticipant)
+	for _, vw := range rootData.ValidationWeights {
+		if vw == nil || vw.MemberAddress == "" {
+			continue
+		}
+		addr := vw.MemberAddress
+		if _, dup := participantsByAddr[addr]; dup {
+			continue
+		}
+
+		if !liveSet[addr] {
+			am.LogWarn("EpochFallback: skipping participant removed from current epoch group", types.PoC,
+				"participant", addr)
+			continue
+		}
+		if am.wasExcludedInEpoch(ctx, rootData.EpochIndex, addr) {
+			am.LogWarn("EpochFallback: skipping participant excluded during current epoch", types.PoC,
+				"participant", addr, "epochIndex", rootData.EpochIndex)
+			continue
+		}
+
+		participant, found := am.keeper.GetParticipant(ctx, addr)
+		if !found {
+			am.LogError("EpochFallback: participant record not found", types.PoC, "participant", addr)
+			continue
+		}
+		if participant.Status == types.ParticipantStatus_INVALID ||
+			participant.Status == types.ParticipantStatus_INACTIVE {
+			am.LogWarn("EpochFallback: skipping participant with non-carryable status", types.PoC,
+				"participant", addr, "status", participant.Status)
+			continue
+		}
+		if participant.ValidatorKey == "" {
+			am.LogWarn("EpochFallback: skipping participant without validator key", types.PoC,
+				"participant", addr)
+			continue
+		}
+
+		seed, ok := am.fallbackSeed(ctx, upcomingEpoch.Index, rootData.EpochIndex, addr)
+		if !ok {
+			am.LogWarn("EpochFallback: skipping participant without any usable seed", types.PoC,
+				"participant", addr)
+			continue
+		}
+
+		models, mlNodes := buildFallbackModelNodes(modelNodesByParticipant[addr])
+
+		activeParticipant := &types.ActiveParticipant{
+			Index:        addr,
+			ValidatorKey: participant.ValidatorKey,
+			InferenceUrl: participant.InferenceUrl,
+			Seed:         seed,
+			Models:       models,
+			MlNodes:      mlNodes,
+		}
+		activeParticipant.Weight = RecalculateWeight(activeParticipant)
+		if activeParticipant.Weight <= 0 {
+			// No per-model nodes recovered from subgroup data. Carry the root
+			// consensus weight so the participant still counts toward the set;
+			// the downstream weight pipeline recomputes final weights anyway.
+			activeParticipant.Weight = vw.Weight
+		}
+		if activeParticipant.Weight <= 0 {
+			am.LogWarn("EpochFallback: skipping participant with non-positive weight", types.PoC,
+				"participant", addr)
+			continue
+		}
+
+		participantsByAddr[addr] = activeParticipant
+		am.LogInfo("EpochFallback: carrying participant into upcoming epoch", types.PoC,
+			"participant", addr,
+			"weight", activeParticipant.Weight,
+			"models", models)
+	}
+
+	addrs := make([]string, 0, len(participantsByAddr))
+	for addr := range participantsByAddr {
+		addrs = append(addrs, addr)
+	}
+	slices.Sort(addrs)
+
+	result := make([]*types.ActiveParticipant, 0, len(addrs))
+	for _, addr := range addrs {
+		result = append(result, participantsByAddr[addr])
+	}
+
+	am.LogInfo("EpochFallback: summary", types.PoC,
+		"upcomingEpoch.Index", upcomingEpoch.Index,
+		"candidates", len(rootData.ValidationWeights),
+		"carried", len(result))
+
+	return result
+}
+
+// currentEpochModelNodes rebuilds per-participant, per-model MLNode info from
+// the current epoch's model subgroups. Nodes are copied fresh (id, throughput,
+// PoC weight only) so no scheduling or per-epoch state leaks into the new epoch.
+func (am AppModule) currentEpochModelNodes(
+	ctx context.Context,
+	rootData types.EpochGroupData,
+) map[string]map[string][]*types.MLNodeInfo {
+	result := make(map[string]map[string][]*types.MLNodeInfo)
+
+	models := slices.Clone(rootData.SubGroupModels)
+	slices.Sort(models)
+
+	for _, modelId := range models {
+		subData, found := am.keeper.GetEpochGroupData(ctx, rootData.EpochIndex, modelId)
+		if !found {
+			am.LogWarn("EpochFallback: model subgroup data not found", types.PoC,
+				"epochIndex", rootData.EpochIndex, "modelId", modelId)
+			continue
+		}
+		for _, vw := range subData.ValidationWeights {
+			if vw == nil || vw.MemberAddress == "" {
+				continue
+			}
+			seenNodeIds := make(map[string]bool, len(vw.MlNodes))
+			for _, node := range vw.MlNodes {
+				if node == nil || node.NodeId == "" || seenNodeIds[node.NodeId] {
+					continue
+				}
+				seenNodeIds[node.NodeId] = true
+				if result[vw.MemberAddress] == nil {
+					result[vw.MemberAddress] = make(map[string][]*types.MLNodeInfo)
+				}
+				result[vw.MemberAddress][modelId] = append(result[vw.MemberAddress][modelId], &types.MLNodeInfo{
+					NodeId:     node.NodeId,
+					Throughput: node.Throughput,
+					PocWeight:  node.PocWeight,
+				})
+			}
+		}
+	}
+
+	return result
+}
+
+// buildFallbackModelNodes converts a model->nodes map into the parallel
+// Models/MlNodes arrays used by ActiveParticipant, in deterministic order.
+func buildFallbackModelNodes(modelNodes map[string][]*types.MLNodeInfo) ([]string, []*types.ModelMLNodes) {
+	if len(modelNodes) == 0 {
+		return nil, nil
+	}
+
+	models := make([]string, 0, len(modelNodes))
+	for modelId := range modelNodes {
+		models = append(models, modelId)
+	}
+	slices.Sort(models)
+
+	mlNodes := make([]*types.ModelMLNodes, 0, len(models))
+	for _, modelId := range models {
+		mlNodes = append(mlNodes, &types.ModelMLNodes{MlNodes: modelNodes[modelId]})
+	}
+	return models, mlNodes
+}
+
+// fallbackSeed picks the seed for a carried participant. A seed submitted for
+// the upcoming epoch is preferred. If none exists (likely, given the epoch
+// formation just failed), the current epoch's seed is reused: its value may
+// already be revealed via a prior claim, which weakens validation-sampling
+// unpredictability for this participant, but that is an acceptable trade-off
+// for keeping the chain alive.
+func (am AppModule) fallbackSeed(
+	ctx context.Context,
+	upcomingEpochIndex, currentEpochIndex uint64,
+	address string,
+) (*types.RandomSeed, bool) {
+	if seed, found := am.keeper.GetRandomSeed(ctx, upcomingEpochIndex, address); found {
+		return &seed, true
+	}
+	seed, found := am.keeper.GetRandomSeed(ctx, currentEpochIndex, address)
+	if !found {
+		return nil, false
+	}
+	am.LogWarn("EpochFallback: reusing current-epoch seed for upcoming epoch", types.PoC,
+		"participant", address,
+		"currentEpochIndex", currentEpochIndex,
+		"upcomingEpochIndex", upcomingEpochIndex)
+	seed.EpochIndex = upcomingEpochIndex
+	return &seed, true
+}
+
+// wasExcludedInEpoch reports whether the participant has an exclusion record
+// (invalidation, downtime, failed confirmation PoC) for the given epoch.
+func (am AppModule) wasExcludedInEpoch(ctx context.Context, epochIndex uint64, address string) bool {
+	accAddr, err := sdk.AccAddressFromBech32(address)
+	if err != nil {
+		am.LogError("EpochFallback: unable to parse participant address for exclusion check", types.PoC,
+			"participant", address, "error", err.Error())
+		return false
+	}
+	has, err := am.keeper.ExcludedParticipantsMap.Has(ctx, collections.Join(epochIndex, accAddr))
+	if err != nil {
+		am.LogError("EpochFallback: exclusion lookup failed", types.PoC,
+			"participant", address, "error", err.Error())
+		return false
+	}
+	return has
+}
diff --git a/inference-chain/x/inference/module/epoch_fallback_test.go b/inference-chain/x/inference/module/epoch_fallback_test.go
new file mode 100644
index 0000000000..f6dde1ece1
--- /dev/null
+++ b/inference-chain/x/inference/module/epoch_fallback_test.go
@@ -0,0 +1,214 @@
+package inference
+
+import (
+	"slices"
+	"testing"
+
+	"cosmossdk.io/collections"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	"github.com/stretchr/testify/require"
+
+	"github.com/productscience/inference/testutil"
+	"github.com/productscience/inference/x/inference/types"
+)
+
+func mustAccAddr(t *testing.T, addr string) sdk.AccAddress {
+	t.Helper()
+	accAddr, err := sdk.AccAddressFromBech32(addr)
+	require.NoError(t, err)
+	return accAddr
+}
+
+func findByIndex(participants []*types.ActiveParticipant, index string) *types.ActiveParticipant {
+	for _, p := range participants {
+		if p.Index == index {
+			return p
+		}
+	}
+	return nil
+}
+
+func TestFallbackActiveParticipantsFromCurrentEpoch(t *testing.T) {
+	k, ctx, groupStub := newMinimalInferenceKeeperWithStub(t)
+	am := NewAppModule(nil, k, nil, nil, nil, nil)
+
+	const currentEpochIndex = uint64(5)
+	upcomingEpoch := types.Epoch{Index: 6, PocStartBlockHeight: 600}
+
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, currentEpochIndex))
+
+	carried := testutil.Executor    // happy path: live, active, has upcoming seed
+	seedReuse := testutil.Executor2 // live, active, only current-epoch seed
+	rootOnly := testutil.Creator    // live, active, seed, but no subgroup nodes
+	removed := testutil.Validator   // removed from SDK group mid-epoch
+	excluded := testutil.Validator2 // has an exclusion record for current epoch
+	invalid := testutil.Requester   // participant status INVALID
+
+	k.SetEpochGroupData(ctx, types.EpochGroupData{
+		EpochIndex:     currentEpochIndex,
+		ModelId:        "",
+		EpochGroupId:   77,
+		SubGroupModels: []string{"model-a"},
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: carried, Weight: 100},
+			{MemberAddress: seedReuse, Weight: 50},
+			{MemberAddress: rootOnly, Weight: 70},
+			{MemberAddress: removed, Weight: 40},
+			{MemberAddress: excluded, Weight: 30},
+			{MemberAddress: invalid, Weight: 20},
+		},
+	})
+	k.SetEpochGroupData(ctx, types.EpochGroupData{
+		EpochIndex:   currentEpochIndex,
+		ModelId:      "model-a",
+		EpochGroupId: 78,
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: carried, Weight: 100, MlNodes: []*types.MLNodeInfo{
+				{NodeId: "n1", PocWeight: 60, Throughput: 10, TimeslotAllocation: []bool{true, true}},
+				{NodeId: "n2", PocWeight: 40},
+			}},
+			{MemberAddress: seedReuse, Weight: 50, MlNodes: []*types.MLNodeInfo{
+				{NodeId: "m1", PocWeight: 50},
+			}},
+			{MemberAddress: removed, Weight: 40, MlNodes: []*types.MLNodeInfo{
+				{NodeId: "r1", PocWeight: 40},
+			}},
+			{MemberAddress: excluded, Weight: 30, MlNodes: []*types.MLNodeInfo{
+				{NodeId: "e1", PocWeight: 30},
+			}},
+			{MemberAddress: invalid, Weight: 20, MlNodes: []*types.MLNodeInfo{
+				{NodeId: "i1", PocWeight: 20},
+			}},
+		},
+	})
+
+	// Mid-epoch removal: participant is still in ValidationWeights but no
+	// longer a live SDK group member.
+	groupStub.excludedMembers = map[string]bool{removed: true}
+
+	setParticipant := func(addr string, status types.ParticipantStatus) {
+		require.NoError(t, k.Participants.Set(ctx, mustAccAddr(t, addr), types.Participant{
+			Index:        addr,
+			Address:      addr,
+			Status:       status,
+			ValidatorKey: "valkey-" + addr,
+			InferenceUrl: "http://" + addr,
+		}))
+	}
+	for _, addr := range []string{carried, seedReuse, rootOnly, removed, excluded} {
+		setParticipant(addr, types.ParticipantStatus_ACTIVE)
+	}
+	setParticipant(invalid, types.ParticipantStatus_INVALID)
+
+	// Exclusion record for the current epoch.
+	require.NoError(t, k.ExcludedParticipantsMap.Set(ctx,
+		collections.Join(currentEpochIndex, mustAccAddr(t, excluded)),
+		types.ExcludedParticipant{Address: excluded, EpochIndex: currentEpochIndex, Reason: "downtime"},
+	))
+
+	// Seeds: carried has both, and the upcoming one must win. seedReuse and
+	// rootOnly only have the current epoch's seed. Everyone else has seeds too,
+	// so their absence from the result is attributable to the intended filter.
+	require.NoError(t, k.SetRandomSeed(ctx, types.RandomSeed{Participant: carried, EpochIndex: 6, Signature: "sig-new"}))
+	for _, addr := range []string{carried, seedReuse, rootOnly, removed, excluded, invalid} {
+		require.NoError(t, k.SetRandomSeed(ctx, types.RandomSeed{Participant: addr, EpochIndex: currentEpochIndex, Signature: "sig-old-" + addr}))
+	}
+
+	result := am.fallbackActiveParticipantsFromCurrentEpoch(ctx, upcomingEpoch)
+
+	require.Len(t, result, 3)
+	require.True(t, slices.IsSortedFunc(result, func(a, b *types.ActiveParticipant) int {
+		if a.Index < b.Index {
+			return -1
+		}
+		if a.Index > b.Index {
+			return 1
+		}
+		return 0
+	}))
+	require.Nil(t, findByIndex(result, removed))
+	require.Nil(t, findByIndex(result, excluded))
+	require.Nil(t, findByIndex(result, invalid))
+
+	carriedAP := findByIndex(result, carried)
+	require.NotNil(t, carriedAP)
+	require.Equal(t, "valkey-"+carried, carriedAP.ValidatorKey)
+	require.Equal(t, "http://"+carried, carriedAP.InferenceUrl)
+	require.Equal(t, []string{"model-a"}, carriedAP.Models)
+	require.Equal(t, int64(100), carriedAP.Weight)
+	require.NotNil(t, carriedAP.Seed)
+	require.Equal(t, "sig-new", carriedAP.Seed.Signature)
+	require.Len(t, carriedAP.MlNodes, 1)
+	require.Len(t, carriedAP.MlNodes[0].MlNodes, 2)
+	for _, node := range carriedAP.MlNodes[0].MlNodes {
+		// Fresh copies: no scheduling state carried over.
+		require.Empty(t, node.TimeslotAllocation)
+	}
+
+	seedReuseAP := findByIndex(result, seedReuse)
+	require.NotNil(t, seedReuseAP)
+	require.Equal(t, int64(50), seedReuseAP.Weight)
+	require.NotNil(t, seedReuseAP.Seed)
+	require.Equal(t, "sig-old-"+seedReuse, seedReuseAP.Seed.Signature)
+
+	rootOnlyAP := findByIndex(result, rootOnly)
+	require.NotNil(t, rootOnlyAP)
+	require.Empty(t, rootOnlyAP.Models)
+	// No subgroup nodes recovered: falls back to the root consensus weight.
+	require.Equal(t, int64(70), rootOnlyAP.Weight)
+}
+
+func TestFallbackActiveParticipantsSkipsParticipantWithoutSeed(t *testing.T) {
+	k, ctx, _ := newMinimalInferenceKeeperWithStub(t)
+	am := NewAppModule(nil, k, nil, nil, nil, nil)
+
+	const currentEpochIndex = uint64(5)
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, currentEpochIndex))
+
+	addr := testutil.Executor
+	k.SetEpochGroupData(ctx, types.EpochGroupData{
+		EpochIndex:   currentEpochIndex,
+		ModelId:      "",
+		EpochGroupId: 77,
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: addr, Weight: 100},
+		},
+	})
+	require.NoError(t, k.Participants.Set(ctx, mustAccAddr(t, addr), types.Participant{
+		Index:        addr,
+		Address:      addr,
+		Status:       types.ParticipantStatus_ACTIVE,
+		ValidatorKey: "valkey",
+	}))
+
+	result := am.fallbackActiveParticipantsFromCurrentEpoch(ctx, types.Epoch{Index: 6, PocStartBlockHeight: 600})
+	require.Empty(t, result)
+}
+
+func TestFallbackActiveParticipantsGuards(t *testing.T) {
+	k, ctx, _ := newMinimalInferenceKeeperWithStub(t)
+	am := NewAppModule(nil, k, nil, nil, nil, nil)
+
+	// Not applicable for the first epoch.
+	require.Empty(t, am.fallbackActiveParticipantsFromCurrentEpoch(ctx, types.Epoch{Index: 1}))
+
+	// Current epoch group must directly precede the upcoming epoch.
+	require.NoError(t, k.SetEffectiveEpochIndex(ctx, 5))
+	k.SetEpochGroupData(ctx, types.EpochGroupData{
+		EpochIndex:   5,
+		ModelId:      "",
+		EpochGroupId: 77,
+		ValidationWeights: []*types.ValidationWeight{
+			{MemberAddress: testutil.Executor, Weight: 100},
+		},
+	})
+	require.Empty(t, am.fallbackActiveParticipantsFromCurrentEpoch(ctx, types.Epoch{Index: 10}))
+}
+
+func TestHasPositiveComputePower(t *testing.T) {
+	require.False(t, hasPositiveComputePower(nil))
+	require.False(t, hasPositiveComputePower([]stakingkeeper.ComputeResult{}))
+	require.False(t, hasPositiveComputePower([]stakingkeeper.ComputeResult{{Power: 0}, {Power: -5}}))
+	require.True(t, hasPositiveComputePower([]stakingkeeper.ComputeResult{{Power: 0}, {Power: 1}}))
+}
diff --git a/inference-chain/x/inference/module/module.go b/inference-chain/x/inference/module/module.go
index fb275cb6d3..672fd8a07a 100644
--- a/inference-chain/x/inference/module/module.go
+++ b/inference-chain/x/inference/module/module.go
@@ -224,6 +224,12 @@ func (am AppModule) BeginBlock(ctx context.Context) error {
 		am.LogError("Failed to build epoch data transient cache", types.Validation, "error", err)
 	}
 
+	// Process maintenance window lifecycle transitions (Scheduled->Active, Active->Completed)
+	err = am.keeper.ProcessMaintenanceTransitions(ctx)
+	if err != nil {
+		am.LogError("Failed to process maintenance transitions", types.Maintenance, "error", err)
+	}
+
 	return nil
 }
 
@@ -245,13 +251,17 @@ func (am AppModule) expireInferences(
 		return err
 	}
 
+	// Pre-build maintenance address set once to avoid repeated O(log N) lookups
+	// per expired inference in handleExpiredInferenceWithContext.
+	maintenanceAddrs := am.keeper.CollectActiveMaintenanceAddresses(ctx)
+
 	for _, i := range timeouts {
 		inference, found := am.keeper.GetInference(ctx, i.InferenceId)
 		if !found {
 			continue
 		}
 		if inference.Status == types.InferenceStatus_STARTED {
-			am.handleExpiredInferenceWithContext(ctx, inference, expiryCtx)
+			am.handleExpiredInferenceWithContext(ctx, inference, expiryCtx, maintenanceAddrs)
 		}
 	}
 	return nil
@@ -276,7 +286,7 @@ func (am AppModule) expireInferenceAndIssueRefund(ctx context.Context, inference
 	return inference
 }
 
-func (am AppModule) handleExpiredInferenceWithContext(ctx context.Context, inference types.Inference, expiryCtx *InferenceExpiryContext) {
+func (am AppModule) handleExpiredInferenceWithContext(ctx context.Context, inference types.Inference, expiryCtx *InferenceExpiryContext, maintenanceAddrs map[string]struct{}) {
 	executor, found := am.keeper.GetParticipant(ctx, inference.AssignedTo)
 	if !found {
 		am.LogWarn("Unable to find participant for expired inference", types.Inferences, "inferenceId", inference.InferenceId, "executedBy", inference.ExecutedBy)
@@ -332,6 +342,29 @@ func (am AppModule) handleExpiredInferenceWithContext(ctx context.Context, infer
 		return
 	}
 
+	// Executor has the required node — check maintenance exemption before penalizing.
+	// During active maintenance, expiry penalties are waived (the participant is
+	// expected to be offline and should not accumulate MissedRequests).
+	if _, inMaint := maintenanceAddrs[inference.AssignedTo]; inMaint {
+		am.LogInfo("Inference expired during active maintenance, waiving penalty",
+			types.Inferences,
+			"inferenceId", inference.InferenceId,
+			"executor", inference.AssignedTo,
+			"model", inference.Model,
+			"epochIndex", epochToCheck.Index)
+
+		sdkCtx := sdk.UnwrapSDKContext(ctx)
+		sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+			"maintenance_penalty_waived",
+			sdk.NewAttribute("inference_id", inference.InferenceId),
+			sdk.NewAttribute("executor", inference.AssignedTo),
+			sdk.NewAttribute("reason", "expiry_during_active_maintenance"),
+		))
+
+		am.expireInferenceAndIssueRefund(ctx, inference)
+		return
+	}
+
 	// Executor has the required node, proceed with normal expiry handling (with penalty)
 	am.LogInfo("Inference expired, not finished. Issuing refund and penalizing executor",
 		types.Inferences,
@@ -418,17 +451,6 @@ func (am AppModule) EndBlock(ctx context.Context) error {
 		am.LogError("Error during pruning", types.Pruning, "error", err.Error())
 	}
 
-	// Track full chain upgrades from UpgradeKeeper
-	upgradePlan, err := am.keeper.GetUpgradePlan(ctx)
-	if err == nil && upgradePlan.Height > 0 && upgradePlan.Height == blockHeight {
-		am.LogInfo("FullUpgradeActive - tracking height", types.Upgrades,
-			"upgradeHeight", upgradePlan.Height, "blockHeight", blockHeight, "name", upgradePlan.Name)
-		err = am.keeper.SetLastUpgradeHeight(ctx, blockHeight)
-		if err != nil {
-			am.LogError("Failed to set last upgrade height for full upgrade", types.Upgrades, "error", err)
-		}
-	}
-
 	partialUpgrades := am.keeper.GetAllPartialUpgrade(ctx)
 	for _, pu := range partialUpgrades {
 		if pu.Height == uint64(blockHeight) {
@@ -557,9 +579,23 @@ func (am AppModule) EndBlock(ctx context.Context) error {
 		// Apply early network protection if conditions are met
 		finalComputeResult := am.applyEarlyNetworkProtection(ctx, computeResult)
 
-		_, err = am.keeper.Staking.SetComputeValidators(ctx, finalComputeResult, testenv.IsTestNet())
-		if err != nil {
-			am.LogError("Unable to update epoch group", types.EpochGroup, "error", err.Error())
+		// Safety mechanism: never hand the staking module a validator set with
+		// no positive power. SetComputeValidators deletes validators absent from
+		// the compute results, so an empty (or all-zero) set would wipe every
+		// validator and halt consensus. Keep the existing validators instead.
+		if !hasPositiveComputePower(finalComputeResult) {
+			am.LogError("EndBlock: refusing to apply validator update with no positive-power validators; keeping current validator set", types.EpochGroup,
+				"blockHeight", blockHeight, "len(computeResult)", len(finalComputeResult))
+			sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+				"epoch_error",
+				sdk.NewAttribute("stage", "set_compute_validators"),
+				sdk.NewAttribute("error_category", "empty_validator_set"),
+			))
+		} else {
+			_, err = am.keeper.Staking.SetComputeValidators(ctx, finalComputeResult, testenv.IsTestNet())
+			if err != nil {
+				am.LogError("Unable to update epoch group", types.EpochGroup, "error", err.Error())
+			}
 		}
 		currentEpochGroup.MarkUnchanged(ctx)
 	}
@@ -623,6 +659,25 @@ func (am AppModule) onEndOfPoCValidationStage(ctx context.Context, blockHeight i
 		return
 	}
 
+	previousEpoch, found := am.keeper.GetPreviousEpoch(ctx)
+	previousEpochIndex := uint64(0)
+	if found {
+		previousEpochIndex = previousEpoch.Index
+	}
+
+	// Settle before collateral AdvanceEpoch so slashing can reach maturing unbonding entries.
+	err := am.keeper.SettleAccounts(ctx, effectiveEpoch.Index, previousEpochIndex)
+	if err != nil {
+		am.LogError("onEndOfPoCValidationStage: Unable to settle accounts", types.Settle, "error", err.Error())
+		sdkCtx := sdk.UnwrapSDKContext(ctx)
+		sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+			"epoch_error",
+			sdk.NewAttribute("stage", "settle_accounts"),
+			sdk.NewAttribute("epoch", fmt.Sprintf("%d", effectiveEpoch.Index)),
+			sdk.NewAttribute("error_category", "settlement"),
+		))
+	}
+
 	// Signal to the collateral module that the epoch has advanced.
 	// This will trigger its internal unbonding queue processing.
 	if am.keeper.GetCollateralKeeper() != nil {
@@ -649,24 +704,6 @@ func (am AppModule) onEndOfPoCValidationStage(ctx context.Context, blockHeight i
 		}
 	}
 
-	previousEpoch, found := am.keeper.GetPreviousEpoch(ctx)
-	previousEpochIndex := uint64(0)
-	if found {
-		previousEpochIndex = previousEpoch.Index
-	}
-
-	err := am.keeper.SettleAccounts(ctx, effectiveEpoch.Index, previousEpochIndex)
-	if err != nil {
-		am.LogError("onEndOfPoCValidationStage: Unable to settle accounts", types.Settle, "error", err.Error())
-		sdkCtx := sdk.UnwrapSDKContext(ctx)
-		sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
-			"epoch_error",
-			sdk.NewAttribute("stage", "settle_accounts"),
-			sdk.NewAttribute("epoch", fmt.Sprintf("%d", effectiveEpoch.Index)),
-			sdk.NewAttribute("error_category", "settlement"),
-		))
-	}
-
 	upcomingEpoch, found := am.keeper.GetUpcomingEpoch(ctx)
 	if !found || upcomingEpoch == nil {
 		am.LogError("onEndOfPoCValidationStage: Unable to get upcoming epoch group", types.EpochGroup)
@@ -674,9 +711,33 @@ func (am AppModule) onEndOfPoCValidationStage(ctx context.Context, blockHeight i
 	}
 
 	activeParticipants := am.ComputeNewWeights(ctx, *upcomingEpoch)
-	if activeParticipants == nil {
-		am.LogError("onEndOfPoCValidationStage: computeResult == nil && activeParticipants == nil", types.PoC)
-		return
+	if len(activeParticipants) == 0 {
+		// Safety mechanism: a PoC round where nobody passed validation must not
+		// produce an empty epoch. An empty epoch group can never validate anyone
+		// in later rounds (voting powers derive from it), permanently stalling
+		// the network. Re-seat the current epoch's still-valid validators
+		// instead; see epoch_fallback.go for the carry-over rules.
+		am.LogError("onEndOfPoCValidationStage: no validated participants for upcoming epoch; falling back to current epoch validators", types.PoC,
+			"upcomingEpoch.Index", upcomingEpoch.Index)
+		activeParticipants = am.fallbackActiveParticipantsFromCurrentEpoch(ctx, *upcomingEpoch)
+		if len(activeParticipants) == 0 {
+			am.LogError("onEndOfPoCValidationStage: fallback produced no participants; aborting epoch formation", types.PoC,
+				"upcomingEpoch.Index", upcomingEpoch.Index)
+			sdkCtx := sdk.UnwrapSDKContext(ctx)
+			sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+				"epoch_error",
+				sdk.NewAttribute("stage", "empty_epoch_fallback"),
+				sdk.NewAttribute("epoch", fmt.Sprintf("%d", upcomingEpoch.Index)),
+				sdk.NewAttribute("error_category", "epoch_formation"),
+			))
+			return
+		}
+		sdkCtx := sdk.UnwrapSDKContext(ctx)
+		sdkCtx.EventManager().EmitEvent(sdk.NewEvent(
+			"empty_epoch_fallback_applied",
+			sdk.NewAttribute("epoch", fmt.Sprintf("%d", upcomingEpoch.Index)),
+			sdk.NewAttribute("participants", fmt.Sprintf("%d", len(activeParticipants))),
+		))
 	}
 
 	modelAssigner := NewModelAssigner(am.keeper, am.keeper)
@@ -727,11 +788,20 @@ func (am AppModule) onEndOfPoCValidationStage(ctx context.Context, blockHeight i
 		upcomingEpoch.Index,
 		penaltyStartEpochByModel,
 	)
-	acc.Apply(activeParticipants)
+	penalties := acc.RewardPenalties()
+	rewardTransfers := BuildDelegationRewardTransfers(
+		participationState.calculator,
+		participationState.eligibleModels,
+		participationState.participationByModel,
+		adjParams,
+		upcomingEpoch.Index,
+		penaltyStartEpochByModel,
+	)
+	allRewardTransfers := rewardTransfers.Records()
 
-	afterPenalty := make(map[string]int64, len(activeParticipants))
+	beforeCollateral := make(map[string]int64, len(activeParticipants))
 	for _, p := range activeParticipants {
-		afterPenalty[p.Index] = p.Weight
+		beforeCollateral[p.Index] = p.Weight
 	}
 
 	// Adjust weights based on collateral after the grace period. This modifies the weights in-place.
@@ -769,7 +839,7 @@ func (am AppModule) onEndOfPoCValidationStage(ctx context.Context, blockHeight i
 	emitWeightPipelineLogs(am, upcomingEpoch.Index, groupSummaries,
 		participationState.eligibleModels, activeParticipants,
 		participationState.participationByModel,
-		consensusWeights, afterPenalty, acc)
+		consensusWeights, beforeCollateral, acc)
 
 	am.LogInfo("onEndOfPoCValidationStage: computed new weights", types.Stages,
 		"upcomingEpoch.Index", upcomingEpoch.Index,
@@ -805,6 +875,14 @@ func (am AppModule) onEndOfPoCValidationStage(ctx context.Context, blockHeight i
 	}
 
 	upcomingEg.GroupData.ConfirmationWeightScales = confirmationWeightScales
+	if err := am.keeper.SetDelegationRewardTransferSnapshot(ctx, types.DelegationRewardTransferSnapshot{
+		EpochIndex: upcomingEpoch.Index,
+		Transfers:  allRewardTransfers,
+		Penalties:  penalties,
+	}); err != nil {
+		am.LogError("onEndOfPoCValidationStage: failed to store delegation reward transfer snapshot", types.PoC, "error", err)
+		return
+	}
 	am.keeper.SetEpochGroupData(ctx, *upcomingEg.GroupData)
 
 	am.addEpochMembers(ctx, upcomingEg, activeParticipants)
@@ -1333,6 +1411,19 @@ func (am AppModule) applyEpochPowerCapping(ctx context.Context, activeParticipan
 	return result.CappedParticipants
 }
 
+// hasPositiveComputePower reports whether at least one compute result carries
+// positive power. SetComputeValidators filters non-positive entries and deletes
+// validators missing from the results, so applying a set without any positive
+// power would remove every validator.
+func hasPositiveComputePower(computeResults []stakingkeeper.ComputeResult) bool {
+	for _, cr := range computeResults {
+		if cr.Power > 0 {
+			return true
+		}
+	}
+	return false
+}
+
 // applyEarlyNetworkProtection applies genesis guardian enhancement to compute results before validator set updates
 // This system only applies when network is immature (below maturity threshold)
 func (am AppModule) applyEarlyNetworkProtection(ctx context.Context, computeResults []stakingkeeper.ComputeResult) []stakingkeeper.ComputeResult {
@@ -1400,6 +1491,7 @@ func GetTxCmd() *cobra.Command {
 
 	cmd.AddCommand(GrantMLOpsPermissionsCmd())
 	cmd.AddCommand(SettleDevshardEscrowCmd())
+	cmd.AddCommand(SetClaimRecipientsCmd())
 
 	return cmd
 }
diff --git a/inference-chain/x/inference/module/weight_calculator_test.go b/inference-chain/x/inference/module/weight_calculator_test.go
index 555a8f10bb..a36a645fbb 100644
--- a/inference-chain/x/inference/module/weight_calculator_test.go
+++ b/inference-chain/x/inference/module/weight_calculator_test.go
@@ -125,6 +125,127 @@ func TestPoCWeightCalculator_PocValidated_SlotSamplingAcceptsWhenGroupControlsEn
 	require.True(t, ok)
 }
 
+// Regression for the guardian-vote-loss incident: a guardian that could not
+// run a model that epoch has no voting weight for it, so its votes were
+// filtered out before the tiebreaker and participants got rejected on split
+// votes. Guardian votes must be counted in the tiebreaker regardless of
+// per-model voting weight.
+func TestPoCWeightCalculator_GuardianTiebreakerCountsWeightlessGuardianVotes(t *testing.T) {
+	key := types.PoCParticipantModelKey{
+		ParticipantAddress: testutil.Executor,
+		ModelID:            "model-a",
+	}
+	guardian := testutil.Creator
+
+	newCalc := func(guardianVote int64) *PoCWeightCalculator {
+		return &PoCWeightCalculator{
+			ModelVotingPowers: map[string]map[string]int64{
+				"model-a": {
+					testutil.Validator:  40,
+					testutil.Validator2: 40,
+					// guardian intentionally absent: no voting weight for model-a
+				},
+			},
+			TotalNetworkWeight: 100,
+			Validations: map[types.PoCParticipantModelKey][]types.PoCValidationV2{
+				key: {
+					{ValidatorParticipantAddress: testutil.Validator, ValidatedWeight: 1},
+					{ValidatorParticipantAddress: testutil.Validator2, ValidatedWeight: -1},
+					{ValidatorParticipantAddress: guardian, ValidatedWeight: guardianVote},
+				},
+			},
+			GuardianEnabled:   true,
+			GuardianAddresses: map[string]bool{guardian: true},
+			Logger:            noopLogger{},
+		}
+	}
+
+	t.Run("guardian votes valid - accepted", func(t *testing.T) {
+		wc := newCalc(1)
+		filtered := wc.getParticipantValidations(key)
+		// The guardian vote is dropped from the majority list because the
+		// guardian has no voting weight for the model...
+		require.Len(t, filtered, 2)
+		// ...votes split 40/40 with no 2/3 majority, and the guardian's raw
+		// vote decides the tiebreaker.
+		require.True(t, wc.pocValidated(filtered, key))
+	})
+
+	t.Run("guardian votes invalid - rejected", func(t *testing.T) {
+		wc := newCalc(-1)
+		filtered := wc.getParticipantValidations(key)
+		require.Len(t, filtered, 2)
+		require.False(t, wc.pocValidated(filtered, key))
+	})
+}
+
+// Even when ALL votes come from weightless guardians (the filtered majority
+// list is empty), the participant must not be rejected early: the guardian
+// tiebreaker still applies.
+func TestPoCWeightCalculator_Calculate_GuardianOnlyVotesReachTiebreaker(t *testing.T) {
+	key := types.PoCParticipantModelKey{
+		ParticipantAddress: testutil.Executor,
+		ModelID:            "model-a",
+	}
+	guardian := testutil.Creator
+
+	wc := &PoCWeightCalculator{
+		ModelVotingPowers: map[string]map[string]int64{
+			"model-a": {
+				testutil.Validator: 40,
+			},
+		},
+		TotalNetworkWeight: 100,
+		StoreCommits: map[types.PoCParticipantModelKey]types.PoCV2StoreCommit{
+			key: {
+				ParticipantAddress:       testutil.Executor,
+				PocStageStartBlockHeight: 100,
+				Count:                    10,
+				ModelId:                  "model-a",
+			},
+		},
+		NodeWeightDistributions: map[types.PoCParticipantModelKey]types.MLNodeWeightDistribution{
+			key: {
+				ParticipantAddress:       testutil.Executor,
+				PocStageStartBlockHeight: 100,
+				ModelId:                  "model-a",
+				Weights: []*types.MLNodeWeight{{
+					NodeId: "node-a",
+					Weight: 10,
+				}},
+			},
+		},
+		Validations: map[types.PoCParticipantModelKey][]types.PoCValidationV2{
+			key: {
+				{ValidatorParticipantAddress: guardian, ValidatedWeight: 10},
+			},
+		},
+		GuardianEnabled:   true,
+		GuardianAddresses: map[string]bool{guardian: true},
+		Participants: map[string]types.Participant{
+			testutil.Executor: {
+				Index:        testutil.Executor,
+				Address:      testutil.Executor,
+				ValidatorKey: "validator-key",
+				InferenceUrl: "http://executor.example.com",
+			},
+		},
+		Seeds: map[string]types.RandomSeed{
+			testutil.Executor: {
+				Participant: testutil.Executor,
+				EpochIndex:  1,
+				Signature:   "seed-sig",
+			},
+		},
+		Logger:                  noopLogger{},
+		TimeNormalizationFactor: mathsdk.LegacyOneDec(),
+	}
+
+	result := wc.Calculate()
+	require.Len(t, result, 1)
+	require.Equal(t, testutil.Executor, result[0].Index)
+}
+
 func TestPoCWeightCalculator_CalculateParticipantWeight_ProducesRawWeights(t *testing.T) {
 	modelAKey := types.PoCParticipantModelKey{
 		ParticipantAddress: testutil.Executor,
diff --git a/inference-chain/x/inference/types/claim_recipient.pb.go b/inference-chain/x/inference/types/claim_recipient.pb.go
new file mode 100644
index 0000000000..8ec0f878a8
--- /dev/null
+++ b/inference-chain/x/inference/types/claim_recipient.pb.go
@@ -0,0 +1,356 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: inference/inference/claim_recipient.proto
+
+package types
+
+import (
+	fmt "fmt"
+	proto "github.com/cosmos/gogoproto/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// ClaimRecipientEntry specifies, for a given epoch, where the participant's
+// claim rewards must be sent. An empty recipient removes the override (revert
+// to the participant's own creator address).
+type ClaimRecipientEntry struct {
+	Epoch     uint64 `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
+	Recipient string `protobuf:"bytes,2,opt,name=recipient,proto3" json:"recipient,omitempty"`
+}
+
+func (m *ClaimRecipientEntry) Reset()         { *m = ClaimRecipientEntry{} }
+func (m *ClaimRecipientEntry) String() string { return proto.CompactTextString(m) }
+func (*ClaimRecipientEntry) ProtoMessage()    {}
+func (*ClaimRecipientEntry) Descriptor() ([]byte, []int) {
+	return fileDescriptor_16b77fb042b3b8f5, []int{0}
+}
+func (m *ClaimRecipientEntry) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ClaimRecipientEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ClaimRecipientEntry.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 *ClaimRecipientEntry) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ClaimRecipientEntry.Merge(m, src)
+}
+func (m *ClaimRecipientEntry) XXX_Size() int {
+	return m.Size()
+}
+func (m *ClaimRecipientEntry) XXX_DiscardUnknown() {
+	xxx_messageInfo_ClaimRecipientEntry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ClaimRecipientEntry proto.InternalMessageInfo
+
+func (m *ClaimRecipientEntry) GetEpoch() uint64 {
+	if m != nil {
+		return m.Epoch
+	}
+	return 0
+}
+
+func (m *ClaimRecipientEntry) GetRecipient() string {
+	if m != nil {
+		return m.Recipient
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*ClaimRecipientEntry)(nil), "inference.inference.ClaimRecipientEntry")
+}
+
+func init() {
+	proto.RegisterFile("inference/inference/claim_recipient.proto", fileDescriptor_16b77fb042b3b8f5)
+}
+
+var fileDescriptor_16b77fb042b3b8f5 = []byte{
+	// 179 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xcc, 0xcc, 0x4b, 0x4b,
+	0x2d, 0x4a, 0xcd, 0x4b, 0x4e, 0xd5, 0x47, 0xb0, 0x92, 0x73, 0x12, 0x33, 0x73, 0xe3, 0x8b, 0x52,
+	0x93, 0x33, 0x0b, 0x32, 0x53, 0xf3, 0x4a, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x84, 0xe1,
+	0x0a, 0xf4, 0xe0, 0x2c, 0x25, 0x4f, 0x2e, 0x61, 0x67, 0x90, 0xea, 0x20, 0x98, 0x62, 0xd7, 0xbc,
+	0x92, 0xa2, 0x4a, 0x21, 0x11, 0x2e, 0xd6, 0xd4, 0x82, 0xfc, 0xe4, 0x0c, 0x09, 0x46, 0x05, 0x46,
+	0x0d, 0x96, 0x20, 0x08, 0x47, 0x48, 0x86, 0x8b, 0x13, 0x6e, 0xa8, 0x04, 0x93, 0x02, 0xa3, 0x06,
+	0x67, 0x10, 0x42, 0xc0, 0xc9, 0xff, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c,
+	0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2,
+	0x4c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x0b, 0x8a, 0xf2, 0x53,
+	0x4a, 0x93, 0x4b, 0x8a, 0x93, 0x33, 0xd1, 0x1c, 0x5d, 0x81, 0xc4, 0x2e, 0xa9, 0x2c, 0x48, 0x2d,
+	0x4e, 0x62, 0x03, 0xbb, 0xdb, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xac, 0xdf, 0xf3, 0xa9, 0xe4,
+	0x00, 0x00, 0x00,
+}
+
+func (m *ClaimRecipientEntry) 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 *ClaimRecipientEntry) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ClaimRecipientEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Recipient) > 0 {
+		i -= len(m.Recipient)
+		copy(dAtA[i:], m.Recipient)
+		i = encodeVarintClaimRecipient(dAtA, i, uint64(len(m.Recipient)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Epoch != 0 {
+		i = encodeVarintClaimRecipient(dAtA, i, uint64(m.Epoch))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintClaimRecipient(dAtA []byte, offset int, v uint64) int {
+	offset -= sovClaimRecipient(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *ClaimRecipientEntry) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Epoch != 0 {
+		n += 1 + sovClaimRecipient(uint64(m.Epoch))
+	}
+	l = len(m.Recipient)
+	if l > 0 {
+		n += 1 + l + sovClaimRecipient(uint64(l))
+	}
+	return n
+}
+
+func sovClaimRecipient(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozClaimRecipient(x uint64) (n int) {
+	return sovClaimRecipient(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *ClaimRecipientEntry) 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 ErrIntOverflowClaimRecipient
+			}
+			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: ClaimRecipientEntry: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ClaimRecipientEntry: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
+			}
+			m.Epoch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowClaimRecipient
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Epoch |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowClaimRecipient
+				}
+				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 ErrInvalidLengthClaimRecipient
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthClaimRecipient
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Recipient = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipClaimRecipient(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthClaimRecipient
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipClaimRecipient(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowClaimRecipient
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowClaimRecipient
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowClaimRecipient
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthClaimRecipient
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupClaimRecipient
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthClaimRecipient
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthClaimRecipient        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowClaimRecipient          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupClaimRecipient = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/inference-chain/x/inference/types/devshard_escrow.pb.go b/inference-chain/x/inference/types/devshard_escrow.pb.go
index c81433682d..b9785973a5 100644
--- a/inference-chain/x/inference/types/devshard_escrow.pb.go
+++ b/inference-chain/x/inference/types/devshard_escrow.pb.go
@@ -37,6 +37,9 @@ type DevshardEscrow struct {
 	InferenceSealGraceNonces  uint32   `protobuf:"varint,12,opt,name=inference_seal_grace_nonces,json=inferenceSealGraceNonces,proto3" json:"inference_seal_grace_nonces,omitempty"`
 	InferenceSealGraceSeconds uint32   `protobuf:"varint,13,opt,name=inference_seal_grace_seconds,json=inferenceSealGraceSeconds,proto3" json:"inference_seal_grace_seconds,omitempty"`
 	AutoSealEveryNNonces      uint32   `protobuf:"varint,14,opt,name=auto_seal_every_n_nonces,json=autoSealEveryNNonces,proto3" json:"auto_seal_every_n_nonces,omitempty"`
+	// Snapshotted from DevshardEscrowParams at create (lane A). Zero on legacy
+	// rows means "unset"; clients fall back to DefaultDevshardValidationRate.
+	ValidationRate uint32 `protobuf:"varint,15,opt,name=validation_rate,json=validationRate,proto3" json:"validation_rate,omitempty"`
 }
 
 func (m *DevshardEscrow) Reset()         { *m = DevshardEscrow{} }
@@ -170,6 +173,13 @@ func (m *DevshardEscrow) GetAutoSealEveryNNonces() uint32 {
 	return 0
 }
 
+func (m *DevshardEscrow) GetValidationRate() uint32 {
+	if m != nil {
+		return m.ValidationRate
+	}
+	return 0
+}
+
 type DevshardHostEpochStats struct {
 	Participant          string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 	EpochIndex           uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
@@ -418,48 +428,49 @@ func init() {
 }
 
 var fileDescriptor_1fb886b60751f999 = []byte{
-	// 645 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xcd, 0x6e, 0x13, 0x3d,
-	0x14, 0xed, 0xa4, 0x69, 0x7e, 0x9c, 0xa6, 0xd2, 0xe7, 0xfe, 0x7c, 0xae, 0x5a, 0x85, 0x90, 0x55,
-	0xd8, 0xa4, 0x42, 0x15, 0xec, 0x10, 0x12, 0x50, 0x68, 0x37, 0xa5, 0x9a, 0x48, 0x2c, 0xd8, 0x58,
-	0xae, 0x7d, 0xd3, 0x58, 0x4c, 0xec, 0xc1, 0x76, 0x4a, 0xfb, 0x02, 0xac, 0x79, 0x10, 0x1e, 0x84,
-	0x65, 0x97, 0x2c, 0x51, 0xcb, 0x83, 0x20, 0xdb, 0x99, 0x69, 0xd4, 0x36, 0x12, 0x62, 0xe7, 0x7b,
-	0xee, 0x39, 0xd7, 0x73, 0xcf, 0xbd, 0x63, 0xf4, 0x44, 0xaa, 0x11, 0x18, 0x50, 0x1c, 0xf6, 0x6e,
-	0x4f, 0x02, 0xce, 0xed, 0x98, 0x19, 0x41, 0xc1, 0x72, 0xa3, 0xbf, 0x0c, 0x72, 0xa3, 0x9d, 0xc6,
-	0xeb, 0x25, 0x61, 0x50, 0x9e, 0x7a, 0x5f, 0xab, 0x68, 0xed, 0xcd, 0x8c, 0x7e, 0x10, 0xd8, 0x78,
-	0x0d, 0x55, 0xa4, 0x20, 0x49, 0x37, 0xe9, 0x57, 0xd3, 0x8a, 0x14, 0x98, 0xa0, 0x3a, 0x37, 0xc0,
-	0x9c, 0x36, 0xa4, 0xd2, 0x4d, 0xfa, 0xcd, 0xb4, 0x08, 0xf1, 0x16, 0xaa, 0xb1, 0x89, 0x9e, 0x2a,
-	0x47, 0x96, 0x03, 0x7b, 0x16, 0xe1, 0x0d, 0xb4, 0x62, 0x33, 0xed, 0x2c, 0xa9, 0x76, 0x97, 0xfb,
-	0xcd, 0x34, 0x06, 0xf8, 0x11, 0x6a, 0x41, 0xae, 0xf9, 0x98, 0x4a, 0x25, 0xe0, 0x82, 0xac, 0x04,
-	0x09, 0x0a, 0xd0, 0x91, 0x47, 0xf0, 0x36, 0x6a, 0xb0, 0x3c, 0xa7, 0x63, 0x66, 0xc7, 0xa4, 0x16,
-	0x6f, 0x62, 0x79, 0x7e, 0xc8, 0xec, 0xd8, 0x7f, 0x83, 0x05, 0xe7, 0x32, 0x10, 0xa4, 0xde, 0x4d,
-	0xfa, 0x8d, 0xb4, 0x08, 0x7d, 0x55, 0xa7, 0x3f, 0x81, 0xa2, 0xb9, 0x91, 0x1c, 0x48, 0x23, 0x56,
-	0x0d, 0xd0, 0x89, 0x47, 0x7c, 0xd5, 0x89, 0x16, 0x90, 0x51, 0x29, 0x48, 0x33, 0x56, 0x0d, 0xf1,
-	0x91, 0xc0, 0x03, 0xb4, 0x1e, 0x5a, 0x01, 0x5a, 0x3a, 0x36, 0x02, 0x20, 0x28, 0xd4, 0xf8, 0x2f,
-	0xa6, 0x0a, 0x73, 0xde, 0x02, 0xe0, 0x1e, 0x6a, 0x8f, 0x00, 0x68, 0x0e, 0x86, 0x2a, 0xad, 0x38,
-	0x90, 0x56, 0x60, 0xb6, 0x46, 0x00, 0x27, 0x60, 0x8e, 0x3d, 0x84, 0x5f, 0xa0, 0x9d, 0xd2, 0x5d,
-	0x6a, 0x81, 0x65, 0xf4, 0xcc, 0x30, 0x0e, 0x51, 0x60, 0xc9, 0x6a, 0x37, 0xe9, 0xb7, 0x53, 0x52,
-	0x52, 0x86, 0xc0, 0xb2, 0x77, 0x9e, 0x10, 0xd4, 0x16, 0xbf, 0x44, 0xbb, 0x0f, 0xca, 0x2d, 0x70,
-	0xad, 0x84, 0x25, 0xed, 0xa0, 0xdf, 0xbe, 0xaf, 0x1f, 0x46, 0x02, 0x7e, 0x8e, 0x08, 0x9b, 0x3a,
-	0x1d, 0xb5, 0x70, 0x0e, 0xe6, 0x92, 0xaa, 0xe2, 0xf2, 0xb5, 0x20, 0xde, 0xf0, 0x79, 0xaf, 0x3b,
-	0xf0, 0xd9, 0xe3, 0x78, 0x71, 0xef, 0x7b, 0x05, 0x6d, 0x15, 0xbd, 0x1e, 0x6a, 0xeb, 0x0e, 0xfc,
-	0x5c, 0x86, 0x8e, 0x39, 0x8b, 0xbb, 0xa8, 0x95, 0x33, 0xe3, 0x24, 0x97, 0x39, 0x53, 0x2e, 0x6c,
-	0x46, 0x33, 0x9d, 0x87, 0xee, 0x8e, 0xb6, 0x72, 0x6f, 0xb4, 0x5b, 0xa8, 0x36, 0x91, 0xd6, 0x82,
-	0x08, 0x9b, 0xd2, 0x4e, 0x67, 0x91, 0x9f, 0xab, 0x54, 0xe7, 0x2c, 0x93, 0x82, 0x54, 0x43, 0xa2,
-	0x08, 0x31, 0x46, 0x55, 0xae, 0xad, 0x9b, 0xad, 0x49, 0x38, 0xe3, 0xa7, 0x68, 0xc3, 0xc0, 0xe7,
-	0xa9, 0x34, 0x20, 0x68, 0x60, 0x31, 0x27, 0xb5, 0xb2, 0x61, 0x59, 0xda, 0xe9, 0x7a, 0x91, 0xfb,
-	0x70, 0x9b, 0xc2, 0xfb, 0x68, 0x93, 0xeb, 0x49, 0x9e, 0x81, 0xbb, 0xa3, 0xa9, 0x47, 0x2f, 0xca,
-	0xe4, 0xbc, 0xe8, 0x31, 0x5a, 0x8d, 0x7f, 0x0e, 0xe5, 0x61, 0xbb, 0x1b, 0x81, 0xdb, 0x8a, 0xd8,
-	0x6b, 0x0f, 0xf5, 0x7e, 0x27, 0x68, 0xa7, 0xb0, 0x6b, 0x18, 0x56, 0x71, 0x02, 0xca, 0x79, 0xe3,
-	0xa2, 0x67, 0xff, 0xa3, 0xba, 0xdf, 0x7a, 0x3a, 0xfb, 0x93, 0xda, 0x69, 0xcd, 0x87, 0x47, 0x62,
-	0xce, 0x89, 0xca, 0x22, 0x27, 0x96, 0x1f, 0x76, 0xa2, 0xfa, 0x17, 0x4e, 0xac, 0xfc, 0x83, 0x13,
-	0xb5, 0xc5, 0x4e, 0xf4, 0x8e, 0xd1, 0x66, 0xd9, 0x65, 0xa6, 0xdd, 0x50, 0x9e, 0x29, 0xe6, 0xa6,
-	0x06, 0x16, 0xf7, 0xb7, 0x8b, 0x9a, 0xb6, 0x60, 0x85, 0x16, 0x57, 0xd3, 0x5b, 0xe0, 0xd5, 0xfb,
-	0x1f, 0xd7, 0x9d, 0xe4, 0xea, 0xba, 0x93, 0xfc, 0xba, 0xee, 0x24, 0xdf, 0x6e, 0x3a, 0x4b, 0x57,
-	0x37, 0x9d, 0xa5, 0x9f, 0x37, 0x9d, 0xa5, 0x8f, 0xcf, 0xce, 0xa4, 0x1b, 0x4f, 0x4f, 0x07, 0x5c,
-	0x4f, 0xf6, 0x72, 0xa3, 0xc5, 0x94, 0x3b, 0xcb, 0xe5, 0x9d, 0x87, 0xed, 0x62, 0xee, 0xec, 0x2e,
-	0x73, 0xb0, 0xa7, 0xb5, 0xf0, 0xb6, 0xed, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xca, 0xbd, 0x3e,
-	0x7d, 0x08, 0x05, 0x00, 0x00,
+	// 661 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xcb, 0x6e, 0x13, 0x31,
+	0x14, 0xed, 0xa4, 0x69, 0x1e, 0x4e, 0x93, 0x0a, 0xf7, 0x81, 0xab, 0x56, 0x21, 0x64, 0x43, 0xd8,
+	0xa4, 0x42, 0x15, 0xec, 0x10, 0x12, 0x50, 0x68, 0x37, 0xa5, 0x9a, 0x48, 0x2c, 0xd8, 0x58, 0xae,
+	0x7d, 0xd3, 0x58, 0x4c, 0xec, 0xc1, 0x76, 0x4a, 0xfb, 0x17, 0x7c, 0x08, 0x12, 0xbf, 0xc1, 0xb2,
+	0x4b, 0x96, 0xa8, 0xe5, 0x43, 0x90, 0x3d, 0x99, 0x49, 0xd4, 0x36, 0x12, 0x62, 0xe7, 0x7b, 0xee,
+	0x39, 0xd7, 0xf6, 0x99, 0xe3, 0x41, 0x4f, 0xa5, 0x1a, 0x82, 0x01, 0xc5, 0x61, 0x6f, 0xb6, 0x12,
+	0x70, 0x6e, 0x47, 0xcc, 0x08, 0x0a, 0x96, 0x1b, 0xfd, 0xb5, 0x9f, 0x1a, 0xed, 0x34, 0x5e, 0x2f,
+	0x08, 0xfd, 0x62, 0xd5, 0xfd, 0x51, 0x46, 0xad, 0xb7, 0x53, 0xfa, 0x41, 0x60, 0xe3, 0x16, 0x2a,
+	0x49, 0x41, 0xa2, 0x4e, 0xd4, 0x2b, 0xc7, 0x25, 0x29, 0x30, 0x41, 0x55, 0x6e, 0x80, 0x39, 0x6d,
+	0x48, 0xa9, 0x13, 0xf5, 0xea, 0x71, 0x5e, 0xe2, 0x2d, 0x54, 0x61, 0x63, 0x3d, 0x51, 0x8e, 0x2c,
+	0x07, 0xf6, 0xb4, 0xc2, 0x1b, 0x68, 0xc5, 0x26, 0xda, 0x59, 0x52, 0xee, 0x2c, 0xf7, 0xea, 0x71,
+	0x56, 0xe0, 0x47, 0xa8, 0x01, 0xa9, 0xe6, 0x23, 0x2a, 0x95, 0x80, 0x0b, 0xb2, 0x12, 0x24, 0x28,
+	0x40, 0x47, 0x1e, 0xc1, 0xdb, 0xa8, 0xc6, 0xd2, 0x94, 0x8e, 0x98, 0x1d, 0x91, 0x4a, 0xb6, 0x13,
+	0x4b, 0xd3, 0x43, 0x66, 0x47, 0xfe, 0x0c, 0x16, 0x9c, 0x4b, 0x40, 0x90, 0x6a, 0x27, 0xea, 0xd5,
+	0xe2, 0xbc, 0xf4, 0x53, 0x9d, 0xfe, 0x0c, 0x8a, 0xa6, 0x46, 0x72, 0x20, 0xb5, 0x6c, 0x6a, 0x80,
+	0x4e, 0x3c, 0xe2, 0xa7, 0x8e, 0xb5, 0x80, 0x84, 0x4a, 0x41, 0xea, 0xd9, 0xd4, 0x50, 0x1f, 0x09,
+	0xdc, 0x47, 0xeb, 0xe1, 0x2a, 0x40, 0x0b, 0xc7, 0x86, 0x00, 0x04, 0x85, 0x19, 0x0f, 0xb2, 0x56,
+	0x6e, 0xce, 0x3b, 0x00, 0xdc, 0x45, 0xcd, 0x21, 0x00, 0x4d, 0xc1, 0x50, 0xa5, 0x15, 0x07, 0xd2,
+	0x08, 0xcc, 0xc6, 0x10, 0xe0, 0x04, 0xcc, 0xb1, 0x87, 0xf0, 0x4b, 0xb4, 0x53, 0xb8, 0x4b, 0x2d,
+	0xb0, 0x84, 0x9e, 0x19, 0xc6, 0x21, 0x13, 0x58, 0xb2, 0xda, 0x89, 0x7a, 0xcd, 0x98, 0x14, 0x94,
+	0x01, 0xb0, 0xe4, 0xbd, 0x27, 0x04, 0xb5, 0xc5, 0xaf, 0xd0, 0xee, 0xbd, 0x72, 0x0b, 0x5c, 0x2b,
+	0x61, 0x49, 0x33, 0xe8, 0xb7, 0xef, 0xea, 0x07, 0x19, 0x01, 0xbf, 0x40, 0x84, 0x4d, 0x9c, 0xce,
+	0xb4, 0x70, 0x0e, 0xe6, 0x92, 0xaa, 0x7c, 0xf3, 0x56, 0x10, 0x6f, 0xf8, 0xbe, 0xd7, 0x1d, 0xf8,
+	0xee, 0xf1, 0x74, 0xe3, 0x27, 0x68, 0xed, 0x9c, 0x25, 0x52, 0x30, 0x27, 0xb5, 0xa2, 0x86, 0x39,
+	0x20, 0x6b, 0x81, 0xde, 0x9a, 0xc1, 0x31, 0x73, 0xd0, 0xfd, 0x5e, 0x42, 0x5b, 0xb9, 0x29, 0x87,
+	0xda, 0xba, 0x03, 0xff, 0x01, 0x07, 0x8e, 0x39, 0x8b, 0x3b, 0xa8, 0x91, 0x32, 0xe3, 0x24, 0x97,
+	0x29, 0x53, 0x2e, 0x44, 0xa8, 0x1e, 0xcf, 0x43, 0xb7, 0x33, 0x50, 0xba, 0x93, 0x81, 0x2d, 0x54,
+	0x19, 0x4b, 0x6b, 0x41, 0x84, 0x48, 0x35, 0xe3, 0x69, 0xe5, 0x03, 0x20, 0x55, 0x38, 0x09, 0x29,
+	0x87, 0x46, 0x5e, 0x62, 0x8c, 0xca, 0x5c, 0x5b, 0x37, 0xcd, 0x53, 0x58, 0xe3, 0x67, 0x68, 0xc3,
+	0xc0, 0x97, 0x89, 0x34, 0x20, 0xe8, 0xec, 0xf8, 0x36, 0xa4, 0xaa, 0x19, 0xaf, 0xe7, 0xbd, 0x8f,
+	0xb3, 0x16, 0xde, 0x47, 0x9b, 0x5c, 0x8f, 0xd3, 0x04, 0xdc, 0x2d, 0x4d, 0x35, 0x33, 0xad, 0x68,
+	0xce, 0x8b, 0x1e, 0xa3, 0xd5, 0xec, 0x89, 0x51, 0x1e, 0x9e, 0x41, 0x2d, 0x70, 0x1b, 0x19, 0xf6,
+	0xc6, 0x43, 0xdd, 0x3f, 0x11, 0xda, 0xc9, 0xed, 0x1a, 0x84, 0xcc, 0x8e, 0x41, 0x39, 0x6f, 0x5c,
+	0xe6, 0xd9, 0x43, 0x54, 0xf5, 0xcf, 0x83, 0x4e, 0x9f, 0x5c, 0x33, 0xae, 0xf8, 0xf2, 0x48, 0xcc,
+	0x39, 0x51, 0x5a, 0xe4, 0xc4, 0xf2, 0xfd, 0x4e, 0x94, 0xff, 0xc1, 0x89, 0x95, 0xff, 0x70, 0xa2,
+	0xb2, 0xd8, 0x89, 0xee, 0x31, 0xda, 0x2c, 0x6e, 0x99, 0x68, 0x37, 0x90, 0x67, 0x8a, 0xb9, 0x89,
+	0x81, 0xc5, 0xf7, 0xdb, 0x45, 0x75, 0x9b, 0xb3, 0xc2, 0x15, 0x57, 0xe3, 0x19, 0xf0, 0xfa, 0xc3,
+	0xcf, 0xeb, 0x76, 0x74, 0x75, 0xdd, 0x8e, 0x7e, 0x5f, 0xb7, 0xa3, 0x6f, 0x37, 0xed, 0xa5, 0xab,
+	0x9b, 0xf6, 0xd2, 0xaf, 0x9b, 0xf6, 0xd2, 0xa7, 0xe7, 0x67, 0xd2, 0x8d, 0x26, 0xa7, 0x7d, 0xae,
+	0xc7, 0x7b, 0xa9, 0xd1, 0x62, 0xc2, 0x9d, 0xe5, 0xf2, 0xd6, 0x1f, 0xf0, 0x62, 0x6e, 0xed, 0x2e,
+	0x53, 0xb0, 0xa7, 0x95, 0xf0, 0x13, 0xdc, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x57, 0x59,
+	0x84, 0x31, 0x05, 0x00, 0x00,
 }
 
 func (m *DevshardEscrow) Marshal() (dAtA []byte, err error) {
@@ -482,6 +493,11 @@ func (m *DevshardEscrow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.ValidationRate != 0 {
+		i = encodeVarintDevshardEscrow(dAtA, i, uint64(m.ValidationRate))
+		i--
+		dAtA[i] = 0x78
+	}
 	if m.AutoSealEveryNNonces != 0 {
 		i = encodeVarintDevshardEscrow(dAtA, i, uint64(m.AutoSealEveryNNonces))
 		i--
@@ -788,6 +804,9 @@ func (m *DevshardEscrow) Size() (n int) {
 	if m.AutoSealEveryNNonces != 0 {
 		n += 1 + sovDevshardEscrow(uint64(m.AutoSealEveryNNonces))
 	}
+	if m.ValidationRate != 0 {
+		n += 1 + sovDevshardEscrow(uint64(m.ValidationRate))
+	}
 	return n
 }
 
@@ -1222,6 +1241,25 @@ func (m *DevshardEscrow) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidationRate", wireType)
+			}
+			m.ValidationRate = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDevshardEscrow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ValidationRate |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipDevshardEscrow(dAtA[iNdEx:])
diff --git a/inference-chain/x/inference/types/devshard_escrow_consensus.go b/inference-chain/x/inference/types/devshard_escrow_consensus.go
new file mode 100644
index 0000000000..919a6f173c
--- /dev/null
+++ b/inference-chain/x/inference/types/devshard_escrow_consensus.go
@@ -0,0 +1,10 @@
+package types
+
+// DevshardValidationRateForCreate returns the validation_rate snapshotted onto a
+// DevshardEscrow at create. Governance zero falls back to the compiled default.
+func DevshardValidationRateForCreate(ep *DevshardEscrowParams) uint32 {
+	if ep == nil || ep.ValidationRate == 0 {
+		return DefaultDevshardValidationRate
+	}
+	return ep.ValidationRate
+}
diff --git a/inference-chain/x/inference/types/devshard_escrow_consensus_test.go b/inference-chain/x/inference/types/devshard_escrow_consensus_test.go
new file mode 100644
index 0000000000..7d70b3da58
--- /dev/null
+++ b/inference-chain/x/inference/types/devshard_escrow_consensus_test.go
@@ -0,0 +1,14 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDevshardValidationRateForCreate(t *testing.T) {
+	require.Equal(t, DefaultDevshardValidationRate, DevshardValidationRateForCreate(nil))
+	require.Equal(t, DefaultDevshardValidationRate, DevshardValidationRateForCreate(&DevshardEscrowParams{}))
+	require.Equal(t, uint32(3000), DevshardValidationRateForCreate(&DevshardEscrowParams{ValidationRate: 3000}))
+	require.Equal(t, uint32(10000), DevshardValidationRateForCreate(&DevshardEscrowParams{ValidationRate: 10000}))
+}
diff --git a/inference-chain/x/inference/types/errors.go b/inference-chain/x/inference/types/errors.go
index 26f70ace13..732c04135d 100644
--- a/inference-chain/x/inference/types/errors.go
+++ b/inference-chain/x/inference/types/errors.go
@@ -76,4 +76,20 @@ var (
 	ErrEpochIndexOutOfRange                  = sdkerrors.Register(ModuleName, 1174, "epoch index can only be current or upcoming epoch")
 	ErrSelfDelegation                        = sdkerrors.Register(ModuleName, 1175, "self-delegation not allowed")
 	ErrInvalidDelegateTarget                 = sdkerrors.Register(ModuleName, 1176, "invalid delegation target")
+	ErrMaintenanceNotImplemented             = sdkerrors.Register(ModuleName, 1177, "maintenance feature not yet implemented")
+	ErrMaintenanceDisabled                   = sdkerrors.Register(ModuleName, 1178, "maintenance windows are disabled")
+	ErrMaintenanceInsufficientCredit         = sdkerrors.Register(ModuleName, 1179, "insufficient maintenance credit")
+	ErrMaintenanceInsufficientLeadTime       = sdkerrors.Register(ModuleName, 1180, "start height does not satisfy minimum scheduling lead time")
+	ErrMaintenanceDurationExceeded           = sdkerrors.Register(ModuleName, 1181, "duration exceeds maximum maintenance window blocks")
+	ErrMaintenanceConcurrentCountExceeded    = sdkerrors.Register(ModuleName, 1182, "concurrent maintenance participant count cap exceeded")
+	ErrMaintenanceConcurrentPowerExceeded    = sdkerrors.Register(ModuleName, 1183, "concurrent maintenance power cap exceeded")
+	ErrMaintenanceOverlap                    = sdkerrors.Register(ModuleName, 1184, "maintenance window overlaps existing reservation for this participant")
+	ErrMaintenanceAlreadyScheduled           = sdkerrors.Register(ModuleName, 1185, "participant already has a scheduled maintenance window")
+	ErrMaintenanceReservationNotFound        = sdkerrors.Register(ModuleName, 1186, "maintenance reservation not found")
+	ErrMaintenanceNotScheduled               = sdkerrors.Register(ModuleName, 1187, "reservation is not in scheduled state")
+	ErrMaintenanceOverlapsPoCPhase           = sdkerrors.Register(ModuleName, 1188, "maintenance window overlaps PoC commit/exchange phase")
+	ErrMaintenanceOverlapsDKGPhase           = sdkerrors.Register(ModuleName, 1189, "maintenance window overlaps DKG phase")
+	ErrMaintenanceInvalidParticipant         = sdkerrors.Register(ModuleName, 1190, "invalid participant address")
+	ErrMaintenanceZeroDuration               = sdkerrors.Register(ModuleName, 1191, "duration_blocks must be positive")
+	ErrMaintenanceCompletionHeightOverflow   = sdkerrors.Register(ModuleName, 1192, "maintenance completion height overflows int64")
 )
diff --git a/inference-chain/x/inference/types/expected_keepers.go b/inference-chain/x/inference/types/expected_keepers.go
index 3446d7d188..3a8cb61bc9 100644
--- a/inference-chain/x/inference/types/expected_keepers.go
+++ b/inference-chain/x/inference/types/expected_keepers.go
@@ -77,6 +77,11 @@ type ValidatorSet interface {
 type StakingKeeper interface {
 	SetComputeValidators(ctx context.Context, computeResults []keeper.ComputeResult, isTestnet bool) ([]types.Validator, error)
 	GetAllValidators(ctx context.Context) (validators []types.Validator, err error)
+	// O(1)/O(log) lookups used by the maintenance feature to avoid full
+	// validator-set scans on the slashing hot path and concurrency checks.
+	GetValidatorByConsAddr(ctx context.Context, consAddr sdk.ConsAddress) (validator types.Validator, err error)
+	GetValidator(ctx context.Context, addr sdk.ValAddress) (validator types.Validator, err error)
+	GetLastTotalPower(ctx context.Context) (math.Int, error)
 }
 
 // CollateralKeeper defines the expected interface for the Collateral module.
diff --git a/inference-chain/x/inference/types/keys.go b/inference-chain/x/inference/types/keys.go
index ca790d5aec..51189388cd 100644
--- a/inference-chain/x/inference/types/keys.go
+++ b/inference-chain/x/inference/types/keys.go
@@ -103,7 +103,30 @@ var (
 	// canonical bech32 address.
 	BridgeTransactionValidatorsPrefix = collections.NewPrefix(64)
 	PreservedNodesSnapshotPrefix      = collections.NewPrefix(65)
-	ParamsKey                         = []byte("p_inference")
+	// Maintenance window collections. Prefixes start at 100 to (a) leave room
+	// for upstream's BridgeTransactionValidators (64) and PreservedNodesSnapshot (65)
+	// which shipped first on gm/microrelease, and (b) avoid colliding with
+	// legacy raw-byte string keys whose first byte falls in the ASCII letter
+	// range (e.g. "GenesisOnlyData/value/" — 'G' = 71 — which collides with a
+	// uint64-keyed collection iterator at prefix 71). Byte 100 ('d') is the
+	// first ASCII letter not used as a leading byte of any current legacy
+	// string key in this module; using 'd' onward keeps maintenance prefixes
+	// safely outside the live legacy-key namespace.
+	MaintenanceReservationsPrefix       = collections.NewPrefix(100)
+	MaintenanceReservationCounterPrefix = collections.NewPrefix(101)
+	MaintenanceStatesPrefix             = collections.NewPrefix(102)
+	MaintenanceTransitionsPrefix        = collections.NewPrefix(103)
+	// Index of currently-active maintenance reservations (key = reservationID).
+	// Avoids O(M) full-scan of MaintenanceStates in the MaintenanceActive query.
+	MaintenanceActiveIndexPrefix = collections.NewPrefix(104)
+	// Index of currently-scheduled maintenance reservations (key = reservationID).
+	// Lets concurrency / schedulability queries iterate only the bounded set
+	// of scheduled reservations instead of every participant's MaintenanceState.
+	MaintenanceScheduledIndexPrefix = collections.NewPrefix(105)
+	ClaimRecipientsPrefix           = collections.NewPrefix(106)
+	ClaimRecipientsByEpochPrefix    = collections.NewPrefix(107)
+	DelegationRewardTransferSnapshotPrefix = collections.NewPrefix(108)
+	ParamsKey                              = []byte("p_inference")
 )
 
 func KeyPrefix(p string) []byte {
diff --git a/inference-chain/x/inference/types/logging.go b/inference-chain/x/inference/types/logging.go
index 8fb40def69..2a92420769 100644
--- a/inference-chain/x/inference/types/logging.go
+++ b/inference-chain/x/inference/types/logging.go
@@ -28,6 +28,7 @@ const (
 	ValidationRecovery
 	Allocation
 	PayloadStorage
+	Maintenance
 	Testing = 255
 )
 
@@ -85,6 +86,8 @@ func (s SubSystem) String() string {
 		return "Allocation"
 	case PayloadStorage:
 		return "PayloadStorage"
+	case Maintenance:
+		return "Maintenance"
 	default:
 		return "Unknown"
 	}
diff --git a/inference-chain/x/inference/types/maintenance.pb.go b/inference-chain/x/inference/types/maintenance.pb.go
new file mode 100644
index 0000000000..85b677d40e
--- /dev/null
+++ b/inference-chain/x/inference/types/maintenance.pb.go
@@ -0,0 +1,1234 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: inference/inference/maintenance.proto
+
+package types
+
+import (
+	fmt "fmt"
+	proto "github.com/cosmos/gogoproto/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// MaintenanceReservationStatus represents the lifecycle status of a maintenance reservation.
+type MaintenanceReservationStatus int32
+
+const (
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED MaintenanceReservationStatus = 0
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_SCHEDULED   MaintenanceReservationStatus = 1
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_ACTIVE      MaintenanceReservationStatus = 2
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_COMPLETED   MaintenanceReservationStatus = 3
+	MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_CANCELED    MaintenanceReservationStatus = 4
+)
+
+var MaintenanceReservationStatus_name = map[int32]string{
+	0: "MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED",
+	1: "MAINTENANCE_RESERVATION_STATUS_SCHEDULED",
+	2: "MAINTENANCE_RESERVATION_STATUS_ACTIVE",
+	3: "MAINTENANCE_RESERVATION_STATUS_COMPLETED",
+	4: "MAINTENANCE_RESERVATION_STATUS_CANCELED",
+}
+
+var MaintenanceReservationStatus_value = map[string]int32{
+	"MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED": 0,
+	"MAINTENANCE_RESERVATION_STATUS_SCHEDULED":   1,
+	"MAINTENANCE_RESERVATION_STATUS_ACTIVE":      2,
+	"MAINTENANCE_RESERVATION_STATUS_COMPLETED":   3,
+	"MAINTENANCE_RESERVATION_STATUS_CANCELED":    4,
+}
+
+func (x MaintenanceReservationStatus) String() string {
+	return proto.EnumName(MaintenanceReservationStatus_name, int32(x))
+}
+
+func (MaintenanceReservationStatus) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_3e2613976197972a, []int{0}
+}
+
+// MaintenanceTransitionType represents the type of lifecycle transition at a given block height.
+type MaintenanceTransitionType int32
+
+const (
+	MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED MaintenanceTransitionType = 0
+	MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_ACTIVATE    MaintenanceTransitionType = 1
+	MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_COMPLETE    MaintenanceTransitionType = 2
+)
+
+var MaintenanceTransitionType_name = map[int32]string{
+	0: "MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED",
+	1: "MAINTENANCE_TRANSITION_TYPE_ACTIVATE",
+	2: "MAINTENANCE_TRANSITION_TYPE_COMPLETE",
+}
+
+var MaintenanceTransitionType_value = map[string]int32{
+	"MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED": 0,
+	"MAINTENANCE_TRANSITION_TYPE_ACTIVATE":    1,
+	"MAINTENANCE_TRANSITION_TYPE_COMPLETE":    2,
+}
+
+func (x MaintenanceTransitionType) String() string {
+	return proto.EnumName(MaintenanceTransitionType_name, int32(x))
+}
+
+func (MaintenanceTransitionType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_3e2613976197972a, []int{1}
+}
+
+// MaintenanceReservation represents a scheduled maintenance window for a participant.
+type MaintenanceReservation struct {
+	ReservationId     uint64                       `protobuf:"varint,1,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+	Participant       string                       `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
+	StartHeight       int64                        `protobuf:"varint,3,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
+	DurationBlocks    uint64                       `protobuf:"varint,4,opt,name=duration_blocks,json=durationBlocks,proto3" json:"duration_blocks,omitempty"`
+	CreatedBy         string                       `protobuf:"bytes,5,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"`
+	Status            MaintenanceReservationStatus `protobuf:"varint,6,opt,name=status,proto3,enum=inference.inference.MaintenanceReservationStatus" json:"status,omitempty"`
+	ActivationWarning string                       `protobuf:"bytes,7,opt,name=activation_warning,json=activationWarning,proto3" json:"activation_warning,omitempty"`
+}
+
+func (m *MaintenanceReservation) Reset()         { *m = MaintenanceReservation{} }
+func (m *MaintenanceReservation) String() string { return proto.CompactTextString(m) }
+func (*MaintenanceReservation) ProtoMessage()    {}
+func (*MaintenanceReservation) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3e2613976197972a, []int{0}
+}
+func (m *MaintenanceReservation) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MaintenanceReservation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MaintenanceReservation.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 *MaintenanceReservation) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaintenanceReservation.Merge(m, src)
+}
+func (m *MaintenanceReservation) XXX_Size() int {
+	return m.Size()
+}
+func (m *MaintenanceReservation) XXX_DiscardUnknown() {
+	xxx_messageInfo_MaintenanceReservation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MaintenanceReservation proto.InternalMessageInfo
+
+func (m *MaintenanceReservation) GetReservationId() uint64 {
+	if m != nil {
+		return m.ReservationId
+	}
+	return 0
+}
+
+func (m *MaintenanceReservation) GetParticipant() string {
+	if m != nil {
+		return m.Participant
+	}
+	return ""
+}
+
+func (m *MaintenanceReservation) GetStartHeight() int64 {
+	if m != nil {
+		return m.StartHeight
+	}
+	return 0
+}
+
+func (m *MaintenanceReservation) GetDurationBlocks() uint64 {
+	if m != nil {
+		return m.DurationBlocks
+	}
+	return 0
+}
+
+func (m *MaintenanceReservation) GetCreatedBy() string {
+	if m != nil {
+		return m.CreatedBy
+	}
+	return ""
+}
+
+func (m *MaintenanceReservation) GetStatus() MaintenanceReservationStatus {
+	if m != nil {
+		return m.Status
+	}
+	return MaintenanceReservationStatus_MAINTENANCE_RESERVATION_STATUS_UNSPECIFIED
+}
+
+func (m *MaintenanceReservation) GetActivationWarning() string {
+	if m != nil {
+		return m.ActivationWarning
+	}
+	return ""
+}
+
+// MaintenanceState holds per-participant maintenance metadata, keyed by participant address.
+type MaintenanceState struct {
+	Participant  string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	CreditBlocks uint64 `protobuf:"varint,2,opt,name=credit_blocks,json=creditBlocks,proto3" json:"credit_blocks,omitempty"`
+	// Earliest epoch covered by the most recent maintenance window (set on
+	// activation). Combined with last_maintenance_end_epoch, defines the
+	// [start, end] range of epochs in which credit accrual is suppressed
+	// for the participant's most recent window.
+	LastMaintenanceEpoch   uint64 `protobuf:"varint,3,opt,name=last_maintenance_epoch,json=lastMaintenanceEpoch,proto3" json:"last_maintenance_epoch,omitempty"`
+	ActiveReservationId    uint64 `protobuf:"varint,4,opt,name=active_reservation_id,json=activeReservationId,proto3" json:"active_reservation_id,omitempty"`
+	ScheduledReservationId uint64 `protobuf:"varint,5,opt,name=scheduled_reservation_id,json=scheduledReservationId,proto3" json:"scheduled_reservation_id,omitempty"`
+	// Latest epoch covered by the most recent maintenance window. Set on
+	// completion (BeginBlock) to the epoch in which the window's last block
+	// fell. While the window is still active, this stays at the activation
+	// epoch and the active_reservation_id check covers the in-progress epochs.
+	LastMaintenanceEndEpoch uint64 `protobuf:"varint,6,opt,name=last_maintenance_end_epoch,json=lastMaintenanceEndEpoch,proto3" json:"last_maintenance_end_epoch,omitempty"`
+}
+
+func (m *MaintenanceState) Reset()         { *m = MaintenanceState{} }
+func (m *MaintenanceState) String() string { return proto.CompactTextString(m) }
+func (*MaintenanceState) ProtoMessage()    {}
+func (*MaintenanceState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3e2613976197972a, []int{1}
+}
+func (m *MaintenanceState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MaintenanceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MaintenanceState.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 *MaintenanceState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaintenanceState.Merge(m, src)
+}
+func (m *MaintenanceState) XXX_Size() int {
+	return m.Size()
+}
+func (m *MaintenanceState) XXX_DiscardUnknown() {
+	xxx_messageInfo_MaintenanceState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MaintenanceState proto.InternalMessageInfo
+
+func (m *MaintenanceState) GetParticipant() string {
+	if m != nil {
+		return m.Participant
+	}
+	return ""
+}
+
+func (m *MaintenanceState) GetCreditBlocks() uint64 {
+	if m != nil {
+		return m.CreditBlocks
+	}
+	return 0
+}
+
+func (m *MaintenanceState) GetLastMaintenanceEpoch() uint64 {
+	if m != nil {
+		return m.LastMaintenanceEpoch
+	}
+	return 0
+}
+
+func (m *MaintenanceState) GetActiveReservationId() uint64 {
+	if m != nil {
+		return m.ActiveReservationId
+	}
+	return 0
+}
+
+func (m *MaintenanceState) GetScheduledReservationId() uint64 {
+	if m != nil {
+		return m.ScheduledReservationId
+	}
+	return 0
+}
+
+func (m *MaintenanceState) GetLastMaintenanceEndEpoch() uint64 {
+	if m != nil {
+		return m.LastMaintenanceEndEpoch
+	}
+	return 0
+}
+
+// MaintenanceTransition is an entry in the exact-height transition schedule for BeginBlock processing.
+type MaintenanceTransition struct {
+	BlockHeight   int64                     `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
+	ReservationId uint64                    `protobuf:"varint,2,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+	Type          MaintenanceTransitionType `protobuf:"varint,3,opt,name=type,proto3,enum=inference.inference.MaintenanceTransitionType" json:"type,omitempty"`
+}
+
+func (m *MaintenanceTransition) Reset()         { *m = MaintenanceTransition{} }
+func (m *MaintenanceTransition) String() string { return proto.CompactTextString(m) }
+func (*MaintenanceTransition) ProtoMessage()    {}
+func (*MaintenanceTransition) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3e2613976197972a, []int{2}
+}
+func (m *MaintenanceTransition) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MaintenanceTransition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MaintenanceTransition.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 *MaintenanceTransition) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaintenanceTransition.Merge(m, src)
+}
+func (m *MaintenanceTransition) XXX_Size() int {
+	return m.Size()
+}
+func (m *MaintenanceTransition) XXX_DiscardUnknown() {
+	xxx_messageInfo_MaintenanceTransition.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MaintenanceTransition proto.InternalMessageInfo
+
+func (m *MaintenanceTransition) GetBlockHeight() int64 {
+	if m != nil {
+		return m.BlockHeight
+	}
+	return 0
+}
+
+func (m *MaintenanceTransition) GetReservationId() uint64 {
+	if m != nil {
+		return m.ReservationId
+	}
+	return 0
+}
+
+func (m *MaintenanceTransition) GetType() MaintenanceTransitionType {
+	if m != nil {
+		return m.Type
+	}
+	return MaintenanceTransitionType_MAINTENANCE_TRANSITION_TYPE_UNSPECIFIED
+}
+
+func init() {
+	proto.RegisterEnum("inference.inference.MaintenanceReservationStatus", MaintenanceReservationStatus_name, MaintenanceReservationStatus_value)
+	proto.RegisterEnum("inference.inference.MaintenanceTransitionType", MaintenanceTransitionType_name, MaintenanceTransitionType_value)
+	proto.RegisterType((*MaintenanceReservation)(nil), "inference.inference.MaintenanceReservation")
+	proto.RegisterType((*MaintenanceState)(nil), "inference.inference.MaintenanceState")
+	proto.RegisterType((*MaintenanceTransition)(nil), "inference.inference.MaintenanceTransition")
+}
+
+func init() {
+	proto.RegisterFile("inference/inference/maintenance.proto", fileDescriptor_3e2613976197972a)
+}
+
+var fileDescriptor_3e2613976197972a = []byte{
+	// 635 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdf, 0x4e, 0xd3, 0x50,
+	0x18, 0xdf, 0x29, 0x63, 0x86, 0x0f, 0x98, 0xf5, 0x20, 0x58, 0x8d, 0x2e, 0x03, 0x25, 0x4c, 0xd4,
+	0x12, 0x51, 0x13, 0x13, 0xaf, 0xba, 0xed, 0x18, 0x9a, 0xc0, 0x20, 0x6d, 0xc1, 0xe8, 0x4d, 0xd3,
+	0xb5, 0x47, 0x76, 0x22, 0xb4, 0xcd, 0xe9, 0x99, 0xba, 0x5b, 0x9f, 0xc0, 0x07, 0xf0, 0xd6, 0x97,
+	0xf0, 0x01, 0x8c, 0x97, 0x5c, 0x7a, 0x69, 0xe0, 0x45, 0xcc, 0xce, 0x3a, 0x56, 0xca, 0x64, 0xde,
+	0x9d, 0xfe, 0x7e, 0xdf, 0xbf, 0xdf, 0xf7, 0xfd, 0x52, 0x58, 0x65, 0xe1, 0x7b, 0xca, 0x69, 0xe8,
+	0xd3, 0x8d, 0xd1, 0xeb, 0xd8, 0x63, 0xa1, 0xa0, 0xa1, 0x17, 0xfa, 0x54, 0x8f, 0x79, 0x24, 0x22,
+	0xbc, 0x70, 0x4e, 0xea, 0xe7, 0xaf, 0x95, 0x9f, 0x0a, 0x2c, 0xed, 0x8c, 0x42, 0x2d, 0x9a, 0x50,
+	0xfe, 0xd1, 0x13, 0x2c, 0x0a, 0xf1, 0x2a, 0x94, 0xf9, 0xe8, 0xd3, 0x65, 0x81, 0x86, 0xaa, 0xa8,
+	0x56, 0xb4, 0xe6, 0x33, 0xa8, 0x19, 0xe0, 0x2a, 0xcc, 0xc6, 0x1e, 0x17, 0xcc, 0x67, 0xb1, 0x17,
+	0x0a, 0x4d, 0xa9, 0xa2, 0xda, 0x8c, 0x95, 0x85, 0xf0, 0x32, 0xcc, 0x25, 0xc2, 0xe3, 0xc2, 0xed,
+	0x50, 0x76, 0xd8, 0x11, 0xda, 0x54, 0x15, 0xd5, 0xa6, 0xac, 0x59, 0x89, 0x6d, 0x49, 0x08, 0xaf,
+	0xc1, 0xf5, 0xa0, 0xcb, 0x07, 0x8d, 0xda, 0x47, 0x91, 0xff, 0x21, 0xd1, 0x8a, 0xb2, 0x59, 0x79,
+	0x08, 0xd7, 0x25, 0x8a, 0xef, 0x01, 0xf8, 0x9c, 0x7a, 0x82, 0x06, 0x6e, 0xbb, 0xa7, 0x4d, 0xcb,
+	0x66, 0x33, 0x29, 0x52, 0xef, 0x61, 0x13, 0x4a, 0x89, 0xf0, 0x44, 0x37, 0xd1, 0x4a, 0x55, 0x54,
+	0x2b, 0x6f, 0x3e, 0xd5, 0xc7, 0x88, 0xd6, 0xc7, 0x0b, 0xb6, 0x65, 0xa2, 0x95, 0x16, 0xc0, 0x4f,
+	0x00, 0x7b, 0xbe, 0x60, 0xa9, 0xfa, 0x4f, 0x1e, 0x0f, 0x59, 0x78, 0xa8, 0x5d, 0x93, 0x1d, 0x6f,
+	0x8c, 0x98, 0x37, 0x03, 0x62, 0xe5, 0x87, 0x02, 0x6a, 0xa6, 0x6e, 0xbf, 0x18, 0xcd, 0xef, 0x06,
+	0x5d, 0xde, 0xcd, 0x7d, 0x98, 0xf7, 0x39, 0x0d, 0x98, 0x18, 0xca, 0x56, 0xa4, 0xec, 0xb9, 0x01,
+	0x98, 0x8a, 0x7e, 0x0e, 0x4b, 0x47, 0x5e, 0x22, 0xdc, 0xcc, 0x4d, 0x5d, 0x1a, 0x47, 0x7e, 0x47,
+	0xae, 0xb2, 0x68, 0xdd, 0xec, 0xb3, 0x99, 0xe6, 0xa4, 0xcf, 0xe1, 0x4d, 0x58, 0x94, 0x63, 0x52,
+	0x37, 0x77, 0xc6, 0xc1, 0x66, 0x17, 0x06, 0xa4, 0x75, 0xe1, 0x98, 0x2f, 0x41, 0x4b, 0xfc, 0x0e,
+	0x0d, 0xba, 0x47, 0x34, 0xc8, 0xa7, 0x4d, 0xcb, 0xb4, 0xa5, 0x73, 0xfe, 0x62, 0xe6, 0x2b, 0xb8,
+	0x73, 0x79, 0xc6, 0x30, 0x48, 0xe7, 0x2c, 0xc9, 0xdc, 0x5b, 0xf9, 0x39, 0xc3, 0x40, 0x8e, 0xba,
+	0xf2, 0x1d, 0xc1, 0x62, 0x06, 0x77, 0xb8, 0x17, 0x26, 0x4c, 0x9a, 0x70, 0x19, 0xe6, 0xe4, 0x62,
+	0x86, 0xde, 0x41, 0x03, 0xef, 0x48, 0x2c, 0xf5, 0xce, 0x65, 0x9f, 0x2a, 0xe3, 0x7c, 0x5a, 0x87,
+	0xa2, 0xe8, 0xc5, 0x54, 0xae, 0xac, 0xbc, 0xa9, 0x4f, 0x32, 0xc6, 0x68, 0x06, 0xa7, 0x17, 0x53,
+	0x4b, 0xe6, 0xae, 0x7f, 0x51, 0xe0, 0xee, 0x55, 0xe6, 0xc1, 0x3a, 0xac, 0xef, 0x18, 0x66, 0xcb,
+	0x21, 0x2d, 0xa3, 0xd5, 0x20, 0xae, 0x45, 0x6c, 0x62, 0x1d, 0x18, 0x8e, 0xb9, 0xdb, 0x72, 0x6d,
+	0xc7, 0x70, 0xf6, 0x6d, 0x77, 0xbf, 0x65, 0xef, 0x91, 0x86, 0xf9, 0xda, 0x24, 0x4d, 0xb5, 0x80,
+	0x1f, 0x43, 0x6d, 0x42, 0xbc, 0xdd, 0xd8, 0x22, 0xcd, 0xfd, 0x6d, 0xd2, 0x54, 0x11, 0x7e, 0x08,
+	0xab, 0x13, 0xa2, 0x8d, 0x86, 0x63, 0x1e, 0x10, 0x55, 0xf9, 0x8f, 0xc2, 0x8d, 0xdd, 0x9d, 0xbd,
+	0x6d, 0xe2, 0x90, 0xa6, 0x3a, 0x85, 0x1f, 0xc1, 0xda, 0xa4, 0xe8, 0x3e, 0xd1, 0x9f, 0xa2, 0xb8,
+	0xfe, 0x0d, 0xc1, 0xed, 0x7f, 0x2e, 0x2a, 0x5f, 0xca, 0xb1, 0x8c, 0x96, 0x6d, 0xca, 0x4a, 0xce,
+	0xdb, 0x3d, 0x92, 0x93, 0x5f, 0x83, 0x07, 0x57, 0x05, 0x4b, 0x35, 0x86, 0x43, 0x54, 0x34, 0x29,
+	0x72, 0x28, 0x46, 0x55, 0xea, 0xbb, 0xbf, 0x4e, 0x2b, 0xe8, 0xe4, 0xb4, 0x82, 0xfe, 0x9c, 0x56,
+	0xd0, 0xd7, 0xb3, 0x4a, 0xe1, 0xe4, 0xac, 0x52, 0xf8, 0x7d, 0x56, 0x29, 0xbc, 0x7b, 0x71, 0xc8,
+	0x44, 0xa7, 0xdb, 0xd6, 0xfd, 0xe8, 0x78, 0x23, 0xe6, 0x51, 0xd0, 0xf5, 0x45, 0xe2, 0xb3, 0xdc,
+	0x7f, 0xf3, 0x73, 0xe6, 0xdd, 0xbf, 0x79, 0xd2, 0x2e, 0xc9, 0xdf, 0xe7, 0xb3, 0xbf, 0x01, 0x00,
+	0x00, 0xff, 0xff, 0x21, 0x0d, 0x73, 0x8c, 0x67, 0x05, 0x00, 0x00,
+}
+
+func (m *MaintenanceReservation) 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 *MaintenanceReservation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MaintenanceReservation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ActivationWarning) > 0 {
+		i -= len(m.ActivationWarning)
+		copy(dAtA[i:], m.ActivationWarning)
+		i = encodeVarintMaintenance(dAtA, i, uint64(len(m.ActivationWarning)))
+		i--
+		dAtA[i] = 0x3a
+	}
+	if m.Status != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.Status))
+		i--
+		dAtA[i] = 0x30
+	}
+	if len(m.CreatedBy) > 0 {
+		i -= len(m.CreatedBy)
+		copy(dAtA[i:], m.CreatedBy)
+		i = encodeVarintMaintenance(dAtA, i, uint64(len(m.CreatedBy)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if m.DurationBlocks != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.DurationBlocks))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.StartHeight != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.StartHeight))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintMaintenance(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.ReservationId != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.ReservationId))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MaintenanceState) 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 *MaintenanceState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MaintenanceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.LastMaintenanceEndEpoch != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.LastMaintenanceEndEpoch))
+		i--
+		dAtA[i] = 0x30
+	}
+	if m.ScheduledReservationId != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.ScheduledReservationId))
+		i--
+		dAtA[i] = 0x28
+	}
+	if m.ActiveReservationId != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.ActiveReservationId))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.LastMaintenanceEpoch != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.LastMaintenanceEpoch))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.CreditBlocks != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.CreditBlocks))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintMaintenance(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MaintenanceTransition) 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 *MaintenanceTransition) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MaintenanceTransition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Type != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.ReservationId != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.ReservationId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.BlockHeight != 0 {
+		i = encodeVarintMaintenance(dAtA, i, uint64(m.BlockHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintMaintenance(dAtA []byte, offset int, v uint64) int {
+	offset -= sovMaintenance(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *MaintenanceReservation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ReservationId != 0 {
+		n += 1 + sovMaintenance(uint64(m.ReservationId))
+	}
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovMaintenance(uint64(l))
+	}
+	if m.StartHeight != 0 {
+		n += 1 + sovMaintenance(uint64(m.StartHeight))
+	}
+	if m.DurationBlocks != 0 {
+		n += 1 + sovMaintenance(uint64(m.DurationBlocks))
+	}
+	l = len(m.CreatedBy)
+	if l > 0 {
+		n += 1 + l + sovMaintenance(uint64(l))
+	}
+	if m.Status != 0 {
+		n += 1 + sovMaintenance(uint64(m.Status))
+	}
+	l = len(m.ActivationWarning)
+	if l > 0 {
+		n += 1 + l + sovMaintenance(uint64(l))
+	}
+	return n
+}
+
+func (m *MaintenanceState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovMaintenance(uint64(l))
+	}
+	if m.CreditBlocks != 0 {
+		n += 1 + sovMaintenance(uint64(m.CreditBlocks))
+	}
+	if m.LastMaintenanceEpoch != 0 {
+		n += 1 + sovMaintenance(uint64(m.LastMaintenanceEpoch))
+	}
+	if m.ActiveReservationId != 0 {
+		n += 1 + sovMaintenance(uint64(m.ActiveReservationId))
+	}
+	if m.ScheduledReservationId != 0 {
+		n += 1 + sovMaintenance(uint64(m.ScheduledReservationId))
+	}
+	if m.LastMaintenanceEndEpoch != 0 {
+		n += 1 + sovMaintenance(uint64(m.LastMaintenanceEndEpoch))
+	}
+	return n
+}
+
+func (m *MaintenanceTransition) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.BlockHeight != 0 {
+		n += 1 + sovMaintenance(uint64(m.BlockHeight))
+	}
+	if m.ReservationId != 0 {
+		n += 1 + sovMaintenance(uint64(m.ReservationId))
+	}
+	if m.Type != 0 {
+		n += 1 + sovMaintenance(uint64(m.Type))
+	}
+	return n
+}
+
+func sovMaintenance(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozMaintenance(x uint64) (n int) {
+	return sovMaintenance(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *MaintenanceReservation) 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 ErrIntOverflowMaintenance
+			}
+			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: MaintenanceReservation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MaintenanceReservation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+			}
+			m.ReservationId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ReservationId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				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 ErrInvalidLengthMaintenance
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
+			}
+			m.StartHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DurationBlocks", wireType)
+			}
+			m.DurationBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DurationBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreatedBy", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				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 ErrInvalidLengthMaintenance
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.CreatedBy = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+			}
+			m.Status = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Status |= MaintenanceReservationStatus(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ActivationWarning", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				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 ErrInvalidLengthMaintenance
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ActivationWarning = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMaintenance(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MaintenanceState) 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 ErrIntOverflowMaintenance
+			}
+			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: MaintenanceState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MaintenanceState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				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 ErrInvalidLengthMaintenance
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreditBlocks", wireType)
+			}
+			m.CreditBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CreditBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastMaintenanceEpoch", wireType)
+			}
+			m.LastMaintenanceEpoch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LastMaintenanceEpoch |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ActiveReservationId", wireType)
+			}
+			m.ActiveReservationId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ActiveReservationId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ScheduledReservationId", wireType)
+			}
+			m.ScheduledReservationId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ScheduledReservationId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastMaintenanceEndEpoch", wireType)
+			}
+			m.LastMaintenanceEndEpoch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LastMaintenanceEndEpoch |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMaintenance(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MaintenanceTransition) 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 ErrIntOverflowMaintenance
+			}
+			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: MaintenanceTransition: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MaintenanceTransition: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+			}
+			m.BlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+			}
+			m.ReservationId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ReservationId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= MaintenanceTransitionType(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMaintenance(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthMaintenance
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipMaintenance(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowMaintenance
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowMaintenance
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthMaintenance
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupMaintenance
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthMaintenance
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthMaintenance        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowMaintenance          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupMaintenance = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/inference-chain/x/inference/types/message_signers.go b/inference-chain/x/inference/types/message_signers.go
index 67f16ffb5b..0eda0f4a7e 100644
--- a/inference-chain/x/inference/types/message_signers.go
+++ b/inference-chain/x/inference/types/message_signers.go
@@ -49,6 +49,7 @@ func (msg *MsgSubmitUnitOfComputePriceProposal) GetSignersStrings() []string {
 }
 func (msg *MsgValidation) GetSignersStrings() []string              { return []string{msg.Creator} }
 func (msg *MsgClaimRewards) GetSignersStrings() []string            { return []string{msg.Creator} }
+func (msg *MsgSetClaimRecipients) GetSignersStrings() []string      { return []string{msg.Creator} }
 func (msg *MsgRequestBridgeMint) GetSignersStrings() []string       { return []string{msg.Creator} }
 func (msg *MsgRequestBridgeWithdrawal) GetSignersStrings() []string { return []string{msg.Creator} }
 func (msg *MsgCancelBridgeOperation) GetSignersStrings() []string   { return []string{msg.Creator} }
@@ -68,5 +69,9 @@ func (msg *MsgSetPoCDelegation) GetSignersStrings() []string    { return []strin
 func (msg *MsgRefusePoCDelegation) GetSignersStrings() []string { return []string{msg.Sender} }
 func (msg *MsgDeclarePoCIntent) GetSignersStrings() []string    { return []string{msg.Sender} }
 
+// Maintenance messages
+func (msg *MsgScheduleMaintenance) GetSignersStrings() []string { return []string{msg.Creator} }
+func (msg *MsgCancelMaintenance) GetSignersStrings() []string   { return []string{msg.Creator} }
+
 // And one validator signed message?
 func (msg *MsgBridgeExchange) GetSignersStrings() []string { return []string{msg.Validator} }
diff --git a/inference-chain/x/inference/types/params.go b/inference-chain/x/inference/types/params.go
index d1549e87de..f36c521e56 100644
--- a/inference-chain/x/inference/types/params.go
+++ b/inference-chain/x/inference/types/params.go
@@ -105,8 +105,16 @@ const (
 	DefaultDevshardFeePerNonce         uint64 = 1_000
 	DefaultDevshardRefusalTimeout      int64  = 60
 	DefaultDevshardExecutionTimeout    int64  = 1200
-	DefaultDevshardValidationRate      uint32 = 5000
+	DefaultDevshardValidationRate      uint32 = 1000
 	DefaultDevshardVoteThresholdFactor uint32 = 50
+
+	DefaultMaintenanceEnabled                         = false
+	DefaultMaintenanceMinScheduleLeadBlocks    uint64 = 100
+	DefaultMaintenanceMaxWindowBlocks          uint64 = 200
+	DefaultMaintenanceMaxConcurrentValidators  uint32 = 3
+	DefaultMaintenanceMaxConcurrentPowerBps    uint32 = 1000 // 10% in basis points
+	DefaultMaintenanceCreditCapBlocks          uint64 = 400
+	DefaultMaintenanceCreditEarnPerEpochBlocks uint64 = 20
 )
 
 // DefaultSealGraceMultiplier is the multiplier used to compute the default seal grace nonces.
@@ -196,6 +204,7 @@ func DefaultParams() Params {
 			AllowedTransferAddresses: nil, // nil = no restriction, all TAs allowed
 		},
 		DevshardEscrowParams: DefaultDevshardEscrowParams(),
+		MaintenanceParams:    DefaultMaintenanceParams(),
 		DelegationParams:     DefaultDelegationParams(),
 	}
 }
@@ -377,6 +386,66 @@ func DefaultDevshardEscrowParams() *DevshardEscrowParams {
 	}
 }
 
+func DefaultMaintenanceParams() *MaintenanceParams {
+	return &MaintenanceParams{
+		MaintenanceEnabled:                            DefaultMaintenanceEnabled,
+		MaintenanceMinScheduleLeadBlocks:              DefaultMaintenanceMinScheduleLeadBlocks,
+		MaintenanceMaxWindowBlocks:                    DefaultMaintenanceMaxWindowBlocks,
+		MaintenanceMaxConcurrentValidators:            DefaultMaintenanceMaxConcurrentValidators,
+		MaintenanceMaxConcurrentPowerBps:              DefaultMaintenanceMaxConcurrentPowerBps,
+		MaintenanceCreditCapBlocks:                    DefaultMaintenanceCreditCapBlocks,
+		MaintenanceCreditEarnPerSuccessfulEpochBlocks: DefaultMaintenanceCreditEarnPerEpochBlocks,
+	}
+}
+
+// maxMaintenanceBlocksParam bounds every governance-controlled *Blocks field.
+// Set well below math.MaxInt64 so any addition of two such values, or any
+// cast from uint64 to int64, cannot wrap. Concretely: at 5-second blocks,
+// 1e15 blocks is ~158 million years — far beyond any realistic governance
+// configuration, while still safe for arithmetic in callers like
+// msg_server_schedule_maintenance.go (blockHeight + lead) and
+// GrantMaintenanceCredit (CreditBlocks += earn).
+const maxMaintenanceBlocksParam = uint64(1e15)
+
+func (p *MaintenanceParams) Validate() error {
+	if p == nil {
+		return nil
+	}
+	if p.MaintenanceMaxWindowBlocks == 0 {
+		return fmt.Errorf("maintenance max window blocks must be positive")
+	}
+	if p.MaintenanceMaxWindowBlocks > maxMaintenanceBlocksParam {
+		return fmt.Errorf("maintenance max window blocks (%d) exceeds safe upper bound %d", p.MaintenanceMaxWindowBlocks, maxMaintenanceBlocksParam)
+	}
+	if p.MaintenanceMinScheduleLeadBlocks > maxMaintenanceBlocksParam {
+		return fmt.Errorf("maintenance min schedule lead blocks (%d) exceeds safe upper bound %d", p.MaintenanceMinScheduleLeadBlocks, maxMaintenanceBlocksParam)
+	}
+	if p.MaintenanceCreditCapBlocks == 0 {
+		return fmt.Errorf("maintenance credit cap blocks must be positive")
+	}
+	if p.MaintenanceCreditCapBlocks > maxMaintenanceBlocksParam {
+		return fmt.Errorf("maintenance credit cap blocks (%d) exceeds safe upper bound %d", p.MaintenanceCreditCapBlocks, maxMaintenanceBlocksParam)
+	}
+	if p.MaintenanceMaxConcurrentValidators == 0 {
+		return fmt.Errorf("maintenance max concurrent validators must be positive")
+	}
+	if p.MaintenanceMaxConcurrentPowerBps > 10000 {
+		return fmt.Errorf("maintenance max concurrent power bps cannot exceed 10000")
+	}
+	// Zero credit-earn silently disables credit accrual: maintenance can be
+	// scheduled exactly once (with whatever credit the participant was seeded
+	// with) and never replenishes. That is a valid governance state but a
+	// confusing one to land on by accident, so reject it here. To intentionally
+	// disable maintenance, set MaintenanceEnabled = false instead.
+	if p.MaintenanceCreditEarnPerSuccessfulEpochBlocks == 0 {
+		return fmt.Errorf("maintenance credit earn per successful epoch blocks must be positive (set maintenance_enabled=false to disable maintenance windows)")
+	}
+	if p.MaintenanceCreditEarnPerSuccessfulEpochBlocks > p.MaintenanceCreditCapBlocks {
+		return fmt.Errorf("maintenance credit earn per successful epoch blocks (%d) must not exceed credit cap (%d)", p.MaintenanceCreditEarnPerSuccessfulEpochBlocks, p.MaintenanceCreditCapBlocks)
+	}
+	return nil
+}
+
 func (p *DevshardEscrowParams) Validate() error {
 	if p.MinAmount == 0 {
 		return fmt.Errorf("devshard escrow min_amount must be positive")
@@ -677,6 +746,12 @@ func (p Params) Validate() error {
 		}
 	}
 
+	if p.MaintenanceParams != nil {
+		if err := p.MaintenanceParams.Validate(); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
diff --git a/inference-chain/x/inference/types/params.pb.go b/inference-chain/x/inference/types/params.pb.go
index 3f3b05d297..0346954e4d 100644
--- a/inference-chain/x/inference/types/params.pb.go
+++ b/inference-chain/x/inference/types/params.pb.go
@@ -42,7 +42,12 @@ type Params struct {
 	TransferAgentAccessParams *TransferAgentAccessParams `protobuf:"bytes,13,opt,name=transfer_agent_access_params,json=transferAgentAccessParams,proto3" json:"transfer_agent_access_params,omitempty"`
 	DevshardEscrowParams      *DevshardEscrowParams      `protobuf:"bytes,14,opt,name=devshard_escrow_params,json=devshardEscrowParams,proto3" json:"devshard_escrow_params,omitempty"`
 	FeeParams                 *FeeParams                 `protobuf:"bytes,15,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"`
-	DelegationParams          *DelegationParams          `protobuf:"bytes,16,opt,name=delegation_params,json=delegationParams,proto3" json:"delegation_params,omitempty"`
+	// Field numbers 16 and 17 are wire-format-locked to match the upstream
+	// multi-model branch (which shipped delegation_params=16 first). Renumbering
+	// would silently lose DelegationParams from any chain that already stored
+	// params under field 16.
+	DelegationParams  *DelegationParams  `protobuf:"bytes,16,opt,name=delegation_params,json=delegationParams,proto3" json:"delegation_params,omitempty"`
+	MaintenanceParams *MaintenanceParams `protobuf:"bytes,17,opt,name=maintenance_params,json=maintenanceParams,proto3" json:"maintenance_params,omitempty"`
 }
 
 func (m *Params) Reset()         { *m = Params{} }
@@ -190,6 +195,113 @@ func (m *Params) GetDelegationParams() *DelegationParams {
 	return nil
 }
 
+func (m *Params) GetMaintenanceParams() *MaintenanceParams {
+	if m != nil {
+		return m.MaintenanceParams
+	}
+	return nil
+}
+
+// MaintenanceParams defines the governance-controlled parameters for participant maintenance windows.
+type MaintenanceParams struct {
+	// maintenance_enabled enables or disables scheduling and activation of maintenance windows.
+	MaintenanceEnabled bool `protobuf:"varint,1,opt,name=maintenance_enabled,json=maintenanceEnabled,proto3" json:"maintenance_enabled,omitempty"`
+	// maintenance_min_schedule_lead_blocks is the minimum number of blocks between scheduling and start.
+	MaintenanceMinScheduleLeadBlocks uint64 `protobuf:"varint,2,opt,name=maintenance_min_schedule_lead_blocks,json=maintenanceMinScheduleLeadBlocks,proto3" json:"maintenance_min_schedule_lead_blocks,omitempty"`
+	// maintenance_max_window_blocks is the maximum duration of a single maintenance window.
+	MaintenanceMaxWindowBlocks uint64 `protobuf:"varint,3,opt,name=maintenance_max_window_blocks,json=maintenanceMaxWindowBlocks,proto3" json:"maintenance_max_window_blocks,omitempty"`
+	// maintenance_max_concurrent_validators is the maximum number of participants concurrently in maintenance.
+	MaintenanceMaxConcurrentValidators uint32 `protobuf:"varint,4,opt,name=maintenance_max_concurrent_validators,json=maintenanceMaxConcurrentValidators,proto3" json:"maintenance_max_concurrent_validators,omitempty"`
+	// maintenance_max_concurrent_power_bps is the maximum consensus power concurrently in maintenance (basis points).
+	MaintenanceMaxConcurrentPowerBps uint32 `protobuf:"varint,5,opt,name=maintenance_max_concurrent_power_bps,json=maintenanceMaxConcurrentPowerBps,proto3" json:"maintenance_max_concurrent_power_bps,omitempty"`
+	// maintenance_credit_cap_blocks is the maximum maintenance credit a participant may accumulate.
+	MaintenanceCreditCapBlocks uint64 `protobuf:"varint,6,opt,name=maintenance_credit_cap_blocks,json=maintenanceCreditCapBlocks,proto3" json:"maintenance_credit_cap_blocks,omitempty"`
+	// maintenance_credit_earn_per_successful_epoch_blocks is the number of credit blocks earned per successful epoch.
+	MaintenanceCreditEarnPerSuccessfulEpochBlocks uint64 `protobuf:"varint,7,opt,name=maintenance_credit_earn_per_successful_epoch_blocks,json=maintenanceCreditEarnPerSuccessfulEpochBlocks,proto3" json:"maintenance_credit_earn_per_successful_epoch_blocks,omitempty"`
+}
+
+func (m *MaintenanceParams) Reset()         { *m = MaintenanceParams{} }
+func (m *MaintenanceParams) String() string { return proto.CompactTextString(m) }
+func (*MaintenanceParams) ProtoMessage()    {}
+func (*MaintenanceParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_3cf34332021bbe94, []int{1}
+}
+func (m *MaintenanceParams) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MaintenanceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MaintenanceParams.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 *MaintenanceParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaintenanceParams.Merge(m, src)
+}
+func (m *MaintenanceParams) XXX_Size() int {
+	return m.Size()
+}
+func (m *MaintenanceParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_MaintenanceParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MaintenanceParams proto.InternalMessageInfo
+
+func (m *MaintenanceParams) GetMaintenanceEnabled() bool {
+	if m != nil {
+		return m.MaintenanceEnabled
+	}
+	return false
+}
+
+func (m *MaintenanceParams) GetMaintenanceMinScheduleLeadBlocks() uint64 {
+	if m != nil {
+		return m.MaintenanceMinScheduleLeadBlocks
+	}
+	return 0
+}
+
+func (m *MaintenanceParams) GetMaintenanceMaxWindowBlocks() uint64 {
+	if m != nil {
+		return m.MaintenanceMaxWindowBlocks
+	}
+	return 0
+}
+
+func (m *MaintenanceParams) GetMaintenanceMaxConcurrentValidators() uint32 {
+	if m != nil {
+		return m.MaintenanceMaxConcurrentValidators
+	}
+	return 0
+}
+
+func (m *MaintenanceParams) GetMaintenanceMaxConcurrentPowerBps() uint32 {
+	if m != nil {
+		return m.MaintenanceMaxConcurrentPowerBps
+	}
+	return 0
+}
+
+func (m *MaintenanceParams) GetMaintenanceCreditCapBlocks() uint64 {
+	if m != nil {
+		return m.MaintenanceCreditCapBlocks
+	}
+	return 0
+}
+
+func (m *MaintenanceParams) GetMaintenanceCreditEarnPerSuccessfulEpochBlocks() uint64 {
+	if m != nil {
+		return m.MaintenanceCreditEarnPerSuccessfulEpochBlocks
+	}
+	return 0
+}
+
 type GenesisOnlyParams struct {
 	TotalSupply                             int64    `protobuf:"varint,1,opt,name=total_supply,json=totalSupply,proto3" json:"total_supply,omitempty"`
 	OriginatorSupply                        int64    `protobuf:"varint,2,opt,name=originator_supply,json=originatorSupply,proto3" json:"originator_supply,omitempty"`
@@ -207,7 +319,7 @@ func (m *GenesisOnlyParams) Reset()         { *m = GenesisOnlyParams{} }
 func (m *GenesisOnlyParams) String() string { return proto.CompactTextString(m) }
 func (*GenesisOnlyParams) ProtoMessage()    {}
 func (*GenesisOnlyParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{1}
+	return fileDescriptor_3cf34332021bbe94, []int{2}
 }
 func (m *GenesisOnlyParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -318,7 +430,7 @@ func (m *TokenomicsParams) Reset()         { *m = TokenomicsParams{} }
 func (m *TokenomicsParams) String() string { return proto.CompactTextString(m) }
 func (*TokenomicsParams) ProtoMessage()    {}
 func (*TokenomicsParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{2}
+	return fileDescriptor_3cf34332021bbe94, []int{3}
 }
 func (m *TokenomicsParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -404,7 +516,7 @@ func (m *EpochParams) Reset()         { *m = EpochParams{} }
 func (m *EpochParams) String() string { return proto.CompactTextString(m) }
 func (*EpochParams) ProtoMessage()    {}
 func (*EpochParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{3}
+	return fileDescriptor_3cf34332021bbe94, []int{4}
 }
 func (m *EpochParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -572,7 +684,7 @@ func (m *ValidationParams) Reset()         { *m = ValidationParams{} }
 func (m *ValidationParams) String() string { return proto.CompactTextString(m) }
 func (*ValidationParams) ProtoMessage()    {}
 func (*ValidationParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{4}
+	return fileDescriptor_3cf34332021bbe94, []int{5}
 }
 func (m *ValidationParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -802,7 +914,7 @@ func (m *PoCModelParams) Reset()         { *m = PoCModelParams{} }
 func (m *PoCModelParams) String() string { return proto.CompactTextString(m) }
 func (*PoCModelParams) ProtoMessage()    {}
 func (*PoCModelParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{5}
+	return fileDescriptor_3cf34332021bbe94, []int{6}
 }
 func (m *PoCModelParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -926,7 +1038,7 @@ func (m *PoCStatTestParams) Reset()         { *m = PoCStatTestParams{} }
 func (m *PoCStatTestParams) String() string { return proto.CompactTextString(m) }
 func (*PoCStatTestParams) ProtoMessage()    {}
 func (*PoCStatTestParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{6}
+	return fileDescriptor_3cf34332021bbe94, []int{7}
 }
 func (m *PoCStatTestParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -988,7 +1100,7 @@ func (m *PoCModelConfig) Reset()         { *m = PoCModelConfig{} }
 func (m *PoCModelConfig) String() string { return proto.CompactTextString(m) }
 func (*PoCModelConfig) ProtoMessage()    {}
 func (*PoCModelConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{7}
+	return fileDescriptor_3cf34332021bbe94, []int{8}
 }
 func (m *PoCModelConfig) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1073,7 +1185,7 @@ func (m *PocParams) Reset()         { *m = PocParams{} }
 func (m *PocParams) String() string { return proto.CompactTextString(m) }
 func (*PocParams) ProtoMessage()    {}
 func (*PocParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{8}
+	return fileDescriptor_3cf34332021bbe94, []int{9}
 }
 func (m *PocParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1214,7 +1326,7 @@ func (m *Decimal) Reset()         { *m = Decimal{} }
 func (m *Decimal) String() string { return proto.CompactTextString(m) }
 func (*Decimal) ProtoMessage()    {}
 func (*Decimal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{9}
+	return fileDescriptor_3cf34332021bbe94, []int{10}
 }
 func (m *Decimal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1276,7 +1388,7 @@ func (m *CollateralParams) Reset()         { *m = CollateralParams{} }
 func (m *CollateralParams) String() string { return proto.CompactTextString(m) }
 func (*CollateralParams) ProtoMessage()    {}
 func (*CollateralParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{10}
+	return fileDescriptor_3cf34332021bbe94, []int{11}
 }
 func (m *CollateralParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1369,7 +1481,7 @@ func (m *BitcoinRewardParams) Reset()         { *m = BitcoinRewardParams{} }
 func (m *BitcoinRewardParams) String() string { return proto.CompactTextString(m) }
 func (*BitcoinRewardParams) ProtoMessage()    {}
 func (*BitcoinRewardParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{11}
+	return fileDescriptor_3cf34332021bbe94, []int{12}
 }
 func (m *BitcoinRewardParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1471,7 +1583,7 @@ func (m *DynamicPricingParams) Reset()         { *m = DynamicPricingParams{} }
 func (m *DynamicPricingParams) String() string { return proto.CompactTextString(m) }
 func (*DynamicPricingParams) ProtoMessage()    {}
 func (*DynamicPricingParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{12}
+	return fileDescriptor_3cf34332021bbe94, []int{13}
 }
 func (m *DynamicPricingParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1581,7 +1693,7 @@ func (m *BandwidthLimitsParams) Reset()         { *m = BandwidthLimitsParams{} }
 func (m *BandwidthLimitsParams) String() string { return proto.CompactTextString(m) }
 func (*BandwidthLimitsParams) ProtoMessage()    {}
 func (*BandwidthLimitsParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{13}
+	return fileDescriptor_3cf34332021bbe94, []int{14}
 }
 func (m *BandwidthLimitsParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1682,7 +1794,7 @@ func (m *ConfirmationPoCParams) Reset()         { *m = ConfirmationPoCParams{} }
 func (m *ConfirmationPoCParams) String() string { return proto.CompactTextString(m) }
 func (*ConfirmationPoCParams) ProtoMessage()    {}
 func (*ConfirmationPoCParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{14}
+	return fileDescriptor_3cf34332021bbe94, []int{15}
 }
 func (m *ConfirmationPoCParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1752,7 +1864,7 @@ func (m *GenesisGuardianParams) Reset()         { *m = GenesisGuardianParams{} }
 func (m *GenesisGuardianParams) String() string { return proto.CompactTextString(m) }
 func (*GenesisGuardianParams) ProtoMessage()    {}
 func (*GenesisGuardianParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{15}
+	return fileDescriptor_3cf34332021bbe94, []int{16}
 }
 func (m *GenesisGuardianParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1814,7 +1926,7 @@ func (m *DeveloperAccessParams) Reset()         { *m = DeveloperAccessParams{} }
 func (m *DeveloperAccessParams) String() string { return proto.CompactTextString(m) }
 func (*DeveloperAccessParams) ProtoMessage()    {}
 func (*DeveloperAccessParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{16}
+	return fileDescriptor_3cf34332021bbe94, []int{17}
 }
 func (m *DeveloperAccessParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1885,7 +1997,7 @@ func (m *ParticipantAccessParams) Reset()         { *m = ParticipantAccessParams
 func (m *ParticipantAccessParams) String() string { return proto.CompactTextString(m) }
 func (*ParticipantAccessParams) ProtoMessage()    {}
 func (*ParticipantAccessParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{17}
+	return fileDescriptor_3cf34332021bbe94, []int{18}
 }
 func (m *ParticipantAccessParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1954,7 +2066,7 @@ func (m *TransferAgentAccessParams) Reset()         { *m = TransferAgentAccessPa
 func (m *TransferAgentAccessParams) String() string { return proto.CompactTextString(m) }
 func (*TransferAgentAccessParams) ProtoMessage()    {}
 func (*TransferAgentAccessParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{18}
+	return fileDescriptor_3cf34332021bbe94, []int{19}
 }
 func (m *TransferAgentAccessParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2011,7 +2123,7 @@ func (m *DelegationParams) Reset()         { *m = DelegationParams{} }
 func (m *DelegationParams) String() string { return proto.CompactTextString(m) }
 func (*DelegationParams) ProtoMessage()    {}
 func (*DelegationParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{19}
+	return fileDescriptor_3cf34332021bbe94, []int{20}
 }
 func (m *DelegationParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2117,7 +2229,7 @@ func (m *DevshardApprovedVersion) Reset()         { *m = DevshardApprovedVersion
 func (m *DevshardApprovedVersion) String() string { return proto.CompactTextString(m) }
 func (*DevshardApprovedVersion) ProtoMessage()    {}
 func (*DevshardApprovedVersion) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{20}
+	return fileDescriptor_3cf34332021bbe94, []int{21}
 }
 func (m *DevshardApprovedVersion) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2193,7 +2305,7 @@ func (m *DevshardEscrowParams) Reset()         { *m = DevshardEscrowParams{} }
 func (m *DevshardEscrowParams) String() string { return proto.CompactTextString(m) }
 func (*DevshardEscrowParams) ProtoMessage()    {}
 func (*DevshardEscrowParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{21}
+	return fileDescriptor_3cf34332021bbe94, []int{22}
 }
 func (m *DevshardEscrowParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2363,7 +2475,7 @@ func (m *FeeParams) Reset()         { *m = FeeParams{} }
 func (m *FeeParams) String() string { return proto.CompactTextString(m) }
 func (*FeeParams) ProtoMessage()    {}
 func (*FeeParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_3cf34332021bbe94, []int{22}
+	return fileDescriptor_3cf34332021bbe94, []int{23}
 }
 func (m *FeeParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2415,6 +2527,7 @@ func (m *FeeParams) GetGasPerPocCount() uint64 {
 
 func init() {
 	proto.RegisterType((*Params)(nil), "inference.inference.Params")
+	proto.RegisterType((*MaintenanceParams)(nil), "inference.inference.MaintenanceParams")
 	proto.RegisterType((*GenesisOnlyParams)(nil), "inference.inference.GenesisOnlyParams")
 	proto.RegisterType((*TokenomicsParams)(nil), "inference.inference.TokenomicsParams")
 	proto.RegisterType((*EpochParams)(nil), "inference.inference.EpochParams")
@@ -2442,277 +2555,290 @@ func init() {
 func init() { proto.RegisterFile("inference/inference/params.proto", fileDescriptor_3cf34332021bbe94) }
 
 var fileDescriptor_3cf34332021bbe94 = []byte{
-	// 4320 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x5b, 0x5f, 0x6f, 0x1c, 0x47,
-	0x72, 0x3f, 0x6a, 0x97, 0xe4, 0x6e, 0xf1, 0xdf, 0xee, 0xf0, 0x3f, 0x29, 0xd1, 0x92, 0x6c, 0x9f,
-	0xed, 0xb3, 0x4f, 0xf2, 0xe9, 0xee, 0xec, 0xc0, 0x3e, 0x1b, 0x47, 0x51, 0xd4, 0x3f, 0x4b, 0xf2,
-	0x62, 0x28, 0xf3, 0x62, 0xc3, 0xc8, 0xa0, 0x77, 0xa6, 0x77, 0xd9, 0xd0, 0x4c, 0xf7, 0x78, 0xba,
-	0x67, 0x49, 0xfa, 0x23, 0x24, 0x08, 0x90, 0x2f, 0x10, 0x20, 0x40, 0x1e, 0x82, 0xbc, 0x04, 0xf7,
-	0x90, 0xef, 0x90, 0xcb, 0xdb, 0xe5, 0xed, 0x1e, 0x03, 0x1b, 0x41, 0xf2, 0x92, 0x87, 0x20, 0x5f,
-	0x20, 0xe8, 0xea, 0xee, 0x99, 0xd9, 0xe5, 0x92, 0x1e, 0xe7, 0x45, 0xe0, 0x56, 0xd5, 0xaf, 0xaa,
-	0xa7, 0xbb, 0xba, 0xba, 0xaa, 0xba, 0x05, 0x37, 0x19, 0x1f, 0xd0, 0x8c, 0xf2, 0x90, 0xde, 0x2d,
-	0xff, 0x4a, 0x49, 0x46, 0x12, 0x79, 0x27, 0xcd, 0x84, 0x12, 0xde, 0x6a, 0x41, 0xbf, 0x53, 0xfc,
-	0xb5, 0xd3, 0x25, 0x09, 0xe3, 0xe2, 0x2e, 0xfe, 0x6b, 0xe4, 0x76, 0xd6, 0x86, 0x62, 0x28, 0xf0,
-	0xcf, 0xbb, 0xfa, 0x2f, 0x4b, 0xdd, 0x0e, 0x85, 0x4c, 0x84, 0x0c, 0x0c, 0xc3, 0xfc, 0x30, 0xac,
-	0xdb, 0xdf, 0x2f, 0xc0, 0x5c, 0x0f, 0x2d, 0x79, 0x07, 0xb0, 0x48, 0x53, 0x11, 0x9e, 0x04, 0xc6,
-	0xf2, 0xd6, 0xcc, 0xcd, 0x99, 0xb7, 0x17, 0xee, 0xdd, 0xbc, 0x33, 0xc5, 0xf4, 0x9d, 0x43, 0x2d,
-	0x68, 0x70, 0xfe, 0x02, 0x2d, 0x7f, 0x78, 0x3e, 0x74, 0x47, 0x24, 0x66, 0x11, 0x51, 0x4c, 0x70,
-	0xa7, 0xe9, 0x1a, 0x6a, 0x7a, 0x73, 0xaa, 0xa6, 0xe3, 0x42, 0xda, 0xaa, 0xeb, 0x8c, 0x26, 0x28,
-	0xde, 0x27, 0x00, 0xa9, 0x08, 0x9d, 0xb2, 0x06, 0x2a, 0xdb, 0x9b, 0xaa, 0xac, 0x27, 0x42, 0xab,
-	0xa5, 0x9d, 0xba, 0x3f, 0xf5, 0x90, 0x94, 0x78, 0x45, 0xb9, 0x48, 0x58, 0x28, 0x9d, 0x96, 0xe6,
-	0x15, 0x43, 0x7a, 0x59, 0x48, 0xbb, 0x21, 0xa9, 0x09, 0x8a, 0xd6, 0x19, 0x8a, 0x38, 0x26, 0x8a,
-	0x66, 0x24, 0x76, 0x3a, 0x67, 0xaf, 0xd0, 0x79, 0x50, 0x48, 0x3b, 0x9d, 0xe1, 0x04, 0xc5, 0xfb,
-	0x1a, 0xd6, 0xfb, 0x4c, 0x85, 0x82, 0xf1, 0x20, 0xa3, 0xa7, 0x24, 0x8b, 0x9c, 0xde, 0x39, 0xd4,
-	0xfb, 0xf6, 0x54, 0xbd, 0xf7, 0x0d, 0xc2, 0x47, 0x80, 0x55, 0xbd, 0xda, 0xbf, 0x48, 0xf4, 0x02,
-	0xd8, 0x88, 0xce, 0x39, 0x49, 0x58, 0x18, 0xa4, 0x19, 0x0b, 0x19, 0x1f, 0x3a, 0xf5, 0xf3, 0xa8,
-	0xfe, 0x9d, 0xa9, 0xea, 0x1f, 0x18, 0x48, 0xcf, 0x20, 0xac, 0xfe, 0xb5, 0x68, 0x0a, 0xd5, 0xeb,
-	0xc3, 0x66, 0x9f, 0xf0, 0xe8, 0x94, 0x45, 0xea, 0x24, 0x88, 0x59, 0xc2, 0x54, 0x31, 0xd9, 0x2d,
-	0xb4, 0xf0, 0xb3, 0xe9, 0x1f, 0xe0, 0x30, 0xcf, 0x10, 0x62, 0x4d, 0xac, 0xf7, 0xa7, 0x91, 0xb5,
-	0x8d, 0x50, 0xf0, 0x01, 0xcb, 0x12, 0xeb, 0x5f, 0xa5, 0x5b, 0xb4, 0xaf, 0xb0, 0x71, 0x50, 0xc1,
-	0xf4, 0xc4, 0x81, 0xb3, 0x11, 0x8e, 0x91, 0xc3, 0xd2, 0xc6, 0x90, 0x72, 0x2a, 0x99, 0x0c, 0x86,
-	0x39, 0xc9, 0x22, 0x46, 0x0a, 0x3f, 0x86, 0x2b, 0x6c, 0x3c, 0x32, 0x98, 0x47, 0x16, 0xe2, 0x6c,
-	0x0c, 0xa7, 0x91, 0xb5, 0x8d, 0x88, 0x8e, 0x68, 0x2c, 0x52, 0x9a, 0x05, 0x24, 0x0c, 0xa9, 0x2c,
-	0xe6, 0x6a, 0xe1, 0x0a, 0x1b, 0x0f, 0x1c, 0x66, 0x1f, 0x21, 0xce, 0x46, 0x34, 0x8d, 0xec, 0x9d,
-	0xc0, 0x76, 0x4a, 0x32, 0xc5, 0x42, 0x96, 0x12, 0xae, 0x26, 0xac, 0x2c, 0xa2, 0x95, 0xf7, 0xa6,
-	0x6f, 0xa2, 0x12, 0x35, 0x66, 0x67, 0x33, 0x9d, 0xce, 0xf0, 0x04, 0x5c, 0x57, 0x19, 0xe1, 0x72,
-	0xa0, 0x3f, 0x66, 0x48, 0x2f, 0x18, 0x5b, 0x42, 0x63, 0x77, 0xa6, 0xef, 0x35, 0x0b, 0xdc, 0xd7,
-	0xb8, 0x31, 0x73, 0xdb, 0xea, 0x32, 0x16, 0xfa, 0x32, 0x1d, 0xc9, 0x13, 0xbd, 0x47, 0xa8, 0x0c,
-	0x33, 0x71, 0xea, 0x4c, 0x2d, 0x5f, 0xe5, 0xcb, 0x16, 0x72, 0x88, 0x88, 0xc2, 0x97, 0xa7, 0x50,
-	0x75, 0xc4, 0x19, 0x50, 0xea, 0x94, 0xae, 0x5c, 0x11, 0x71, 0x1e, 0x52, 0xea, 0x22, 0xce, 0xc0,
-	0xfd, 0xa9, 0xa3, 0x43, 0x44, 0x63, 0x3a, 0x1c, 0x0b, 0x82, 0x9d, 0x2b, 0xa2, 0xc3, 0x83, 0x42,
-	0xda, 0x45, 0x87, 0x68, 0x82, 0xf2, 0xd1, 0x9b, 0xff, 0xf5, 0x77, 0xaf, 0xcd, 0xfc, 0xe5, 0x7f,
-	0xfe, 0xfe, 0x67, 0xd7, 0xcb, 0x23, 0xe2, 0xac, 0x72, 0x5c, 0xb8, 0xef, 0x91, 0x79, 0x9f, 0x53,
-	0x35, 0x3e, 0x2d, 0xb7, 0xff, 0x79, 0x0e, 0xba, 0xd6, 0x41, 0x3f, 0xe7, 0xf1, 0xb9, 0x1d, 0xe6,
-	0x2d, 0x58, 0x54, 0x42, 0x91, 0x38, 0x90, 0x79, 0x9a, 0xc6, 0xe7, 0x18, 0xf0, 0x1b, 0xfe, 0x02,
-	0xd2, 0x8e, 0x90, 0xe4, 0xbd, 0x0b, 0x5d, 0x91, 0xb1, 0x21, 0xe3, 0x44, 0x89, 0xcc, 0xc9, 0x5d,
-	0x43, 0xb9, 0x4e, 0xc9, 0xb0, 0xc2, 0xbf, 0x82, 0x0d, 0xa9, 0x08, 0x8f, 0xf4, 0xb2, 0xd8, 0x08,
-	0x46, 0x12, 0x91, 0x73, 0x85, 0xd1, 0xb6, 0xe1, 0xaf, 0x39, 0xae, 0x09, 0x4c, 0xfb, 0xc8, 0xf3,
-	0x3e, 0x86, 0x9d, 0x34, 0xa3, 0xfa, 0x6c, 0x1a, 0x66, 0x24, 0x49, 0x68, 0x14, 0x48, 0x12, 0x53,
-	0x87, 0x9c, 0x45, 0xe4, 0x66, 0x9a, 0xd1, 0x5e, 0x21, 0x70, 0x44, 0x62, 0x6a, 0xc1, 0xb7, 0x60,
-	0xd1, 0x0c, 0x2a, 0x88, 0x74, 0x80, 0xc6, 0x58, 0xd6, 0xf6, 0x17, 0x0c, 0xed, 0x81, 0x26, 0x79,
-	0x21, 0xbc, 0x96, 0x90, 0xb3, 0x80, 0xf1, 0x88, 0x8d, 0x58, 0x94, 0xeb, 0x70, 0x2d, 0x4e, 0x69,
-	0x16, 0xa4, 0x34, 0x0b, 0x29, 0x57, 0x64, 0x48, 0xed, 0x6e, 0xb8, 0x7e, 0xc9, 0xd2, 0x84, 0x2c,
-	0x21, 0xb1, 0x7f, 0x3d, 0x21, 0x67, 0x4f, 0x0a, 0x1d, 0x3d, 0xad, 0xa2, 0x57, 0x68, 0xf0, 0xfe,
-	0x0c, 0xb6, 0x2e, 0x04, 0x0d, 0xca, 0x49, 0x3f, 0xa6, 0x11, 0xba, 0x7f, 0xcb, 0xdf, 0x98, 0x88,
-	0x04, 0x87, 0x86, 0xeb, 0x7d, 0x0d, 0xef, 0x5e, 0x40, 0x72, 0xaa, 0x4e, 0x45, 0xf6, 0x2a, 0x48,
-	0x88, 0xca, 0x33, 0xa6, 0xce, 0x03, 0x75, 0x92, 0x51, 0x79, 0x22, 0xe2, 0x08, 0x1d, 0xbc, 0xe1,
-	0xbf, 0x35, 0xa1, 0xec, 0x85, 0x01, 0x3c, 0xb7, 0xf2, 0x2f, 0x9d, 0xb8, 0xf7, 0x35, 0xec, 0x5e,
-	0xd0, 0x9e, 0xe4, 0xb1, 0x62, 0x69, 0xcc, 0x68, 0x66, 0x3d, 0xfb, 0xea, 0x0f, 0xdf, 0x9e, 0xb0,
-	0xf5, 0xbc, 0x80, 0x7b, 0xbf, 0x81, 0x9d, 0x0b, 0xda, 0x49, 0x14, 0x65, 0x54, 0x4a, 0xaa, 0x1d,
-	0xbe, 0xf1, 0x76, 0xdb, 0xdf, 0x9a, 0x80, 0xef, 0x3b, 0xfe, 0xd3, 0x66, 0xab, 0xd1, 0x69, 0x3e,
-	0x6d, 0xb6, 0xe6, 0x3a, 0xf3, 0x4f, 0x9b, 0xad, 0x56, 0xa7, 0xfd, 0xb4, 0xd9, 0x6a, 0x77, 0xe0,
-	0x69, 0xb3, 0x05, 0x9d, 0x85, 0xa7, 0xcd, 0xd6, 0x42, 0x67, 0xd1, 0xef, 0x2a, 0x91, 0x8e, 0xfb,
-	0x92, 0xf6, 0x4f, 0x47, 0x92, 0x63, 0xfc, 0x94, 0x66, 0x4c, 0x44, 0xbe, 0x57, 0x25, 0x91, 0x73,
-	0x91, 0x2b, 0xe9, 0x5f, 0xbf, 0x48, 0xd3, 0xe2, 0x41, 0xc2, 0x38, 0xcd, 0xfc, 0xcd, 0x0a, 0x57,
-	0xbb, 0x4a, 0x94, 0x67, 0xb8, 0xf3, 0x6e, 0xff, 0x4f, 0x03, 0x3a, 0x93, 0xc9, 0x80, 0xf7, 0x15,
-	0xec, 0xc8, 0xbc, 0x2f, 0x59, 0x74, 0x1e, 0x64, 0x34, 0xca, 0x43, 0xdc, 0xe3, 0x8c, 0x2b, 0x9a,
-	0x8d, 0x48, 0x6c, 0x93, 0xa6, 0xab, 0x67, 0x74, 0xcb, 0xe2, 0x7d, 0x07, 0x7f, 0x62, 0xd1, 0xde,
-	0x31, 0x6c, 0x5d, 0xd4, 0x6d, 0x77, 0xc2, 0xb5, 0x1a, 0x9a, 0x37, 0x26, 0x35, 0xdb, 0x6d, 0xf2,
-	0x15, 0xec, 0x84, 0x79, 0x96, 0xe9, 0xd0, 0xec, 0xf4, 0x57, 0xdc, 0xbf, 0x51, 0x67, 0xcc, 0x16,
-	0x7f, 0x64, 0xe0, 0x15, 0xd7, 0xbf, 0x03, 0xab, 0xe8, 0xac, 0x23, 0x2a, 0x15, 0x66, 0x15, 0xb8,
-	0x0c, 0x98, 0xb4, 0x34, 0xfd, 0xae, 0x66, 0x1d, 0x1b, 0x4e, 0x0f, 0x19, 0xde, 0x3d, 0x58, 0xb7,
-	0x73, 0x3d, 0x81, 0x98, 0x47, 0xc4, 0xaa, 0x61, 0x8e, 0x61, 0x3e, 0x6a, 0xea, 0xe0, 0xf7, 0xb4,
-	0xd9, 0x6a, 0x76, 0x66, 0x9f, 0x36, 0x5b, 0xb3, 0x9d, 0x39, 0xe3, 0x30, 0xfe, 0x4e, 0xd5, 0x3d,
-	0xe2, 0x58, 0x9c, 0xd2, 0x28, 0x18, 0x10, 0x16, 0xe7, 0x19, 0xf5, 0x77, 0x35, 0x0f, 0x17, 0x18,
-	0xd3, 0x84, 0x6f, 0x72, 0x12, 0xb3, 0x01, 0x0b, 0x71, 0x65, 0xfd, 0xad, 0x92, 0x39, 0x3e, 0x8a,
-	0xdb, 0xff, 0x32, 0x07, 0x0b, 0x95, 0xec, 0x56, 0x47, 0x18, 0x93, 0x15, 0xc7, 0x94, 0x0f, 0xd5,
-	0x89, 0x0b, 0x92, 0x48, 0x7b, 0x86, 0x24, 0xef, 0x1d, 0xe8, 0x18, 0x91, 0xca, 0xce, 0x32, 0x31,
-	0x72, 0x05, 0xe9, 0x95, 0x1d, 0xf3, 0x1a, 0x18, 0x64, 0x20, 0x4f, 0xd8, 0x40, 0xe1, 0xcc, 0x37,
-	0x7c, 0x40, 0xd2, 0x91, 0xa6, 0x78, 0xbf, 0x85, 0x1b, 0x11, 0x1d, 0x90, 0x3c, 0x56, 0x41, 0xce,
-	0x99, 0x0a, 0xc4, 0x20, 0x08, 0x45, 0x92, 0xe6, 0x8a, 0x62, 0xda, 0x46, 0x6d, 0x28, 0xdd, 0xb6,
-	0x42, 0x5f, 0x70, 0xa6, 0x3e, 0x1f, 0x1c, 0x18, 0x09, 0x9d, 0x8f, 0x51, 0xef, 0x3d, 0xf0, 0xf4,
-	0xf7, 0x4a, 0xbd, 0x38, 0x85, 0x2b, 0xdb, 0x38, 0xda, 0x49, 0x45, 0x78, 0xa4, 0x19, 0x0f, 0x2c,
-	0xdd, 0xfb, 0x00, 0xd6, 0xb5, 0x34, 0x3d, 0x0b, 0x4f, 0x08, 0xaf, 0x02, 0xf4, 0xfa, 0x35, 0xee,
-	0x5f, 0xdb, 0x9a, 0xf1, 0x57, 0x53, 0x11, 0x1e, 0x5a, 0x7e, 0x81, 0x7b, 0x1f, 0xd6, 0x34, 0xae,
-	0x92, 0xeb, 0x47, 0x34, 0x26, 0xe7, 0xb8, 0x88, 0x0d, 0x5f, 0x8f, 0xa0, 0x4c, 0xec, 0x1f, 0x68,
-	0x8e, 0xf7, 0x01, 0x6c, 0x4e, 0x22, 0x9c, 0xad, 0x16, 0x82, 0xd6, 0xc7, 0x41, 0xce, 0xd2, 0x87,
-	0xb0, 0x25, 0xa9, 0x0a, 0x38, 0x3d, 0x75, 0x58, 0x91, 0x49, 0x6b, 0xad, 0x6d, 0x80, 0x92, 0xaa,
-	0x17, 0xf4, 0xf4, 0xb8, 0xe0, 0x1a, 0x83, 0x9f, 0xc2, 0x6e, 0xe1, 0xc7, 0x55, 0xb3, 0x61, 0xae,
-	0xc4, 0x60, 0x80, 0xc9, 0x5c, 0xc3, 0xdf, 0x2e, 0x44, 0x4a, 0xd3, 0x07, 0x28, 0xe0, 0x3d, 0x81,
-	0x5b, 0x25, 0x3e, 0xcd, 0x72, 0xae, 0xbd, 0xc4, 0xac, 0x5e, 0x19, 0x8f, 0x17, 0xd0, 0x69, 0xf7,
-	0x0a, 0xc1, 0x9e, 0x91, 0x43, 0x0f, 0x2a, 0xc3, 0xf0, 0x3d, 0x58, 0xbf, 0xa8, 0x2a, 0x21, 0x67,
-	0x78, 0xf2, 0x34, 0xfc, 0xd5, 0x49, 0xf8, 0x73, 0x72, 0xe6, 0xfd, 0x14, 0x56, 0x30, 0xbd, 0xad,
-	0x48, 0x2f, 0xa1, 0xf4, 0x92, 0x2e, 0x6d, 0x4a, 0xb9, 0x67, 0xb0, 0x8a, 0xeb, 0x1d, 0x0b, 0x85,
-	0x7b, 0xc0, 0x78, 0xb8, 0xcd, 0x84, 0xae, 0xde, 0xd4, 0x5d, 0xed, 0x0e, 0xb1, 0x50, 0xfb, 0x05,
-	0xcc, 0x3b, 0x80, 0xbd, 0x0b, 0x19, 0xb6, 0x24, 0x03, 0xaa, 0xce, 0x83, 0x53, 0xc6, 0x23, 0x71,
-	0x8a, 0x67, 0x46, 0xc3, 0xdf, 0x9d, 0x48, 0x9e, 0x8f, 0x50, 0xe6, 0x77, 0x28, 0x62, 0xb6, 0xeb,
-	0xed, 0xff, 0x5e, 0x86, 0xce, 0x64, 0x75, 0xa7, 0x47, 0x3b, 0x20, 0xb1, 0xa4, 0x41, 0x2a, 0x24,
-	0x53, 0x6c, 0x44, 0x83, 0x8c, 0x28, 0x5a, 0x2b, 0x6c, 0x76, 0x11, 0xd8, 0xb3, 0x38, 0x9f, 0x28,
-	0xaa, 0x7d, 0x23, 0xd1, 0xe5, 0x12, 0x49, 0xd2, 0x20, 0x4f, 0x83, 0x84, 0x12, 0x99, 0x67, 0x34,
-	0xa1, 0x5c, 0x99, 0xa2, 0x73, 0xd6, 0x5f, 0x4f, 0x18, 0xf7, 0x49, 0x92, 0x7e, 0x91, 0x3e, 0xaf,
-	0x30, 0xbd, 0x8f, 0x01, 0x52, 0x22, 0xa5, 0x76, 0x8b, 0xbc, 0x5e, 0x00, 0x6c, 0x6b, 0xf9, 0x63,
-	0x2d, 0xee, 0xf9, 0xb0, 0xa1, 0xad, 0x56, 0x5c, 0x8a, 0x8c, 0x68, 0xa6, 0x23, 0x69, 0xb3, 0x86,
-	0xa2, 0xb5, 0x84, 0xf1, 0x72, 0x5a, 0xf6, 0x0d, 0x12, 0x75, 0x92, 0xb3, 0x69, 0x3a, 0x67, 0x6b,
-	0xe9, 0x24, 0x67, 0x17, 0x75, 0xbe, 0x0b, 0x5d, 0x7a, 0x96, 0x32, 0xb3, 0x8f, 0x82, 0x7e, 0x2c,
-	0xc2, 0x57, 0xa6, 0x98, 0x6c, 0xf8, 0x9d, 0x92, 0x71, 0x1f, 0xe9, 0xde, 0x6d, 0x58, 0x42, 0xdf,
-	0x96, 0x81, 0x12, 0xe8, 0x6c, 0xf3, 0x95, 0x40, 0x27, 0x5f, 0x0a, 0xed, 0x6a, 0x07, 0xb0, 0x37,
-	0xc8, 0xe3, 0xb8, 0x3a, 0x4a, 0x95, 0x91, 0xc1, 0x80, 0x85, 0x6e, 0x53, 0x99, 0x9d, 0xbc, 0xab,
-	0xa5, 0xca, 0xf1, 0xbc, 0x34, 0x32, 0x76, 0x5b, 0x5d, 0x9c, 0xbd, 0x13, 0x12, 0x0f, 0x4e, 0xed,
-	0x6e, 0xfe, 0x71, 0xb3, 0xf7, 0xd8, 0x20, 0xbd, 0x7d, 0xb8, 0x31, 0xa1, 0x73, 0x62, 0x5c, 0x66,
-	0xb3, 0xef, 0x8c, 0x81, 0xa7, 0x0c, 0x4b, 0xca, 0xca, 0xb9, 0xe8, 0xb0, 0x0b, 0xf5, 0x86, 0x25,
-	0x65, 0x79, 0x28, 0x5a, 0x9d, 0x3d, 0x58, 0x47, 0x9d, 0x19, 0xfd, 0x26, 0xa7, 0x12, 0x73, 0x0e,
-	0x4e, 0x62, 0x75, 0x5e, 0x2b, 0xe1, 0x5c, 0xd5, 0x50, 0xdf, 0x22, 0x7b, 0x06, 0xe8, 0xfd, 0x02,
-	0xd6, 0x14, 0x4b, 0xa8, 0x54, 0xda, 0xe3, 0xcb, 0x35, 0xb4, 0x91, 0x61, 0xb5, 0xe0, 0x1d, 0x16,
-	0x2c, 0xed, 0x05, 0x25, 0x84, 0x44, 0x23, 0xc2, 0x43, 0x6a, 0xd3, 0xc8, 0x4e, 0xc1, 0xd8, 0x37,
-	0x74, 0x7d, 0xfc, 0xe8, 0xe3, 0x30, 0x21, 0x8a, 0x46, 0x45, 0x11, 0x4f, 0x33, 0xe3, 0x3c, 0xc1,
-	0xab, 0x3e, 0xee, 0xfe, 0xa6, 0xbf, 0x5d, 0x08, 0xd9, 0xf2, 0x9c, 0x66, 0xe8, 0x46, 0x9f, 0xf5,
-	0x75, 0xc6, 0xc9, 0x38, 0x2e, 0x44, 0x90, 0xd1, 0x34, 0x57, 0x36, 0x8c, 0x64, 0x54, 0xd2, 0x6c,
-	0x44, 0x6d, 0x15, 0xf4, 0x03, 0x19, 0xa7, 0x55, 0xe0, 0x17, 0xf8, 0x9e, 0x85, 0x7b, 0x43, 0xb8,
-	0xd5, 0x27, 0xd8, 0x18, 0x29, 0x0a, 0x5b, 0x2b, 0x6c, 0xec, 0x60, 0x30, 0xe9, 0xd6, 0xb0, 0xb1,
-	0xd7, 0x27, 0x51, 0xa5, 0xd0, 0x7d, 0x52, 0x51, 0x82, 0x91, 0xe5, 0x18, 0xb6, 0xc6, 0x14, 0x57,
-	0x63, 0xbe, 0x57, 0x27, 0x13, 0xab, 0xa2, 0x1f, 0x97, 0x27, 0xc1, 0x31, 0x6c, 0x45, 0xe2, 0x94,
-	0xeb, 0x89, 0x0f, 0x86, 0x42, 0x44, 0xd5, 0x3c, 0x6c, 0xb5, 0x8e, 0x5e, 0x87, 0x7e, 0x24, 0x44,
-	0x54, 0xc9, 0xc2, 0x5e, 0xc2, 0x66, 0xa1, 0x17, 0x67, 0xa8, 0x54, 0xbb, 0x56, 0x43, 0xed, 0xba,
-	0x03, 0xdf, 0x27, 0x55, 0xad, 0x2f, 0x60, 0xad, 0xd0, 0x5a, 0x9d, 0x81, 0xf5, 0x1a, 0x2a, 0x3d,
-	0x87, 0xac, 0x7c, 0xfd, 0x5f, 0xc0, 0xf5, 0x42, 0xdf, 0x34, 0xef, 0xd8, 0xa8, 0xa1, 0x77, 0xc7,
-	0x69, 0x98, 0xe2, 0x1e, 0x2f, 0x61, 0xf3, 0x9b, 0x9c, 0x85, 0xaf, 0x5c, 0x12, 0x58, 0x19, 0xf2,
-	0x66, 0x9d, 0x59, 0x40, 0xf0, 0x43, 0x83, 0x2d, 0x47, 0xfd, 0x5b, 0x58, 0xea, 0x33, 0x2e, 0x92,
-	0x40, 0x51, 0xa9, 0x82, 0xf4, 0xfd, 0xad, 0xad, 0x1a, 0xba, 0x16, 0x10, 0xf2, 0x92, 0x4a, 0xd5,
-	0x7b, 0x5f, 0x97, 0x87, 0x61, 0x4c, 0x58, 0x52, 0x8d, 0x50, 0xae, 0x3c, 0xdc, 0x36, 0xe5, 0x21,
-	0xf2, 0xcb, 0xe0, 0xe4, 0xca, 0xc3, 0xd7, 0x61, 0x29, 0x16, 0xc3, 0x34, 0x13, 0x7d, 0x19, 0x24,
-	0x22, 0xa2, 0x5b, 0x3b, 0x58, 0xe1, 0x2e, 0x3a, 0xe2, 0x73, 0x11, 0x51, 0x7b, 0xde, 0xfe, 0xa9,
-	0x01, 0xcb, 0x3d, 0x71, 0xa0, 0x29, 0xae, 0xa5, 0xd8, 0x81, 0x46, 0xc4, 0x12, 0x3c, 0x5d, 0x67,
-	0x7d, 0xfd, 0xa7, 0xb7, 0x0d, 0x2d, 0x1e, 0xc4, 0xe4, 0x9c, 0x66, 0xee, 0x84, 0x9c, 0xe7, 0xcf,
-	0xf0, 0xa7, 0xb7, 0x09, 0xf3, 0x3c, 0x38, 0xa1, 0x24, 0x32, 0x3d, 0xd6, 0x59, 0x7f, 0x8e, 0x3f,
-	0xd6, 0xbf, 0xbc, 0xeb, 0x00, 0x3c, 0x78, 0x35, 0xb2, 0xbc, 0x26, 0xf2, 0x5a, 0xfc, 0xb3, 0x91,
-	0xe1, 0xde, 0x00, 0x18, 0x89, 0x90, 0xf4, 0x03, 0xc9, 0xbe, 0x35, 0xa7, 0xd5, 0xac, 0xdf, 0x46,
-	0xca, 0x11, 0xfb, 0x96, 0x7a, 0x4f, 0xc1, 0x1b, 0x0c, 0x78, 0x10, 0xb1, 0xa4, 0x9a, 0x1e, 0xcf,
-	0xd5, 0x98, 0xc1, 0xce, 0x60, 0xc0, 0x1f, 0xb0, 0x64, 0x3c, 0x7b, 0xb6, 0x3a, 0x68, 0x20, 0x06,
-	0x78, 0x42, 0xcd, 0xfa, 0xe0, 0x48, 0x9f, 0x0f, 0xbc, 0x0f, 0xa1, 0xc5, 0x45, 0x96, 0x04, 0x34,
-	0x75, 0x4d, 0xc7, 0xab, 0x4d, 0xcc, 0x6b, 0xe9, 0xc3, 0x14, 0x3f, 0x22, 0x13, 0xa9, 0xf6, 0x17,
-	0xaa, 0x08, 0x1e, 0x44, 0xb3, 0x7e, 0x5b, 0x53, 0x5e, 0x6a, 0x82, 0xce, 0xc5, 0x72, 0x49, 0x03,
-	0x19, 0x92, 0x98, 0x46, 0x81, 0xa6, 0xe3, 0x89, 0xd2, 0xf2, 0x97, 0x72, 0x49, 0x8f, 0x90, 0xea,
-	0x8b, 0x94, 0xea, 0x29, 0x94, 0xf4, 0x1b, 0x5d, 0x2a, 0xe0, 0xa9, 0x31, 0xeb, 0xcf, 0x49, 0xfa,
-	0xcd, 0x33, 0xaa, 0x93, 0xd8, 0x56, 0x16, 0x28, 0x92, 0x0d, 0xa9, 0xaa, 0x15, 0xfc, 0xe7, 0xb3,
-	0x97, 0x28, 0x6c, 0x97, 0xf6, 0x3f, 0x66, 0xa0, 0xdb, 0x13, 0x07, 0x47, 0x8a, 0x28, 0xf4, 0x28,
-	0xd7, 0xb0, 0x5f, 0x8e, 0x98, 0x54, 0x15, 0x27, 0xaf, 0x93, 0x46, 0x2d, 0x69, 0x4c, 0xe9, 0xdc,
-	0x3a, 0x13, 0x0a, 0x12, 0x26, 0x13, 0xa2, 0xc2, 0x93, 0x5a, 0x45, 0x66, 0x3b, 0x7d, 0x6e, 0xc5,
-	0xbd, 0xc7, 0xd0, 0x4d, 0x4d, 0x0e, 0x55, 0x19, 0x44, 0x9d, 0x6c, 0x6a, 0x25, 0xc5, 0x54, 0xaa,
-	0x18, 0x86, 0xfd, 0xce, 0xbf, 0xbe, 0x56, 0xba, 0x30, 0x36, 0x6d, 0x87, 0xda, 0x61, 0xb5, 0xdf,
-	0xc7, 0x01, 0x33, 0x9f, 0xd7, 0xf6, 0xe7, 0xf1, 0xf7, 0x93, 0xa8, 0x3a, 0xdb, 0xa6, 0xdc, 0x72,
-	0xb3, 0x7d, 0x00, 0x6d, 0xa9, 0x88, 0xc2, 0xfd, 0x6a, 0x87, 0xf3, 0xd3, 0x4b, 0xee, 0x0b, 0x26,
-	0xe6, 0xd4, 0x6f, 0x49, 0xfb, 0x5b, 0x67, 0xaa, 0xa7, 0x94, 0x0d, 0x4f, 0x94, 0x59, 0xf6, 0x60,
-	0x40, 0x42, 0x25, 0xb2, 0x5a, 0x29, 0x5e, 0xd7, 0x00, 0xd1, 0x31, 0x1e, 0x22, 0x4c, 0x57, 0xc9,
-	0xf6, 0xf0, 0xd7, 0x95, 0x59, 0xa6, 0x4c, 0x21, 0x81, 0xdb, 0xa5, 0xe9, 0x77, 0x2d, 0xeb, 0x48,
-	0x73, 0xb0, 0x74, 0xb0, 0xf3, 0xf1, 0xf7, 0x73, 0xd0, 0x2e, 0x3b, 0xd3, 0x3f, 0x07, 0xcf, 0xd5,
-	0x86, 0x11, 0xd3, 0xa9, 0x4b, 0xae, 0x73, 0x09, 0xb3, 0xb9, 0xbb, 0x96, 0xf3, 0xa0, 0x60, 0x78,
-	0xbf, 0x82, 0x8d, 0x4a, 0xb8, 0x91, 0x24, 0xd1, 0xdb, 0x06, 0x37, 0xa9, 0xd9, 0xf8, 0x6b, 0x25,
-	0xf7, 0x08, 0x99, 0xb8, 0x5f, 0x1f, 0xc2, 0x4d, 0x9d, 0xf3, 0x47, 0x44, 0x91, 0x4b, 0x8b, 0x9e,
-	0x06, 0x8e, 0xfa, 0x7a, 0x2a, 0xc2, 0x07, 0x44, 0x91, 0xe9, 0x25, 0x4f, 0xef, 0xff, 0x3d, 0x7d,
-	0x58, 0x74, 0x4e, 0x99, 0xc2, 0xa7, 0xb0, 0x68, 0x3c, 0x61, 0xec, 0xba, 0xe5, 0xf5, 0xcb, 0x16,
-	0xb6, 0x12, 0x07, 0x51, 0xe3, 0x42, 0x52, 0x09, 0x8c, 0x37, 0x2a, 0x5e, 0xa5, 0x63, 0x51, 0x1b,
-	0x45, 0x0a, 0xcf, 0xda, 0x2d, 0x3d, 0x6b, 0xbe, 0xa8, 0x83, 0x9d, 0x77, 0xbd, 0x01, 0xcb, 0x58,
-	0xc8, 0xde, 0x2b, 0x42, 0x78, 0x0b, 0x63, 0xc1, 0xa2, 0xae, 0x5f, 0xef, 0xb9, 0xc0, 0xfd, 0x09,
-	0xec, 0x5e, 0x28, 0xa4, 0x2a, 0x90, 0x36, 0x42, 0xb6, 0x26, 0xaa, 0xa8, 0x12, 0xfe, 0xa8, 0xea,
-	0xc2, 0xf0, 0x63, 0x5c, 0x18, 0xc7, 0x5a, 0xba, 0xf1, 0x3b, 0xd0, 0xa9, 0x7a, 0x41, 0x2c, 0x94,
-	0xb9, 0x63, 0x58, 0xf2, 0x57, 0x2a, 0xeb, 0xaf, 0xc9, 0xde, 0x47, 0xb0, 0xad, 0x47, 0xa9, 0x63,
-	0x22, 0x89, 0xd9, 0xb7, 0xe3, 0xc7, 0xd4, 0x22, 0x0e, 0x58, 0x97, 0xf0, 0x2f, 0xaa, 0x7c, 0x37,
-	0xde, 0x0f, 0x61, 0xcb, 0x74, 0x1d, 0x32, 0xc1, 0x87, 0x34, 0x0b, 0x32, 0xed, 0x36, 0x63, 0x0d,
-	0xd0, 0x75, 0xec, 0x3d, 0x18, 0xb6, 0xcf, 0x87, 0x0e, 0xf8, 0x31, 0xcc, 0xe1, 0xac, 0xcb, 0xad,
-	0xe5, 0x9b, 0x8d, 0x1f, 0x5c, 0x4f, 0x13, 0x14, 0x7c, 0x0b, 0xb1, 0xbb, 0x64, 0x1f, 0xe6, 0xad,
-	0xeb, 0x78, 0x6b, 0x30, 0x6b, 0x4a, 0x3a, 0xd3, 0xa6, 0x31, 0x3f, 0xbc, 0x1d, 0x68, 0xd1, 0xb3,
-	0x54, 0x70, 0x6a, 0xdb, 0x68, 0xb3, 0x7e, 0xf1, 0xdb, 0xaa, 0xf8, 0xab, 0x26, 0x74, 0x26, 0xaf,
-	0xe8, 0x74, 0x49, 0x20, 0x63, 0x22, 0x4f, 0x82, 0x41, 0x46, 0x5c, 0x9b, 0x0f, 0xe7, 0xac, 0x56,
-	0x9c, 0x5d, 0x43, 0xec, 0x43, 0x0b, 0xb5, 0x09, 0xa6, 0xce, 0x50, 0x26, 0x74, 0xba, 0x74, 0xa6,
-	0x56, 0xec, 0x5d, 0x1f, 0x53, 0xfa, 0xc0, 0x42, 0xbd, 0x04, 0xde, 0x28, 0xf2, 0x2a, 0x5d, 0x36,
-	0xd0, 0x6a, 0x02, 0xf8, 0x23, 0x43, 0xf3, 0x2d, 0xa7, 0xe9, 0x39, 0x2a, 0x2a, 0xb3, 0xc1, 0x72,
-	0x6f, 0xff, 0x12, 0x36, 0x86, 0x19, 0x09, 0xa9, 0xed, 0x99, 0x05, 0x94, 0x47, 0x36, 0x9e, 0x35,
-	0x4d, 0x0f, 0x0f, 0xb9, 0xa6, 0x77, 0x77, 0xc8, 0x23, 0x8c, 0x0c, 0xfa, 0xac, 0xe8, 0x13, 0x49,
-	0x03, 0x1b, 0x15, 0xb0, 0x3a, 0xa9, 0x55, 0xdc, 0xae, 0x68, 0xd8, 0xef, 0x10, 0xe5, 0x6b, 0x90,
-	0xf7, 0x25, 0xec, 0x54, 0x2f, 0x5f, 0x69, 0xe6, 0x74, 0xe6, 0x9c, 0xa9, 0x5a, 0xa9, 0xc5, 0x66,
-	0xe5, 0xf2, 0x95, 0x66, 0x46, 0xf7, 0x17, 0x9c, 0x39, 0x6f, 0xf8, 0xdf, 0x06, 0xac, 0x4e, 0xb9,
-	0x58, 0xd5, 0x41, 0x5c, 0xa7, 0x01, 0xe3, 0xb7, 0xb4, 0xe6, 0xa2, 0xbc, 0xe5, 0x77, 0x73, 0x49,
-	0xc7, 0x40, 0xd2, 0x7b, 0x1f, 0xd6, 0x18, 0x67, 0x8a, 0x91, 0xd8, 0x86, 0x50, 0x83, 0xc0, 0x95,
-	0x6e, 0xfa, 0x9e, 0xe5, 0xe1, 0xf4, 0x18, 0x88, 0x3e, 0x8d, 0x23, 0x1a, 0x92, 0x73, 0x53, 0xc8,
-	0xd4, 0xea, 0x4b, 0xa0, 0x3c, 0xd6, 0x2c, 0xaf, 0xc3, 0x92, 0x6b, 0xc7, 0x57, 0x57, 0x63, 0xd1,
-	0x12, 0xcd, 0x32, 0x1c, 0xc3, 0x56, 0xae, 0x58, 0xb1, 0xbd, 0xfb, 0x82, 0xe7, 0xd2, 0x05, 0xe7,
-	0x3a, 0xab, 0xb1, 0x51, 0x41, 0xdf, 0xd7, 0x60, 0x1b, 0x9d, 0xbf, 0x84, 0x1d, 0xec, 0x0d, 0x84,
-	0xc2, 0x74, 0x1f, 0xc6, 0x35, 0xd7, 0x5a, 0x14, 0x8d, 0x3f, 0xb0, 0xf0, 0xaa, 0xea, 0x00, 0x6e,
-	0x60, 0xc1, 0x47, 0x2e, 0xd3, 0x3e, 0x5f, 0xa7, 0x6c, 0xb0, 0x2a, 0xa6, 0x18, 0xb0, 0xab, 0xfe,
-	0xfb, 0x26, 0xac, 0x4d, 0xbb, 0xef, 0xd6, 0x9f, 0x26, 0x15, 0xe9, 0xb3, 0x98, 0xa9, 0xf3, 0xe0,
-	0x5b, 0xc1, 0x69, 0x10, 0xe3, 0x0d, 0x52, 0x5f, 0xe4, 0xbc, 0x5e, 0x2c, 0xd8, 0x2c, 0xf0, 0x5f,
-	0x09, 0x4e, 0x9f, 0x69, 0xf4, 0x7d, 0x0d, 0x9e, 0xa2, 0x3a, 0x4f, 0xd3, 0x42, 0xf5, 0xb5, 0x1f,
-	0xad, 0xfa, 0x0b, 0x8d, 0x36, 0xaa, 0x1f, 0x41, 0x07, 0x3b, 0xc6, 0x01, 0x8d, 0x89, 0xd4, 0x75,
-	0xae, 0x3a, 0xaf, 0x99, 0x9a, 0x69, 0xd4, 0x61, 0x01, 0xf2, 0x3e, 0x85, 0xdd, 0xaa, 0xc7, 0x98,
-	0x36, 0x60, 0xd9, 0xbc, 0x35, 0x4e, 0xb6, 0x5d, 0x11, 0x31, 0x5d, 0xc0, 0xa2, 0x81, 0xfb, 0x73,
-	0x58, 0x4d, 0x18, 0xc7, 0x7d, 0x8a, 0xef, 0x28, 0x6c, 0x23, 0xdb, 0xa4, 0x3e, 0x9d, 0x84, 0xf1,
-	0x1e, 0xcd, 0xf0, 0x96, 0xc5, 0xf4, 0xaf, 0xef, 0xc2, 0x1a, 0xc6, 0x89, 0x49, 0x79, 0x7b, 0xa1,
-	0xa0, 0x79, 0xe3, 0x80, 0xcb, 0xa3, 0xd1, 0xfc, 0xe5, 0xd1, 0xe8, 0x53, 0xb8, 0x3e, 0x06, 0x9a,
-	0xb4, 0xd6, 0x42, 0xe8, 0x56, 0x05, 0x3a, 0x66, 0xd4, 0xba, 0xcc, 0x3f, 0x34, 0x61, 0x7d, 0xea,
-	0x03, 0x86, 0x1f, 0x6e, 0xa4, 0xcc, 0xfc, 0x50, 0x23, 0xe5, 0x09, 0x78, 0xaf, 0xfa, 0x88, 0x61,
-	0x3c, 0xcd, 0x95, 0x19, 0x5d, 0x2d, 0x97, 0x58, 0x79, 0xd5, 0xef, 0xd1, 0xec, 0x89, 0x46, 0xe1,
-	0x88, 0xbd, 0xcf, 0x60, 0xd5, 0xaa, 0x12, 0xb9, 0x2a, 0x75, 0xd5, 0xf1, 0x86, 0x0e, 0xea, 0xfa,
-	0x1c, 0x61, 0x46, 0xd9, 0x5d, 0x58, 0xad, 0xf6, 0x36, 0xa4, 0xf9, 0x3a, 0xeb, 0x06, 0xde, 0x18,
-	0x0b, 0xbf, 0xc9, 0xf4, 0xe1, 0xab, 0x00, 0x9b, 0x8a, 0xda, 0x6b, 0x1f, 0xe3, 0x07, 0xdb, 0x63,
-	0x22, 0x26, 0x1f, 0xb5, 0x17, 0x46, 0x1f, 0xc1, 0xf6, 0x14, 0x83, 0x41, 0x98, 0x67, 0x23, 0xe7,
-	0x15, 0x9b, 0x17, 0xcd, 0x1e, 0x68, 0xb6, 0xf7, 0x18, 0x6e, 0x26, 0x8c, 0xb3, 0x24, 0x4f, 0x82,
-	0x50, 0x70, 0x77, 0x07, 0x36, 0x26, 0x8d, 0x5e, 0xb2, 0xe4, 0xef, 0x59, 0xb9, 0x83, 0x42, 0xac,
-	0xda, 0x13, 0x92, 0xd8, 0x6a, 0xc6, 0x6b, 0x64, 0x3b, 0x43, 0x95, 0xe5, 0xb4, 0xce, 0xb2, 0x8e,
-	0x37, 0xc4, 0x8e, 0xed, 0x56, 0xd2, 0x7a, 0xca, 0x3f, 0x5d, 0x83, 0xf5, 0xa9, 0xcf, 0x50, 0xbc,
-	0x47, 0x70, 0x93, 0x9e, 0xa5, 0x34, 0xd4, 0x8e, 0x52, 0x4d, 0x07, 0x8d, 0x01, 0xe3, 0xc8, 0xc6,
-	0x59, 0x6e, 0x38, 0xb9, 0xaa, 0x22, 0x6d, 0xc8, 0xb8, 0xf4, 0x21, 0xac, 0x90, 0x38, 0x3d, 0x21,
-	0x95, 0xf3, 0xbe, 0x8e, 0xb7, 0x2c, 0x23, 0xa8, 0x3c, 0xdc, 0x0f, 0x60, 0x79, 0x3c, 0x43, 0xa9,
-	0xe5, 0x27, 0x4b, 0x63, 0x89, 0x89, 0x5e, 0xb3, 0x3c, 0x1d, 0x66, 0x24, 0xc2, 0x8b, 0x7d, 0x45,
-	0xc3, 0x4a, 0xe8, 0xb0, 0x57, 0x58, 0x9b, 0x56, 0xa0, 0x57, 0xf0, 0xc7, 0x6e, 0x0f, 0xfe, 0x75,
-	0x06, 0xd6, 0xa7, 0xbe, 0xa9, 0xf1, 0x7e, 0x03, 0x3b, 0x57, 0x5c, 0x90, 0x9b, 0xc4, 0x6f, 0x8b,
-	0x5f, 0x76, 0x23, 0xfe, 0x09, 0xec, 0x5e, 0x40, 0xeb, 0xf0, 0x74, 0x82, 0x49, 0x80, 0x2d, 0x24,
-	0x27, 0xe1, 0xcf, 0x19, 0x7f, 0x8c, 0x7c, 0x5d, 0x83, 0x4d, 0xb9, 0xea, 0x6e, 0xe0, 0x55, 0x77,
-	0x77, 0x38, 0x79, 0xc7, 0xed, 0xb2, 0xcb, 0x19, 0x58, 0x9f, 0xfa, 0x76, 0xc7, 0x7b, 0x0f, 0xbc,
-	0x9c, 0x2b, 0x16, 0xdb, 0xb8, 0x60, 0x07, 0x61, 0xbe, 0xa1, 0x83, 0x1c, 0x74, 0x22, 0x6b, 0xfc,
-	0x53, 0xd8, 0x75, 0xb7, 0x9c, 0x95, 0xe7, 0x43, 0xc5, 0x28, 0xae, 0xe1, 0x28, 0xb6, 0xad, 0x48,
-	0x69, 0x70, 0x62, 0x34, 0xff, 0x76, 0x0d, 0x36, 0x2f, 0x79, 0xe3, 0xe3, 0xfd, 0x39, 0xbc, 0xc3,
-	0xe9, 0xe9, 0x58, 0x7f, 0x35, 0xa3, 0x43, 0x26, 0x95, 0xbd, 0x44, 0x30, 0xb5, 0xeb, 0xd8, 0x30,
-	0xdf, 0xe4, 0xf4, 0xb4, 0xa2, 0xce, 0xaf, 0x88, 0x63, 0x3d, 0x6b, 0xc7, 0x7e, 0x1f, 0x6e, 0xe0,
-	0x37, 0xd2, 0xf1, 0xee, 0xed, 0xe4, 0xe8, 0x77, 0xad, 0x50, 0x75, 0x80, 0x4e, 0x04, 0xbd, 0x4a,
-	0xd2, 0x71, 0xbc, 0xfe, 0xd8, 0x98, 0xd9, 0x3a, 0xbf, 0xe5, 0x6f, 0xe6, 0x92, 0x56, 0xb1, 0x8e,
-	0xed, 0x1d, 0xc3, 0xdb, 0x53, 0x71, 0xc1, 0x94, 0xf9, 0x37, 0x0e, 0xfa, 0x46, 0x3a, 0x45, 0xcf,
-	0x17, 0x13, 0x6b, 0x62, 0xe7, 0x34, 0x80, 0xed, 0x4b, 0x5f, 0x32, 0x69, 0x87, 0x75, 0xcb, 0x56,
-	0xbe, 0x93, 0x2a, 0xbe, 0x7b, 0xc6, 0x3c, 0x93, 0xb0, 0x12, 0x85, 0x96, 0x89, 0x45, 0xfb, 0x43,
-	0x13, 0x3a, 0x93, 0xaf, 0x84, 0x74, 0xc2, 0x17, 0xd1, 0x34, 0x16, 0xc5, 0xdd, 0x9c, 0x59, 0x91,
-	0x45, 0x43, 0x34, 0xdb, 0x49, 0x87, 0x85, 0x8c, 0x0e, 0x72, 0x89, 0xa9, 0xb2, 0xb9, 0x7e, 0xa8,
-	0x15, 0x16, 0x2c, 0xc8, 0xdd, 0x3c, 0x1c, 0xc3, 0x16, 0x17, 0xe5, 0xd4, 0x9b, 0x9a, 0xd6, 0xea,
-	0xab, 0x13, 0x20, 0x36, 0xb8, 0xe8, 0x55, 0xc1, 0x4e, 0xef, 0x23, 0xa8, 0xbc, 0x75, 0x0a, 0xe4,
-	0x09, 0xc9, 0xea, 0x5d, 0xa3, 0xad, 0x94, 0xa8, 0x23, 0x0d, 0xf2, 0x3e, 0x81, 0x85, 0xd3, 0x4a,
-	0x1c, 0xa8, 0x93, 0xcb, 0xc2, 0x69, 0x19, 0x17, 0x56, 0x61, 0x76, 0xa4, 0x03, 0x81, 0xbd, 0x20,
-	0x6b, 0x8e, 0x9e, 0x33, 0xae, 0xd3, 0xf1, 0x90, 0xa4, 0x3f, 0x26, 0xcd, 0x6c, 0x87, 0x24, 0xb5,
-	0x69, 0xeb, 0xdb, 0xd0, 0x71, 0xd9, 0x7f, 0xd1, 0x6b, 0x68, 0x61, 0x07, 0x6b, 0xd9, 0xd2, 0x9f,
-	0xdb, 0x76, 0xc3, 0x00, 0x6e, 0xe9, 0xb3, 0xc5, 0x48, 0x8d, 0x84, 0x79, 0x8e, 0x30, 0xf9, 0x48,
-	0xa9, 0xce, 0xed, 0xd8, 0x8d, 0x84, 0x9c, 0xa1, 0xd2, 0x63, 0x54, 0x32, 0xf1, 0x4a, 0xc9, 0xba,
-	0x52, 0x08, 0x9b, 0xee, 0x29, 0xdc, 0x7e, 0x9a, 0x66, 0x62, 0x44, 0xa3, 0x63, 0x9a, 0x49, 0x1d,
-	0xb6, 0x3d, 0x68, 0x72, 0x92, 0x50, 0xdb, 0x68, 0xc3, 0xbf, 0xbd, 0x0d, 0x98, 0xeb, 0x33, 0x4e,
-	0x32, 0xe3, 0x36, 0x6d, 0xdf, 0xfe, 0xd2, 0x74, 0x79, 0x42, 0xee, 0xfd, 0xfa, 0x03, 0x5c, 0xfe,
-	0xb6, 0x6f, 0x7f, 0x59, 0x23, 0xff, 0x38, 0x0f, 0x6b, 0xd3, 0x1e, 0xdc, 0x79, 0x37, 0x00, 0x74,
-	0xb8, 0xb5, 0x8f, 0x5a, 0xcc, 0xc1, 0xd6, 0x4e, 0x98, 0x7b, 0xa9, 0xa2, 0xd9, 0xe4, 0xac, 0xfa,
-	0xe6, 0x45, 0xb3, 0xc9, 0x99, 0x65, 0xff, 0x02, 0xf4, 0x29, 0x6b, 0x5f, 0xb7, 0x55, 0x4f, 0xc8,
-	0x06, 0x1e, 0xe2, 0x5e, 0x42, 0xce, 0x8c, 0xb5, 0xf2, 0x58, 0xbc, 0x01, 0x30, 0xcc, 0x44, 0x9e,
-	0x9a, 0xd6, 0x57, 0x13, 0xe5, 0xda, 0x48, 0xc1, 0x7e, 0xd7, 0x47, 0xe0, 0x02, 0x66, 0x10, 0x66,
-	0x14, 0x9f, 0xb9, 0x95, 0x7b, 0x73, 0x16, 0xf7, 0xe6, 0xa6, 0x15, 0x38, 0x30, 0xfc, 0x32, 0x1e,
-	0xbd, 0x06, 0x0b, 0x17, 0x33, 0x54, 0x50, 0x65, 0x6a, 0xfa, 0x25, 0x74, 0x89, 0x9d, 0xe2, 0x60,
-	0x64, 0xe6, 0x58, 0xe7, 0x1b, 0x8d, 0x4b, 0xdf, 0x5e, 0x5e, 0xb2, 0x30, 0x7e, 0x87, 0x8c, 0x13,
-	0xa4, 0xb7, 0x0b, 0x7a, 0x5a, 0x02, 0x2e, 0xb8, 0xcd, 0x56, 0x97, 0xfc, 0x56, 0x42, 0xce, 0x5e,
-	0xe8, 0xdf, 0xfa, 0xa3, 0x8a, 0x07, 0x92, 0xc5, 0xe5, 0xe3, 0x78, 0xeb, 0x69, 0xd3, 0x09, 0xb8,
-	0x2b, 0x46, 0xd7, 0x90, 0x79, 0x06, 0xaf, 0xbb, 0x2e, 0x63, 0xf9, 0x66, 0x41, 0x52, 0x12, 0x07,
-	0x26, 0x61, 0x46, 0x8b, 0xe6, 0x2d, 0xec, 0x92, 0xff, 0x9a, 0x15, 0x2d, 0xf2, 0x9e, 0x23, 0x4a,
-	0xe2, 0x47, 0x5a, 0x0e, 0x07, 0x22, 0xbd, 0x17, 0xf0, 0xc6, 0x95, 0xda, 0x24, 0x0d, 0x05, 0x8f,
-	0x5c, 0x4b, 0xea, 0xe6, 0xa5, 0xea, 0x8e, 0x8c, 0x9c, 0x2e, 0xc1, 0x71, 0x99, 0x68, 0x50, 0x7c,
-	0xe0, 0x80, 0x9a, 0x17, 0x7c, 0x4d, 0xbf, 0x6b, 0x58, 0x6e, 0x12, 0x1f, 0x52, 0xea, 0xdd, 0x86,
-	0x25, 0x7c, 0xc9, 0x49, 0x33, 0x3b, 0x55, 0x4b, 0x28, 0xb9, 0x30, 0xa0, 0x3a, 0xbd, 0x34, 0xb3,
-	0xf5, 0x56, 0x19, 0x21, 0x15, 0x4b, 0xa8, 0xc8, 0x95, 0xbd, 0x1f, 0x75, 0x31, 0xf0, 0xa5, 0xa1,
-	0x9a, 0x0b, 0x75, 0x1a, 0xe6, 0xe6, 0x86, 0xd9, 0x8a, 0xae, 0xb8, 0x0b, 0x75, 0xcb, 0x70, 0xc2,
-	0x6f, 0xc1, 0xca, 0xe4, 0xc5, 0x64, 0x07, 0x3f, 0x72, 0x79, 0xe2, 0xaa, 0xf1, 0x1e, 0xac, 0x8f,
-	0x84, 0xaa, 0xb4, 0x69, 0x5c, 0xbc, 0xe9, 0xa2, 0xf8, 0xaa, 0x66, 0x16, 0x71, 0xca, 0xc6, 0x96,
-	0x43, 0x70, 0x53, 0x15, 0x90, 0x5c, 0x09, 0x33, 0xa3, 0x74, 0x44, 0xb3, 0xf3, 0x80, 0xbb, 0x15,
-	0xf2, 0x10, 0xbe, 0x6b, 0xe5, 0xf6, 0x73, 0x25, 0xf4, 0x6c, 0x1e, 0x6a, 0xa1, 0x17, 0x66, 0x75,
-	0xec, 0x5e, 0xfd, 0xdb, 0x19, 0x68, 0x17, 0xef, 0x58, 0x75, 0xfd, 0xa5, 0x37, 0xe8, 0x90, 0x48,
-	0xe3, 0xd6, 0x01, 0x1f, 0x0a, 0xfe, 0x8a, 0xd8, 0xad, 0xda, 0x4d, 0x18, 0x7f, 0x44, 0x24, 0xba,
-	0xf7, 0x0b, 0x64, 0xe8, 0x25, 0xc1, 0x82, 0xad, 0xf2, 0xb5, 0x43, 0x22, 0xed, 0xde, 0xc5, 0x7a,
-	0xad, 0xbc, 0xd6, 0x7a, 0x44, 0xa4, 0xf7, 0x0e, 0x74, 0x51, 0xb9, 0x7d, 0x98, 0x15, 0xe2, 0x4e,
-	0x37, 0x2d, 0xe5, 0xe5, 0x21, 0xd1, 0x1b, 0xb7, 0x27, 0xc2, 0x03, 0x4d, 0x35, 0xe3, 0xbb, 0xff,
-	0xf9, 0x1f, 0xbe, 0xdb, 0x9b, 0xf9, 0xe3, 0x77, 0x7b, 0x33, 0xff, 0xfe, 0xdd, 0xde, 0xcc, 0xdf,
-	0x7c, 0xbf, 0xf7, 0x93, 0x3f, 0x7e, 0xbf, 0xf7, 0x93, 0x3f, 0x7d, 0xbf, 0xf7, 0x93, 0xaf, 0x7e,
-	0x3d, 0x64, 0xea, 0x24, 0xef, 0xdf, 0x09, 0x45, 0x72, 0x37, 0xcd, 0x44, 0x94, 0x87, 0x4a, 0x86,
-	0x6c, 0xe2, 0x3f, 0x52, 0x54, 0x5f, 0xc9, 0xaa, 0xf3, 0x94, 0xca, 0xfe, 0x1c, 0xfe, 0xdf, 0x87,
-	0x5f, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x34, 0x17, 0x41, 0x3b, 0x78, 0x31, 0x00, 0x00,
+	// 4525 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x5b, 0x4f, 0x73, 0x1c, 0x37,
+	0x76, 0x37, 0x35, 0x43, 0x72, 0xe6, 0x91, 0x14, 0x67, 0x9a, 0xff, 0x49, 0x89, 0x96, 0xe4, 0xff,
+	0x6b, 0x5b, 0xf2, 0xca, 0xbb, 0x76, 0xca, 0x5e, 0xbb, 0x96, 0xa2, 0xa8, 0x7f, 0x16, 0xe5, 0x49,
+	0x53, 0xe2, 0xc6, 0x2e, 0x57, 0xba, 0x30, 0xdd, 0x98, 0x21, 0xa2, 0x6e, 0xa0, 0xdd, 0x40, 0x0f,
+	0x49, 0x7f, 0x84, 0xa4, 0x52, 0x95, 0x2f, 0x90, 0xaa, 0x54, 0xe5, 0x90, 0xca, 0x25, 0xd9, 0x43,
+	0x4e, 0xf9, 0x02, 0xd9, 0xdc, 0x36, 0xb7, 0x3d, 0xa6, 0xec, 0x4a, 0x25, 0x97, 0x1c, 0x52, 0xf9,
+	0x02, 0x29, 0x3c, 0x00, 0xdd, 0x3d, 0x7f, 0x48, 0x8f, 0x73, 0x51, 0x71, 0xf0, 0xde, 0xef, 0x07,
+	0x34, 0xf0, 0xf0, 0xf0, 0xde, 0x03, 0x04, 0x37, 0x18, 0xef, 0xd1, 0x8c, 0xf2, 0x90, 0xde, 0x29,
+	0xff, 0x4a, 0x49, 0x46, 0x12, 0x79, 0x3b, 0xcd, 0x84, 0x12, 0xde, 0x4a, 0xd1, 0x7e, 0xbb, 0xf8,
+	0x6b, 0xbb, 0x4d, 0x12, 0xc6, 0xc5, 0x1d, 0xfc, 0xd7, 0xe8, 0x6d, 0xaf, 0xf6, 0x45, 0x5f, 0xe0,
+	0x9f, 0x77, 0xf4, 0x5f, 0xb6, 0x75, 0x2b, 0x14, 0x32, 0x11, 0x32, 0x30, 0x02, 0xf3, 0xc3, 0x88,
+	0x6e, 0xfd, 0xf3, 0x22, 0xcc, 0x75, 0xb0, 0x27, 0x6f, 0x1f, 0x16, 0x69, 0x2a, 0xc2, 0x93, 0xc0,
+	0xf4, 0xbc, 0x39, 0x73, 0x63, 0xe6, 0xed, 0x85, 0xbb, 0x37, 0x6e, 0x4f, 0xe8, 0xfa, 0xf6, 0x81,
+	0x56, 0x34, 0x38, 0x7f, 0x81, 0x96, 0x3f, 0x3c, 0x1f, 0xda, 0x03, 0x12, 0xb3, 0x88, 0x28, 0x26,
+	0xb8, 0x63, 0xba, 0x82, 0x4c, 0x6f, 0x4c, 0x64, 0x3a, 0x2e, 0xb4, 0x2d, 0x5d, 0x6b, 0x30, 0xd2,
+	0xe2, 0x7d, 0x06, 0x90, 0x8a, 0xd0, 0x91, 0xd5, 0x90, 0x6c, 0x77, 0x22, 0x59, 0x47, 0x84, 0x96,
+	0xa5, 0x99, 0xba, 0x3f, 0xf5, 0x90, 0x94, 0x78, 0x49, 0xb9, 0x48, 0x58, 0x28, 0x1d, 0x4b, 0xfd,
+	0x92, 0x21, 0x3d, 0x2f, 0xb4, 0xdd, 0x90, 0xd4, 0x48, 0x8b, 0xe6, 0x0c, 0x45, 0x1c, 0x13, 0x45,
+	0x33, 0x12, 0x3b, 0xce, 0xd9, 0x4b, 0x38, 0xf7, 0x0b, 0x6d, 0xc7, 0x19, 0x8e, 0xb4, 0x78, 0xdf,
+	0xc0, 0x5a, 0x97, 0xa9, 0x50, 0x30, 0x1e, 0x64, 0xf4, 0x94, 0x64, 0x91, 0xe3, 0x9d, 0x43, 0xde,
+	0xb7, 0x27, 0xf2, 0xde, 0x33, 0x08, 0x1f, 0x01, 0x96, 0x7a, 0xa5, 0x3b, 0xde, 0xe8, 0x05, 0xb0,
+	0x1e, 0x9d, 0x73, 0x92, 0xb0, 0x30, 0x48, 0x33, 0x16, 0x32, 0xde, 0x77, 0xf4, 0xf3, 0x48, 0xff,
+	0xce, 0x44, 0xfa, 0xfb, 0x06, 0xd2, 0x31, 0x08, 0xcb, 0xbf, 0x1a, 0x4d, 0x68, 0xf5, 0xba, 0xb0,
+	0xd1, 0x25, 0x3c, 0x3a, 0x65, 0x91, 0x3a, 0x09, 0x62, 0x96, 0x30, 0x55, 0x4c, 0x76, 0x03, 0x7b,
+	0xf8, 0xd9, 0xe4, 0x0f, 0x70, 0x98, 0xa7, 0x08, 0xb1, 0x5d, 0xac, 0x75, 0x27, 0x35, 0xeb, 0x3e,
+	0x42, 0xc1, 0x7b, 0x2c, 0x4b, 0xac, 0x7d, 0x95, 0x66, 0xd1, 0xbc, 0xa4, 0x8f, 0xfd, 0x0a, 0xa6,
+	0x23, 0xf6, 0x5d, 0x1f, 0xe1, 0x50, 0x73, 0x58, 0xf6, 0xd1, 0xa7, 0x9c, 0x4a, 0x26, 0x83, 0x7e,
+	0x4e, 0xb2, 0x88, 0x91, 0xc2, 0x8e, 0xe1, 0x92, 0x3e, 0x1e, 0x1a, 0xcc, 0x43, 0x0b, 0x71, 0x7d,
+	0xf4, 0x27, 0x35, 0xeb, 0x3e, 0x22, 0x3a, 0xa0, 0xb1, 0x48, 0x69, 0x16, 0x90, 0x30, 0xa4, 0xb2,
+	0x98, 0xab, 0x85, 0x4b, 0xfa, 0xb8, 0xef, 0x30, 0x7b, 0x08, 0x71, 0x7d, 0x44, 0x93, 0x9a, 0xbd,
+	0x13, 0xd8, 0x4a, 0x49, 0xa6, 0x58, 0xc8, 0x52, 0xc2, 0xd5, 0x48, 0x2f, 0x8b, 0xd8, 0xcb, 0x7b,
+	0x93, 0x37, 0x51, 0x89, 0x1a, 0xea, 0x67, 0x23, 0x9d, 0x2c, 0xf0, 0x04, 0x5c, 0x53, 0x19, 0xe1,
+	0xb2, 0xa7, 0x3f, 0xa6, 0x4f, 0xc7, 0x3a, 0x5b, 0xc2, 0xce, 0x6e, 0x4f, 0xde, 0x6b, 0x16, 0xb8,
+	0xa7, 0x71, 0x43, 0xdd, 0x6d, 0xa9, 0x8b, 0x44, 0x68, 0xcb, 0x74, 0x20, 0x4f, 0xf4, 0x1e, 0xa1,
+	0x32, 0xcc, 0xc4, 0xa9, 0xeb, 0xea, 0xea, 0x65, 0xb6, 0x6c, 0x21, 0x07, 0x88, 0x28, 0x6c, 0x79,
+	0x42, 0xab, 0xf6, 0x38, 0x3d, 0x4a, 0x1d, 0xe9, 0xf2, 0x25, 0x1e, 0xe7, 0x01, 0xa5, 0xce, 0xe3,
+	0xf4, 0xdc, 0x9f, 0xda, 0x3b, 0x44, 0x34, 0xa6, 0xfd, 0x21, 0x27, 0xd8, 0xba, 0xc4, 0x3b, 0xdc,
+	0x2f, 0xb4, 0x9d, 0x77, 0x88, 0x46, 0x5a, 0xbc, 0x17, 0xe0, 0x25, 0x84, 0x71, 0x45, 0x39, 0xe1,
+	0x61, 0x31, 0xb4, 0x36, 0x92, 0xbe, 0x39, 0x91, 0xf4, 0xb0, 0x54, 0xb7, 0xac, 0xed, 0x64, 0xb4,
+	0xe9, 0x93, 0x37, 0xfe, 0xeb, 0x6f, 0x5e, 0x9d, 0xf9, 0xf3, 0xff, 0xfc, 0xed, 0xcf, 0xae, 0x95,
+	0x27, 0xcf, 0x59, 0xe5, 0x14, 0x72, 0xd3, 0x24, 0xf3, 0x2e, 0xa7, 0x6a, 0x78, 0xb6, 0x6f, 0xfd,
+	0x63, 0x1d, 0xda, 0x63, 0xbd, 0x78, 0x77, 0x60, 0xa5, 0x3a, 0x52, 0xca, 0x49, 0x37, 0xa6, 0x11,
+	0x1e, 0x27, 0x0d, 0xbf, 0xfa, 0x11, 0x07, 0x46, 0xe2, 0x3d, 0x83, 0xd7, 0xab, 0x80, 0x84, 0xf1,
+	0x40, 0x86, 0x27, 0x34, 0xca, 0x63, 0x1a, 0xc4, 0x94, 0x44, 0x41, 0x37, 0x16, 0xe1, 0x4b, 0x73,
+	0x8c, 0xd4, 0xfd, 0x1b, 0x15, 0xdd, 0x43, 0xc6, 0x8f, 0xac, 0xe6, 0x53, 0x4a, 0xa2, 0x7b, 0xa8,
+	0xe7, 0xed, 0xc1, 0xf5, 0x21, 0x3e, 0x72, 0x16, 0x9c, 0x32, 0x1e, 0x89, 0x53, 0x47, 0x54, 0x43,
+	0xa2, 0xed, 0x2a, 0x11, 0x39, 0xfb, 0x0d, 0xaa, 0x58, 0x8a, 0x3f, 0x86, 0x37, 0x46, 0x29, 0x42,
+	0xc1, 0xc3, 0x3c, 0xcb, 0xb4, 0x79, 0xdb, 0x13, 0x4a, 0x64, 0xe6, 0x1c, 0x59, 0xf2, 0x6f, 0x0d,
+	0x53, 0xed, 0x17, 0xaa, 0xc7, 0x85, 0xe6, 0xd8, 0x57, 0x0e, 0x53, 0xa6, 0xe2, 0x94, 0x66, 0x41,
+	0x37, 0x35, 0xa7, 0xc8, 0xd2, 0xf0, 0x57, 0x56, 0x19, 0x3b, 0x5a, 0xf1, 0x5e, 0x3a, 0xf6, 0x95,
+	0x61, 0x46, 0x23, 0xa6, 0x82, 0x90, 0xa4, 0xee, 0x2b, 0xe7, 0xc6, 0xbe, 0x72, 0x1f, 0x75, 0xf6,
+	0x49, 0x6a, 0xbf, 0xf2, 0xcf, 0xe0, 0xc3, 0x09, 0x14, 0x94, 0x64, 0x3c, 0xd0, 0x8e, 0x49, 0xe6,
+	0xb8, 0xe9, 0x7a, 0x79, 0x1c, 0x98, 0xc0, 0xc0, 0x12, 0xcf, 0x23, 0xf1, 0xfb, 0x63, 0xc4, 0x07,
+	0x24, 0xe3, 0x1d, 0x9a, 0x1d, 0x15, 0x30, 0x8c, 0x12, 0x4c, 0x5f, 0x9f, 0xd4, 0xb5, 0xa1, 0xdd,
+	0xfa, 0xa7, 0x39, 0x68, 0x5b, 0x4f, 0xf9, 0x25, 0x8f, 0xcf, 0xad, 0xc5, 0xdc, 0x84, 0x45, 0x25,
+	0x14, 0x89, 0x03, 0x99, 0xa7, 0x69, 0x7c, 0x8e, 0xa6, 0x52, 0xf3, 0x17, 0xb0, 0xed, 0x08, 0x9b,
+	0xbc, 0x77, 0xa1, 0x2d, 0x32, 0xd6, 0x67, 0x5c, 0x4f, 0xa6, 0xd3, 0xbb, 0x82, 0x7a, 0xad, 0x52,
+	0x60, 0x95, 0x7f, 0x01, 0xeb, 0x52, 0x11, 0x1e, 0x69, 0xff, 0x60, 0x8f, 0x52, 0x92, 0x88, 0x9c,
+	0x2b, 0x5c, 0xae, 0x9a, 0xbf, 0xea, 0xa4, 0xe6, 0x84, 0xdc, 0x43, 0x99, 0xf7, 0x29, 0x6c, 0xa7,
+	0x19, 0xd5, 0x41, 0x52, 0x3f, 0x23, 0x49, 0x42, 0xa3, 0x40, 0x92, 0x98, 0x3a, 0xe4, 0x2c, 0x22,
+	0x37, 0xd2, 0x8c, 0x76, 0x0a, 0x85, 0x23, 0x12, 0x53, 0x0b, 0xbe, 0x09, 0x8b, 0x66, 0x50, 0x41,
+	0xa4, 0x23, 0x05, 0x9c, 0xa3, 0xa6, 0xbf, 0x60, 0xda, 0xee, 0xeb, 0x26, 0x2f, 0x84, 0x57, 0xf5,
+	0xa2, 0x33, 0x1e, 0xb1, 0x01, 0x8b, 0x72, 0x1d, 0x37, 0xe0, 0xa2, 0xa7, 0x34, 0x0b, 0x29, 0x57,
+	0xa4, 0x4f, 0xad, 0x5b, 0xbe, 0x76, 0x81, 0x8f, 0x08, 0x59, 0x42, 0x62, 0xff, 0x5a, 0x42, 0xce,
+	0x1e, 0x17, 0x1c, 0x68, 0x0e, 0x9d, 0x82, 0xc1, 0xfb, 0x23, 0xd8, 0x1c, 0x3b, 0xbd, 0xdc, 0x0e,
+	0x5c, 0xc2, 0x1d, 0xb8, 0x3e, 0x72, 0x24, 0xb9, 0x5d, 0xf8, 0x0d, 0xbc, 0x3b, 0x86, 0xe4, 0x54,
+	0x9d, 0x8a, 0xec, 0x65, 0x90, 0x10, 0x95, 0x67, 0x4c, 0x9d, 0x07, 0xea, 0x24, 0xa3, 0xf2, 0x44,
+	0xc4, 0x11, 0x7a, 0xda, 0x9a, 0xff, 0xd6, 0x08, 0xd9, 0x33, 0x03, 0x38, 0xb4, 0xfa, 0xcf, 0x9d,
+	0xba, 0xf7, 0x0d, 0xec, 0x8c, 0xb1, 0x27, 0x79, 0xac, 0x58, 0x1a, 0x33, 0x9a, 0x59, 0x17, 0x7b,
+	0xf9, 0x87, 0x6f, 0x8d, 0xf4, 0x75, 0x58, 0xc0, 0xbd, 0x5f, 0xc1, 0xf6, 0x18, 0x3b, 0x89, 0xa2,
+	0x8c, 0x4a, 0x49, 0xb5, 0xe7, 0xad, 0xbd, 0xdd, 0xf4, 0x37, 0x47, 0xe0, 0x7b, 0x4e, 0xfe, 0xa4,
+	0xde, 0xa8, 0xb5, 0xea, 0x4f, 0xea, 0x8d, 0xb9, 0xd6, 0xfc, 0x93, 0x7a, 0xa3, 0xd1, 0x6a, 0x3e,
+	0xa9, 0x37, 0x9a, 0x2d, 0x78, 0x52, 0x6f, 0x40, 0x6b, 0xe1, 0x49, 0xbd, 0xb1, 0xd0, 0x5a, 0xf4,
+	0xdb, 0x4a, 0xa4, 0xc3, 0xb6, 0xa4, 0xed, 0xd3, 0x35, 0xc9, 0x21, 0x79, 0x4a, 0x33, 0x26, 0x22,
+	0xdf, 0xab, 0x36, 0x91, 0x73, 0x91, 0x2b, 0xe9, 0x5f, 0x1b, 0x6f, 0xc3, 0xad, 0x96, 0x30, 0x4e,
+	0x33, 0x7f, 0xa3, 0x22, 0xd5, 0xa6, 0x12, 0xe5, 0x19, 0x1e, 0x01, 0xb7, 0xfe, 0xa7, 0x06, 0xad,
+	0xd1, 0xa8, 0xd4, 0xfb, 0x1a, 0xb6, 0x65, 0xde, 0x95, 0x2c, 0x3a, 0x0f, 0x32, 0x1a, 0xe5, 0x21,
+	0x1e, 0x36, 0x7a, 0x4b, 0x66, 0x03, 0x12, 0xdb, 0xe8, 0xfd, 0xf2, 0x19, 0xdd, 0xb4, 0x78, 0xdf,
+	0xc1, 0x1f, 0x5b, 0xb4, 0x77, 0x0c, 0x9b, 0xe3, 0xdc, 0x76, 0x27, 0x5c, 0x99, 0x82, 0x79, 0x7d,
+	0x94, 0xd9, 0x6e, 0x93, 0xaf, 0x61, 0xdb, 0x79, 0x3c, 0xc7, 0x5f, 0x31, 0xff, 0xda, 0x34, 0x63,
+	0xb6, 0xf8, 0x23, 0x03, 0xaf, 0x98, 0xfe, 0x6d, 0x58, 0x41, 0x63, 0x1d, 0x50, 0xa9, 0x30, 0xbc,
+	0xc5, 0x65, 0xb0, 0x6e, 0xb0, 0xad, 0x45, 0xc7, 0x46, 0xd2, 0x41, 0x81, 0x77, 0x17, 0xd6, 0xec,
+	0x5c, 0x8f, 0x20, 0x8c, 0x7f, 0x5b, 0x31, 0xc2, 0x21, 0x8c, 0xf1, 0x62, 0x4f, 0xea, 0x8d, 0x7a,
+	0x6b, 0xf6, 0x49, 0xbd, 0x31, 0xdb, 0x9a, 0x33, 0x06, 0xe3, 0x6f, 0x57, 0xcd, 0x23, 0x8e, 0xc5,
+	0x29, 0x8d, 0x82, 0x1e, 0x61, 0x71, 0x9e, 0x51, 0x7f, 0x47, 0xcb, 0x70, 0x81, 0x31, 0x5e, 0xfd,
+	0x36, 0x27, 0x31, 0xeb, 0xb1, 0x10, 0x57, 0xd6, 0xdf, 0x2c, 0x85, 0xc3, 0xa3, 0xb8, 0xf5, 0x2f,
+	0x73, 0xb0, 0x50, 0x49, 0xb3, 0xb4, 0x87, 0x31, 0x5e, 0x38, 0xa6, 0xbc, 0xaf, 0x4e, 0x9c, 0x93,
+	0xc4, 0xb6, 0xa7, 0xd8, 0xe4, 0xbd, 0x03, 0x2d, 0xa3, 0x52, 0xd9, 0x59, 0xc6, 0x47, 0x2e, 0x63,
+	0x7b, 0x65, 0xc7, 0xbc, 0x0a, 0x06, 0x19, 0xc8, 0x13, 0xd6, 0x53, 0x38, 0xf3, 0x35, 0x1f, 0xb0,
+	0xe9, 0x48, 0xb7, 0x78, 0xbf, 0x86, 0xeb, 0x11, 0xed, 0x91, 0x3c, 0x56, 0x41, 0xce, 0x99, 0x0a,
+	0x44, 0x2f, 0x08, 0x45, 0x92, 0xe6, 0x8a, 0x62, 0xfe, 0x40, 0xad, 0x2b, 0xdd, 0xb2, 0x4a, 0x2f,
+	0x38, 0x53, 0x5f, 0xf6, 0xf6, 0x8d, 0x86, 0x4e, 0x0c, 0xa8, 0xf7, 0x1e, 0x78, 0xfa, 0x7b, 0xa5,
+	0x5e, 0x9c, 0xc2, 0x94, 0xad, 0x1f, 0x6d, 0xa5, 0x22, 0x3c, 0xd2, 0x82, 0xfb, 0xb6, 0xdd, 0xfb,
+	0x08, 0xd6, 0xb4, 0x36, 0x3d, 0x0b, 0x4f, 0x08, 0xaf, 0x02, 0xf4, 0xfa, 0xd5, 0xee, 0x5d, 0xd9,
+	0x9c, 0xf1, 0x57, 0x52, 0x11, 0x1e, 0x58, 0x79, 0x81, 0xfb, 0x00, 0x56, 0x35, 0xae, 0x92, 0x74,
+	0x46, 0x34, 0x26, 0xe7, 0xb8, 0x88, 0x35, 0x5f, 0x8f, 0xa0, 0xcc, 0x30, 0xef, 0x6b, 0x89, 0xf7,
+	0x11, 0x6c, 0x8c, 0x22, 0x5c, 0x5f, 0x0d, 0x04, 0xad, 0x0d, 0x83, 0x5c, 0x4f, 0x1f, 0xc3, 0xa6,
+	0xa4, 0x2a, 0xe0, 0xf4, 0xb4, 0x12, 0x00, 0xd8, 0xde, 0x9a, 0x06, 0x28, 0xa9, 0x7a, 0x46, 0x4f,
+	0xcb, 0x43, 0xdf, 0x74, 0xf8, 0x39, 0xec, 0x14, 0x76, 0x5c, 0xed, 0x36, 0xcc, 0x95, 0xe8, 0xf5,
+	0x30, 0xab, 0xa8, 0xf9, 0x5b, 0x85, 0x4a, 0xd9, 0xf5, 0x3e, 0x2a, 0x78, 0x8f, 0xe1, 0x66, 0x89,
+	0x4f, 0xb3, 0x9c, 0x6b, 0x2b, 0x31, 0xab, 0x57, 0xfa, 0xe3, 0x05, 0x34, 0xda, 0xdd, 0x42, 0xb1,
+	0x63, 0xf4, 0xd0, 0x82, 0x4a, 0x37, 0x7c, 0x17, 0xd6, 0xc6, 0xa9, 0x12, 0x72, 0x86, 0x27, 0x4f,
+	0xcd, 0x5f, 0x19, 0x85, 0x1f, 0x92, 0x33, 0xef, 0x4d, 0x58, 0xc6, 0x3c, 0xab, 0xa2, 0xbd, 0x84,
+	0xda, 0x4b, 0x3a, 0xc7, 0x2e, 0xf5, 0x9e, 0xc2, 0x0a, 0xae, 0x77, 0x2c, 0x14, 0xee, 0x01, 0x63,
+	0xe1, 0x36, 0x24, 0xbf, 0x7c, 0x53, 0xb7, 0xb5, 0x39, 0xc4, 0x42, 0xed, 0x15, 0x30, 0x6f, 0x1f,
+	0x76, 0xc7, 0x52, 0x3d, 0x49, 0x7a, 0x54, 0x9d, 0xdb, 0x60, 0x0e, 0xcf, 0x8c, 0x9a, 0xbf, 0x33,
+	0x92, 0xc5, 0x1d, 0xa1, 0x8e, 0x09, 0xe6, 0x6c, 0xd0, 0xf1, 0xdf, 0x57, 0xa1, 0x35, 0x5a, 0x66,
+	0xd0, 0xa3, 0xed, 0x91, 0x58, 0xd2, 0x20, 0x15, 0x92, 0x29, 0x36, 0xa0, 0x41, 0x46, 0x14, 0x9d,
+	0xca, 0x6d, 0xb6, 0x11, 0xd8, 0xb1, 0x38, 0x9f, 0x28, 0xaa, 0x6d, 0x43, 0x87, 0xad, 0x19, 0x49,
+	0xd2, 0x20, 0x4f, 0x83, 0x84, 0x12, 0x99, 0x67, 0x34, 0xa1, 0x5c, 0x99, 0xb0, 0x75, 0xd6, 0x5f,
+	0x4b, 0x18, 0xf7, 0x49, 0x92, 0xbe, 0x48, 0x0f, 0x2b, 0x42, 0xef, 0x53, 0x80, 0x94, 0x48, 0xa9,
+	0xcd, 0x22, 0x9f, 0xce, 0x01, 0x36, 0xb5, 0xfe, 0xb1, 0x56, 0xf7, 0x7c, 0x58, 0xd7, 0xbd, 0x56,
+	0x4c, 0x8a, 0x0c, 0x68, 0xa6, 0x3d, 0x69, 0x7d, 0x0a, 0xa2, 0xd5, 0x84, 0xf1, 0x72, 0x5a, 0xf6,
+	0x0c, 0x12, 0x39, 0xc9, 0xd9, 0x24, 0xce, 0xd9, 0xa9, 0x38, 0xc9, 0xd9, 0x38, 0xe7, 0xbb, 0xd0,
+	0xa6, 0x67, 0x29, 0x33, 0xfb, 0xa8, 0x1a, 0x9e, 0xd6, 0xfc, 0x56, 0x29, 0xb0, 0x41, 0xe9, 0x2d,
+	0x58, 0x42, 0xdb, 0x96, 0x81, 0x12, 0x68, 0x6c, 0xf3, 0x15, 0x47, 0x27, 0x9f, 0x0b, 0x6d, 0x6a,
+	0xfb, 0xb0, 0xdb, 0xcb, 0xe3, 0xb8, 0x3a, 0x4a, 0x95, 0x91, 0x5e, 0x8f, 0x85, 0x6e, 0x53, 0x99,
+	0x9d, 0xbc, 0xa3, 0xb5, 0xca, 0xf1, 0x3c, 0x37, 0x3a, 0x76, 0x5b, 0x8d, 0xcf, 0xde, 0x09, 0x89,
+	0x7b, 0xa7, 0x76, 0x37, 0xff, 0xb4, 0xd9, 0x7b, 0x64, 0x90, 0x18, 0x94, 0x0f, 0x73, 0x8e, 0x8c,
+	0xcb, 0x6c, 0xf6, 0xed, 0x21, 0xf0, 0x84, 0x61, 0x49, 0x59, 0x39, 0x17, 0x1d, 0x76, 0x61, 0xba,
+	0x61, 0x49, 0x59, 0x1e, 0x8a, 0x96, 0xb3, 0x03, 0x6b, 0xc8, 0x99, 0xd1, 0x6f, 0x73, 0x2a, 0x31,
+	0xe6, 0xe0, 0x24, 0x56, 0xe7, 0x53, 0x05, 0x9c, 0x2b, 0x1a, 0xea, 0x5b, 0x64, 0xc7, 0x00, 0xbd,
+	0x9f, 0xc3, 0xaa, 0x62, 0x09, 0x95, 0x4a, 0x5b, 0x7c, 0xb9, 0x86, 0xd6, 0x33, 0xac, 0x14, 0xb2,
+	0x83, 0x42, 0xa4, 0xad, 0xa0, 0x84, 0x90, 0x68, 0xa0, 0x13, 0x07, 0x1b, 0x46, 0xb6, 0x0a, 0xc1,
+	0x9e, 0x69, 0xd7, 0xc7, 0x8f, 0x3e, 0x0e, 0x13, 0xa2, 0x68, 0x54, 0x54, 0x93, 0x74, 0x86, 0xa4,
+	0x8d, 0x24, 0x78, 0xd9, 0xc5, 0xdd, 0x5f, 0xf7, 0xb7, 0x0a, 0x25, 0x5b, 0x27, 0xa2, 0x19, 0x9a,
+	0xd1, 0x17, 0x5d, 0x1d, 0x71, 0x32, 0x8e, 0x0b, 0x11, 0x64, 0x34, 0xcd, 0x95, 0x75, 0x23, 0x19,
+	0x95, 0x34, 0x1b, 0x50, 0x9b, 0x8e, 0xff, 0x48, 0xc4, 0x69, 0x09, 0xfc, 0x02, 0xdf, 0xb1, 0x70,
+	0xaf, 0x0f, 0x37, 0xbb, 0x04, 0x2b, 0x74, 0x45, 0x85, 0xc5, 0x2a, 0x9b, 0x7e, 0xd0, 0x99, 0xb4,
+	0xa7, 0xe8, 0x63, 0xb7, 0x4b, 0xa2, 0x4a, 0xc5, 0xe5, 0x71, 0x85, 0x04, 0x3d, 0xcb, 0x31, 0x6c,
+	0x0e, 0x11, 0x57, 0x7d, 0xbe, 0x37, 0x4d, 0x24, 0x56, 0x45, 0x3f, 0x2a, 0x4f, 0x82, 0x63, 0xd8,
+	0x8c, 0xc4, 0x29, 0xd7, 0x13, 0x1f, 0xf4, 0x85, 0x88, 0xaa, 0x71, 0xd8, 0xca, 0x34, 0xbc, 0x0e,
+	0xfd, 0x50, 0x88, 0xa8, 0x12, 0x85, 0x3d, 0x87, 0x8d, 0x82, 0x17, 0x67, 0xa8, 0xa4, 0x5d, 0x9d,
+	0x82, 0x76, 0xcd, 0x81, 0xef, 0x91, 0x2a, 0xeb, 0x33, 0x58, 0x2d, 0x58, 0xab, 0x33, 0xb0, 0x36,
+	0x05, 0xa5, 0xe7, 0x90, 0x95, 0xaf, 0xff, 0x53, 0xb8, 0x56, 0xf0, 0x4d, 0xb2, 0x8e, 0xf5, 0x29,
+	0x78, 0xb7, 0x1d, 0xc3, 0x04, 0xf3, 0x78, 0x0e, 0x1b, 0xdf, 0xe6, 0x2c, 0x7c, 0xe9, 0x82, 0xc0,
+	0xca, 0x90, 0x37, 0xa6, 0x99, 0x05, 0x04, 0x3f, 0x30, 0xd8, 0x72, 0xd4, 0xbf, 0x86, 0xa5, 0x2e,
+	0xe3, 0x22, 0x09, 0x14, 0x95, 0x2a, 0x48, 0x3f, 0xd8, 0xdc, 0x9c, 0x82, 0x6b, 0x01, 0x21, 0xcf,
+	0xa9, 0x54, 0x9d, 0x0f, 0x74, 0x7a, 0x18, 0xc6, 0x84, 0x25, 0x55, 0x0f, 0xe5, 0xd2, 0xc3, 0x2d,
+	0x93, 0x1e, 0xa2, 0xbc, 0x74, 0x4e, 0x2e, 0x3d, 0x7c, 0x0d, 0x96, 0x62, 0xd1, 0x4f, 0x33, 0xd1,
+	0x95, 0x41, 0x22, 0x22, 0xba, 0xb9, 0x8d, 0x19, 0xee, 0xa2, 0x6b, 0x3c, 0x14, 0x11, 0xb5, 0xe7,
+	0xed, 0x1f, 0x6a, 0x70, 0xb5, 0x23, 0xf6, 0x75, 0x8b, 0xab, 0x6d, 0xb7, 0xa0, 0x16, 0xb1, 0x04,
+	0x4f, 0xd7, 0x59, 0x5f, 0xff, 0xe9, 0x6d, 0x41, 0x83, 0x07, 0x31, 0x39, 0xa7, 0x99, 0x3b, 0x21,
+	0xe7, 0xf9, 0x53, 0xfc, 0xe9, 0x6d, 0xc0, 0x3c, 0x0f, 0x4e, 0x28, 0x89, 0x4c, 0xa5, 0x66, 0xd6,
+	0x9f, 0xe3, 0x8f, 0xf4, 0x2f, 0xef, 0x1a, 0x00, 0x0f, 0x5e, 0x0e, 0xac, 0xac, 0x8e, 0xb2, 0x06,
+	0xff, 0x62, 0x60, 0xa4, 0xd7, 0x01, 0x06, 0x22, 0x24, 0xdd, 0x40, 0xb2, 0xef, 0xcc, 0x69, 0x35,
+	0xeb, 0x37, 0xb1, 0xe5, 0x88, 0x7d, 0x47, 0xbd, 0x27, 0xe0, 0xf5, 0x7a, 0x3c, 0x88, 0x58, 0x52,
+	0x0d, 0x8f, 0xe7, 0xa6, 0x98, 0xc1, 0x56, 0xaf, 0xc7, 0xef, 0xb3, 0x64, 0x38, 0x7a, 0xb6, 0x1c,
+	0x34, 0x10, 0x3d, 0x3c, 0xa1, 0x66, 0x7d, 0x70, 0x4d, 0x5f, 0xf6, 0xbc, 0x8f, 0xa1, 0xc1, 0x45,
+	0x96, 0x04, 0x34, 0x75, 0xd5, 0xef, 0xcb, 0xbb, 0x98, 0xd7, 0xda, 0x07, 0x29, 0x7e, 0x44, 0x26,
+	0x52, 0x6d, 0x2f, 0x54, 0x11, 0x3c, 0x88, 0x66, 0xfd, 0xa6, 0x6e, 0x79, 0xae, 0x1b, 0x74, 0x2c,
+	0x96, 0x4b, 0x1a, 0xc8, 0x90, 0xc4, 0x34, 0x0a, 0x74, 0x3b, 0x9e, 0x28, 0x0d, 0x7f, 0x29, 0x97,
+	0xf4, 0x08, 0x5b, 0x7d, 0x91, 0x52, 0x3d, 0x85, 0x92, 0x7e, 0xab, 0x53, 0x05, 0x3c, 0x35, 0x66,
+	0xfd, 0x39, 0x49, 0xbf, 0x7d, 0x4a, 0x75, 0x10, 0xdb, 0xc8, 0x02, 0x45, 0xb2, 0x3e, 0x55, 0x53,
+	0x39, 0xff, 0xf9, 0xec, 0x39, 0x2a, 0xdb, 0xa5, 0xfd, 0x8f, 0x19, 0x68, 0x77, 0xc4, 0xfe, 0x91,
+	0x22, 0x0a, 0x2d, 0xca, 0xdd, 0x1c, 0x5d, 0x8d, 0x98, 0x54, 0x15, 0x23, 0x9f, 0x26, 0x8c, 0x5a,
+	0xd2, 0x98, 0xd2, 0xb8, 0x75, 0x24, 0x14, 0x24, 0x4c, 0x26, 0x44, 0x85, 0x27, 0x53, 0x25, 0x99,
+	0xcd, 0xf4, 0xd0, 0xaa, 0x7b, 0x8f, 0xa0, 0x9d, 0x9a, 0x18, 0xaa, 0x32, 0x88, 0x69, 0xa2, 0xa9,
+	0xe5, 0x14, 0x43, 0xa9, 0x62, 0x18, 0xf6, 0x3b, 0xff, 0xf2, 0x4a, 0x69, 0xc2, 0x78, 0x7b, 0xd0,
+	0xd7, 0x06, 0xab, 0xed, 0x3e, 0x0e, 0x98, 0xf9, 0xbc, 0xa6, 0x3f, 0x8f, 0xbf, 0x1f, 0x47, 0xd5,
+	0xd9, 0x36, 0xe9, 0x96, 0x9b, 0xed, 0x7d, 0x68, 0x4a, 0x45, 0x14, 0xee, 0x57, 0x3b, 0x9c, 0x37,
+	0x2f, 0xb8, 0xb8, 0x1a, 0x99, 0x53, 0xbf, 0x21, 0xed, 0x6f, 0x1d, 0xa9, 0x9e, 0x52, 0xd6, 0x3f,
+	0x51, 0x66, 0xd9, 0x83, 0x1e, 0x09, 0x95, 0xc8, 0xa6, 0x0a, 0xf1, 0xda, 0x06, 0x88, 0x86, 0xf1,
+	0x00, 0x61, 0x3a, 0x4b, 0xb6, 0x87, 0xbf, 0xce, 0xcc, 0x32, 0x65, 0x12, 0x09, 0xdc, 0x2e, 0x75,
+	0xbf, 0x6d, 0x45, 0x47, 0x5a, 0x82, 0xa9, 0x83, 0x9d, 0x8f, 0xbf, 0x9d, 0x83, 0x66, 0x79, 0x45,
+	0xf2, 0x3e, 0x78, 0x2e, 0x37, 0x8c, 0x98, 0x0e, 0x5d, 0x72, 0x1d, 0x4b, 0x98, 0xcd, 0xdd, 0xb6,
+	0x92, 0xfb, 0x85, 0xc0, 0xfb, 0x05, 0xac, 0x57, 0xdc, 0x8d, 0x24, 0x89, 0xde, 0x36, 0xb8, 0x49,
+	0xcd, 0xc6, 0x5f, 0x2d, 0xa5, 0x47, 0x28, 0xc4, 0xfd, 0xfa, 0x00, 0x6e, 0xe8, 0x98, 0x3f, 0x22,
+	0x8a, 0x5c, 0x98, 0xf4, 0x98, 0x42, 0xee, 0xb5, 0x54, 0x84, 0xf7, 0x89, 0x22, 0x93, 0x53, 0x9e,
+	0xce, 0xff, 0x7b, 0xfa, 0x30, 0xe9, 0x9c, 0x30, 0x85, 0x4f, 0x60, 0xd1, 0x58, 0xc2, 0xd0, 0xbd,
+	0xdf, 0x6b, 0x17, 0x2d, 0x6c, 0xc5, 0x0f, 0x22, 0xe3, 0x42, 0x52, 0x71, 0x8c, 0xd7, 0x2b, 0x56,
+	0xa5, 0x7d, 0x51, 0x13, 0x55, 0x0a, 0xcb, 0xda, 0x29, 0x2d, 0x6b, 0xbe, 0xc8, 0x83, 0x9d, 0x75,
+	0xbd, 0x0e, 0x57, 0x31, 0x91, 0xbd, 0x5b, 0xb8, 0xf0, 0x06, 0xfa, 0x82, 0x45, 0x9d, 0xbf, 0xde,
+	0x75, 0x8e, 0xfb, 0x33, 0xd8, 0x19, 0x4b, 0xa4, 0x2a, 0x90, 0x26, 0x42, 0x36, 0x47, 0xb2, 0xa8,
+	0x12, 0xfe, 0xb0, 0x6a, 0xc2, 0xf0, 0x53, 0x4c, 0x18, 0xc7, 0x5a, 0x9a, 0xf1, 0x3b, 0xd0, 0xaa,
+	0x5a, 0x41, 0x2c, 0x94, 0xb9, 0xec, 0x5a, 0xf2, 0x97, 0x2b, 0xeb, 0xaf, 0x9b, 0xbd, 0x4f, 0x60,
+	0x4b, 0x8f, 0x52, 0xfb, 0x44, 0x12, 0xb3, 0xef, 0x86, 0x8f, 0xa9, 0x45, 0x1c, 0xb0, 0x4e, 0xe1,
+	0x9f, 0x55, 0xe5, 0x6e, 0xbc, 0x1f, 0xc3, 0xa6, 0xa9, 0x3a, 0x64, 0x82, 0xf7, 0x69, 0x16, 0x64,
+	0xda, 0x6c, 0x86, 0x0a, 0xa0, 0x6b, 0x58, 0x7b, 0x30, 0x62, 0x9f, 0xf7, 0x1d, 0xf0, 0x53, 0x98,
+	0xc3, 0x59, 0x97, 0x9b, 0x57, 0x6f, 0xd4, 0x7e, 0x74, 0x3d, 0x8d, 0x53, 0xf0, 0x2d, 0xc4, 0xee,
+	0x92, 0x3d, 0x98, 0xb7, 0xa6, 0xe3, 0xad, 0xc2, 0xac, 0x49, 0xe9, 0x4c, 0x99, 0xc6, 0xfc, 0xf0,
+	0xb6, 0xa1, 0x41, 0xcf, 0x52, 0xc1, 0xa9, 0x2d, 0xa3, 0xcd, 0xfa, 0xc5, 0x6f, 0x4b, 0xf1, 0x17,
+	0x75, 0x68, 0x8d, 0xde, 0x15, 0xeb, 0x94, 0x40, 0xc6, 0x44, 0x9e, 0x04, 0xbd, 0x8c, 0xb8, 0x32,
+	0x1f, 0xce, 0xd9, 0x54, 0x7e, 0x76, 0x15, 0xb1, 0x0f, 0x2c, 0xd4, 0x06, 0x98, 0x3a, 0x42, 0x19,
+	0xe1, 0x74, 0xe1, 0xcc, 0x54, 0xbe, 0x77, 0x6d, 0x88, 0xf4, 0xbe, 0x85, 0x7a, 0x09, 0xbc, 0x5e,
+	0xc4, 0x55, 0x3a, 0x6d, 0xa0, 0xd5, 0x00, 0xf0, 0x27, 0xba, 0xe6, 0x9b, 0x8e, 0xe9, 0x10, 0x89,
+	0xca, 0x68, 0xb0, 0xdc, 0xdb, 0x1f, 0xc2, 0x7a, 0x3f, 0x23, 0x21, 0xb5, 0x35, 0xb3, 0x80, 0xf2,
+	0xc8, 0xfa, 0xb3, 0xba, 0xa9, 0xe1, 0xa1, 0xd4, 0xd4, 0xee, 0x0e, 0x78, 0x84, 0x9e, 0x41, 0x9f,
+	0x15, 0x5d, 0x22, 0x69, 0x60, 0xbd, 0x02, 0x66, 0x27, 0x53, 0x25, 0xb7, 0xcb, 0x1a, 0xf6, 0x1b,
+	0x44, 0xf9, 0x1a, 0xe4, 0x7d, 0x05, 0xdb, 0xd5, 0x57, 0x00, 0x34, 0x73, 0x9c, 0x39, 0x67, 0x6a,
+	0xaa, 0xd0, 0x62, 0xa3, 0xf2, 0x0a, 0x80, 0x66, 0x86, 0xfb, 0x05, 0x67, 0xce, 0x1a, 0xfe, 0xb7,
+	0x06, 0x2b, 0x13, 0x6e, 0xf8, 0xb5, 0x13, 0xd7, 0x61, 0xc0, 0xf0, 0x73, 0x01, 0x69, 0xaf, 0xd8,
+	0xda, 0xb9, 0xa4, 0x43, 0x20, 0xe9, 0x7d, 0x00, 0xab, 0x8c, 0x33, 0xc5, 0x88, 0xbb, 0xc9, 0x31,
+	0x08, 0x7b, 0xa3, 0xe6, 0x59, 0x19, 0x4e, 0x8f, 0x81, 0xe8, 0xd3, 0x38, 0xa2, 0x21, 0x39, 0x37,
+	0x89, 0xcc, 0x54, 0x75, 0x09, 0xd4, 0xc7, 0x9c, 0xe5, 0x35, 0x58, 0x72, 0xe5, 0xf8, 0xea, 0x6a,
+	0x2c, 0xda, 0x46, 0xb3, 0x0c, 0xc7, 0xb0, 0x99, 0x2b, 0x56, 0x6c, 0xef, 0xae, 0xe0, 0xb9, 0x74,
+	0xce, 0x79, 0x9a, 0xd5, 0x58, 0xaf, 0xa0, 0xef, 0x69, 0xb0, 0xf5, 0xce, 0x5f, 0xc1, 0x36, 0xd6,
+	0x06, 0x42, 0x61, 0xaa, 0x0f, 0xc3, 0xcc, 0x53, 0x2d, 0x8a, 0xc6, 0xef, 0x5b, 0x78, 0x95, 0x3a,
+	0x80, 0xeb, 0x98, 0xf0, 0x91, 0x8b, 0xd8, 0xe7, 0xa7, 0x49, 0x1b, 0x2c, 0xc5, 0x84, 0x0e, 0xec,
+	0xaa, 0xff, 0xb6, 0x0e, 0xab, 0x93, 0x1e, 0x5e, 0xe8, 0x4f, 0x93, 0x8a, 0x74, 0x59, 0xcc, 0xd4,
+	0x79, 0xf0, 0x9d, 0xe0, 0x34, 0x88, 0xcd, 0xb5, 0xa1, 0xc8, 0xf9, 0x74, 0xbe, 0x60, 0xa3, 0xc0,
+	0x7f, 0x2d, 0x38, 0x7d, 0x8a, 0x77, 0x89, 0x1a, 0x3c, 0x81, 0x3a, 0x4f, 0xd3, 0x82, 0xfa, 0xca,
+	0x4f, 0xa6, 0x7e, 0xa1, 0xd1, 0x86, 0xfa, 0x21, 0xb4, 0xb0, 0x62, 0x1c, 0xd0, 0x98, 0x48, 0x9d,
+	0xe7, 0xaa, 0xf3, 0x29, 0x43, 0x33, 0x8d, 0x3a, 0x28, 0x40, 0xde, 0xe7, 0xb0, 0x53, 0xb5, 0x18,
+	0x7b, 0xa7, 0x5b, 0x14, 0x6f, 0x8d, 0x91, 0x6d, 0x55, 0x54, 0x4c, 0x15, 0xb0, 0x28, 0xe0, 0xbe,
+	0x0f, 0x2b, 0x09, 0x33, 0x57, 0x9b, 0xf8, 0xa0, 0xc7, 0x16, 0xb2, 0x4d, 0xe8, 0xd3, 0x4a, 0x18,
+	0xef, 0xd0, 0x0c, 0x6f, 0x59, 0x4c, 0xfd, 0xfa, 0x0e, 0xac, 0xa2, 0x9f, 0x18, 0xd5, 0xb7, 0x17,
+	0x0a, 0x5a, 0x36, 0x0c, 0xb8, 0xd8, 0x1b, 0xcd, 0x5f, 0xec, 0x8d, 0x3e, 0x87, 0x6b, 0x43, 0xa0,
+	0xd1, 0xde, 0x1a, 0x08, 0xdd, 0xac, 0x40, 0x87, 0x3a, 0xb5, 0x26, 0xf3, 0x77, 0x75, 0x58, 0x9b,
+	0xf8, 0x92, 0xe6, 0xc7, 0x0b, 0x29, 0x33, 0x3f, 0x56, 0x48, 0x79, 0x0c, 0xde, 0xcb, 0x2e, 0x62,
+	0x18, 0x4f, 0x73, 0x65, 0x46, 0x37, 0x95, 0x49, 0x2c, 0xbf, 0xec, 0x76, 0x68, 0xf6, 0x58, 0xa3,
+	0x70, 0xc4, 0xde, 0x17, 0xb0, 0x62, 0xa9, 0x44, 0xae, 0x4a, 0xae, 0x69, 0xac, 0xa1, 0x85, 0x5c,
+	0x5f, 0x22, 0xcc, 0x90, 0xdd, 0x81, 0x95, 0x6a, 0x6d, 0x43, 0x9a, 0xaf, 0xb3, 0x66, 0xe0, 0x0d,
+	0x89, 0xf0, 0x9b, 0x4c, 0x1d, 0xbe, 0x0a, 0xb0, 0xa1, 0xa8, 0xbd, 0xf6, 0x31, 0x76, 0xb0, 0x35,
+	0xa4, 0x62, 0xe2, 0x51, 0x7b, 0x61, 0xf4, 0x09, 0x6c, 0x4d, 0xe8, 0x30, 0x08, 0xf3, 0x6c, 0xe0,
+	0xac, 0x62, 0x63, 0xbc, 0xdb, 0x7d, 0x2d, 0xf6, 0x1e, 0xc1, 0x8d, 0x84, 0x71, 0x96, 0xe4, 0x49,
+	0xf5, 0xd6, 0x7f, 0x48, 0x1b, 0xad, 0x64, 0xc9, 0xdf, 0xb5, 0x7a, 0xe5, 0x95, 0x7f, 0xb5, 0x26,
+	0x24, 0xb1, 0xd4, 0x8c, 0xd7, 0xc8, 0x76, 0x86, 0x2a, 0xcb, 0x69, 0x8d, 0x65, 0x0d, 0x6f, 0x88,
+	0x9d, 0xd8, 0xad, 0xa4, 0xb5, 0x94, 0x7f, 0xb8, 0x02, 0x6b, 0x13, 0xdf, 0x43, 0x79, 0x0f, 0xe1,
+	0x06, 0x3d, 0x4b, 0x69, 0xa8, 0x0d, 0xa5, 0x1a, 0x0e, 0x9a, 0x0e, 0x8c, 0x21, 0x1b, 0x63, 0xb9,
+	0xee, 0xf4, 0xaa, 0x44, 0xba, 0x23, 0x63, 0xd2, 0x07, 0xb0, 0x4c, 0xe2, 0xf4, 0x84, 0x54, 0xce,
+	0xfb, 0x69, 0xac, 0xe5, 0x2a, 0x82, 0xca, 0xc3, 0x7d, 0x1f, 0xae, 0x0e, 0x47, 0x28, 0x53, 0xd9,
+	0xc9, 0xd2, 0x50, 0x60, 0xa2, 0xd7, 0x2c, 0x4f, 0xfb, 0x19, 0x89, 0xf0, 0x62, 0x5f, 0xd1, 0xb0,
+	0xe2, 0x3a, 0xec, 0x15, 0xd6, 0x86, 0x55, 0xe8, 0x14, 0xf2, 0xa1, 0xdb, 0x83, 0x7f, 0x9d, 0x81,
+	0xb5, 0x89, 0x8f, 0xbb, 0xbc, 0x5f, 0xc1, 0xf6, 0x25, 0x17, 0xe4, 0x26, 0xf0, 0xdb, 0xe4, 0x17,
+	0xdd, 0x88, 0x7f, 0x06, 0x3b, 0x63, 0x68, 0xed, 0x9e, 0x4e, 0x30, 0x08, 0xb0, 0x89, 0xe4, 0x28,
+	0xfc, 0x90, 0xf1, 0x47, 0x28, 0xd7, 0x39, 0xd8, 0x84, 0xab, 0xee, 0x1a, 0x5e, 0x75, 0xb7, 0xfb,
+	0xa3, 0x77, 0xdc, 0x2e, 0xba, 0x9c, 0x81, 0xb5, 0x89, 0x8f, 0xc8, 0xbc, 0xf7, 0xc0, 0xcb, 0xb9,
+	0x62, 0xb1, 0xf5, 0x0b, 0x76, 0x10, 0xe6, 0x1b, 0x5a, 0x28, 0x41, 0x23, 0xb2, 0x9d, 0x7f, 0x0e,
+	0x3b, 0xee, 0x96, 0xb3, 0xf2, 0x8e, 0xad, 0x18, 0xc5, 0x15, 0x1c, 0xc5, 0x96, 0x55, 0x29, 0x3b,
+	0x1c, 0x19, 0xcd, 0xbf, 0x5d, 0x81, 0x8d, 0x0b, 0x1e, 0x9b, 0x79, 0x7f, 0x02, 0xef, 0x70, 0x7a,
+	0x3a, 0x54, 0x5f, 0xcd, 0x68, 0x9f, 0x49, 0x65, 0x2f, 0x11, 0x4c, 0xee, 0x3a, 0x34, 0xcc, 0x37,
+	0x38, 0x3d, 0xad, 0xd0, 0xf9, 0x15, 0x75, 0xcc, 0x67, 0xed, 0xd8, 0xef, 0xc1, 0x75, 0xfc, 0x46,
+	0x3a, 0x5c, 0xbd, 0x1d, 0x1d, 0xfd, 0x8e, 0x55, 0xaa, 0x0e, 0xd0, 0xa9, 0xa0, 0x55, 0x49, 0x3a,
+	0x8c, 0xd7, 0x1f, 0x1b, 0x33, 0x9b, 0xe7, 0x37, 0xfc, 0x8d, 0x5c, 0xd2, 0x2a, 0xd6, 0x89, 0xbd,
+	0x63, 0x78, 0x7b, 0x22, 0x2e, 0x98, 0x30, 0xff, 0xc6, 0x40, 0x5f, 0x4f, 0x27, 0xf0, 0xbc, 0x18,
+	0x59, 0x13, 0x3b, 0xa7, 0x01, 0x6c, 0x5d, 0xf8, 0xa4, 0x4e, 0x1b, 0xac, 0x5b, 0xb6, 0xf2, 0xc1,
+	0x5e, 0xf1, 0xdd, 0x33, 0xe6, 0x99, 0x84, 0xd5, 0x28, 0x58, 0x46, 0x16, 0xed, 0x77, 0x75, 0x68,
+	0x8d, 0x3e, 0x57, 0xd3, 0x01, 0x5f, 0x44, 0xd3, 0x58, 0x14, 0x77, 0x73, 0x66, 0x45, 0x16, 0x4d,
+	0xa3, 0xd9, 0x4e, 0xda, 0x2d, 0x64, 0xb4, 0x97, 0x4b, 0x0c, 0x95, 0xcd, 0xf5, 0xc3, 0x54, 0x6e,
+	0xc1, 0x82, 0xdc, 0xcd, 0xc3, 0x31, 0x6c, 0x72, 0x51, 0x4e, 0xbd, 0xc9, 0x69, 0x2d, 0xdf, 0x34,
+	0x0e, 0x62, 0x9d, 0x8b, 0x4e, 0x15, 0xec, 0x78, 0x1f, 0x42, 0xe5, 0xd1, 0x5d, 0x20, 0x4f, 0x48,
+	0x36, 0xdd, 0x35, 0xda, 0x72, 0x89, 0x3a, 0xd2, 0x20, 0xef, 0x33, 0x58, 0x38, 0xad, 0xf8, 0x81,
+	0x69, 0x62, 0x59, 0x38, 0x2d, 0xfd, 0xc2, 0x0a, 0xcc, 0x0e, 0xb4, 0x23, 0xb0, 0x17, 0x64, 0xf5,
+	0xc1, 0x21, 0xe3, 0x3a, 0x1c, 0x0f, 0x49, 0xfa, 0x53, 0xc2, 0xcc, 0x66, 0x48, 0x52, 0x1b, 0xb6,
+	0xbe, 0x0d, 0x2d, 0x17, 0xfd, 0x17, 0xb5, 0x86, 0x06, 0x56, 0xb0, 0xae, 0xda, 0xf6, 0x43, 0x5b,
+	0x6e, 0xe8, 0xc1, 0x4d, 0x7d, 0xb6, 0x18, 0xad, 0x81, 0x30, 0xcf, 0x11, 0x46, 0x1f, 0x29, 0x4d,
+	0x73, 0x3b, 0x76, 0x3d, 0x21, 0x67, 0x48, 0x7a, 0x8c, 0x24, 0x23, 0xaf, 0x94, 0xac, 0x29, 0x85,
+	0xb0, 0xe1, 0xde, 0x64, 0xee, 0xa5, 0x69, 0x26, 0x06, 0x34, 0x3a, 0xa6, 0x99, 0xd4, 0x6e, 0xdb,
+	0x83, 0x3a, 0x27, 0x09, 0xb5, 0x85, 0x36, 0xfc, 0xdb, 0x5b, 0x87, 0xb9, 0x2e, 0xe3, 0x24, 0x33,
+	0x66, 0xd3, 0xf4, 0xed, 0x2f, 0xdd, 0x2e, 0x4f, 0xc8, 0xdd, 0x5f, 0x7e, 0x84, 0xcb, 0xdf, 0xf4,
+	0xed, 0x2f, 0xdb, 0xc9, 0xdf, 0xcf, 0xc3, 0xea, 0xa4, 0x97, 0x9f, 0xde, 0x75, 0x00, 0xed, 0x6e,
+	0xed, 0xa3, 0x16, 0x73, 0xb0, 0x35, 0x13, 0xe6, 0x5e, 0xaa, 0x68, 0x31, 0x39, 0xab, 0xbe, 0x79,
+	0xd1, 0x62, 0x72, 0x66, 0xc5, 0x3f, 0x07, 0x7d, 0xca, 0xda, 0xf7, 0x90, 0xd5, 0x13, 0xb2, 0x86,
+	0x87, 0xb8, 0x97, 0x90, 0x33, 0xd3, 0x5b, 0x79, 0x2c, 0x5e, 0x07, 0xe8, 0x67, 0x22, 0x4f, 0x4d,
+	0xe9, 0xcb, 0x3c, 0x1c, 0x6c, 0x62, 0x0b, 0xd6, 0xbb, 0x3e, 0x01, 0xe7, 0x30, 0x83, 0x30, 0xa3,
+	0xf8, 0xcc, 0xad, 0xdc, 0x9b, 0xb3, 0xb8, 0x37, 0x37, 0xac, 0xc2, 0xbe, 0x91, 0x97, 0xfe, 0xe8,
+	0x55, 0x58, 0x18, 0x8f, 0x50, 0x41, 0x95, 0xa1, 0xe9, 0x57, 0xd0, 0x26, 0x76, 0x8a, 0x83, 0x81,
+	0x99, 0x63, 0x1d, 0x6f, 0xd4, 0x2e, 0x7c, 0x04, 0x7c, 0xc1, 0xc2, 0xf8, 0x2d, 0x32, 0xdc, 0x20,
+	0xbd, 0x1d, 0xd0, 0xd3, 0x12, 0x70, 0xc1, 0x6d, 0xb4, 0xba, 0xe4, 0x37, 0x12, 0x72, 0xf6, 0x4c,
+	0xff, 0xd6, 0x1f, 0x55, 0xbc, 0xd4, 0x2d, 0x2e, 0x1f, 0x87, 0x4b, 0x4f, 0x1b, 0x4e, 0xc1, 0x5d,
+	0x31, 0xba, 0x82, 0xcc, 0x53, 0x78, 0xcd, 0x55, 0x19, 0xcb, 0x37, 0x0b, 0x92, 0x92, 0x38, 0x30,
+	0x01, 0x33, 0xf6, 0x68, 0x1e, 0x65, 0x2f, 0xf9, 0xaf, 0x5a, 0xd5, 0x22, 0xee, 0x39, 0xa2, 0x24,
+	0x7e, 0xa8, 0xf5, 0x70, 0x20, 0xf8, 0xfc, 0xf2, 0x52, 0x36, 0x49, 0x43, 0xc1, 0x23, 0x57, 0x92,
+	0xba, 0x71, 0x21, 0xdd, 0x91, 0xd1, 0xd3, 0x29, 0x38, 0x2e, 0x13, 0x0d, 0x8a, 0x0f, 0xec, 0x51,
+	0xf3, 0x82, 0xaf, 0xee, 0xb7, 0x8d, 0xc8, 0x4d, 0xe2, 0x03, 0x4a, 0xbd, 0x5b, 0xb0, 0x84, 0x4f,
+	0x8a, 0x69, 0x66, 0xa7, 0x6a, 0x09, 0x35, 0x17, 0x7a, 0x54, 0x87, 0x97, 0x66, 0xb6, 0xde, 0x2a,
+	0x3d, 0xa4, 0x62, 0x09, 0x15, 0xb9, 0xb2, 0xf7, 0xa3, 0xce, 0x07, 0x3e, 0x37, 0xad, 0xe6, 0x42,
+	0x9d, 0x86, 0xb9, 0xb9, 0x61, 0xb6, 0xaa, 0xcb, 0xee, 0x42, 0xdd, 0x0a, 0x9c, 0xf2, 0x5b, 0xb0,
+	0x3c, 0x7a, 0x31, 0xd9, 0xc2, 0x8f, 0xbc, 0x3a, 0x72, 0xd5, 0x78, 0x17, 0xd6, 0x06, 0x42, 0x55,
+	0xca, 0x34, 0xce, 0xdf, 0xb4, 0x51, 0x7d, 0x45, 0x0b, 0x0b, 0x3f, 0x65, 0x7d, 0xcb, 0x01, 0xb8,
+	0xa9, 0x0a, 0x48, 0xae, 0x84, 0x99, 0x51, 0x3a, 0xa0, 0xd9, 0x79, 0xc0, 0xdd, 0x0a, 0x79, 0x08,
+	0xdf, 0xb1, 0x7a, 0x7b, 0xb9, 0x12, 0x7a, 0x36, 0x0f, 0xb4, 0xd2, 0x33, 0xb3, 0x3a, 0x76, 0xaf,
+	0xfe, 0xf5, 0x0c, 0x34, 0x8b, 0x07, 0xd5, 0x3a, 0xff, 0xd2, 0x1b, 0xb4, 0x4f, 0xa4, 0x31, 0xeb,
+	0x80, 0xf7, 0x05, 0x7f, 0x49, 0xec, 0x56, 0x6d, 0x27, 0x8c, 0x3f, 0x24, 0x12, 0xcd, 0xfb, 0x19,
+	0x0a, 0xf4, 0x92, 0x60, 0xc2, 0x56, 0xf9, 0xda, 0x3e, 0x71, 0xcf, 0x86, 0x31, 0x5f, 0x2b, 0xaf,
+	0xb5, 0x1e, 0x12, 0xe9, 0xbd, 0x03, 0x6d, 0x24, 0xb7, 0x0f, 0xb3, 0x42, 0xdc, 0xe9, 0xa6, 0xa4,
+	0x7c, 0xb5, 0x4f, 0xf4, 0xc6, 0xed, 0x88, 0x70, 0x5f, 0xb7, 0x9a, 0xf1, 0xdd, 0xfb, 0xf2, 0x77,
+	0xdf, 0xef, 0xce, 0xfc, 0xfe, 0xfb, 0xdd, 0x99, 0x7f, 0xff, 0x7e, 0x77, 0xe6, 0xaf, 0x7e, 0xd8,
+	0x7d, 0xe5, 0xf7, 0x3f, 0xec, 0xbe, 0xf2, 0x87, 0x1f, 0x76, 0x5f, 0xf9, 0xfa, 0x97, 0x7d, 0xa6,
+	0x4e, 0xf2, 0xee, 0xed, 0x50, 0x24, 0x77, 0xd2, 0x4c, 0x44, 0x79, 0xa8, 0x64, 0xc8, 0x46, 0xfe,
+	0x47, 0x4f, 0xf5, 0x5d, 0xb5, 0x3a, 0x4f, 0xa9, 0xec, 0xce, 0xe1, 0x7f, 0xc2, 0xf9, 0xf0, 0xff,
+	0x02, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xdc, 0x35, 0x36, 0x01, 0x34, 0x00, 0x00,
 }
 
 func (this *Params) Equal(that interface{}) bool {
@@ -2782,6 +2908,51 @@ func (this *Params) Equal(that interface{}) bool {
 	if !this.DelegationParams.Equal(that1.DelegationParams) {
 		return false
 	}
+	if !this.MaintenanceParams.Equal(that1.MaintenanceParams) {
+		return false
+	}
+	return true
+}
+func (this *MaintenanceParams) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*MaintenanceParams)
+	if !ok {
+		that2, ok := that.(MaintenanceParams)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.MaintenanceEnabled != that1.MaintenanceEnabled {
+		return false
+	}
+	if this.MaintenanceMinScheduleLeadBlocks != that1.MaintenanceMinScheduleLeadBlocks {
+		return false
+	}
+	if this.MaintenanceMaxWindowBlocks != that1.MaintenanceMaxWindowBlocks {
+		return false
+	}
+	if this.MaintenanceMaxConcurrentValidators != that1.MaintenanceMaxConcurrentValidators {
+		return false
+	}
+	if this.MaintenanceMaxConcurrentPowerBps != that1.MaintenanceMaxConcurrentPowerBps {
+		return false
+	}
+	if this.MaintenanceCreditCapBlocks != that1.MaintenanceCreditCapBlocks {
+		return false
+	}
+	if this.MaintenanceCreditEarnPerSuccessfulEpochBlocks != that1.MaintenanceCreditEarnPerSuccessfulEpochBlocks {
+		return false
+	}
 	return true
 }
 func (this *TokenomicsParams) Equal(that interface{}) bool {
@@ -3754,6 +3925,20 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.MaintenanceParams != nil {
+		{
+			size, err := m.MaintenanceParams.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintParams(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x8a
+	}
 	if m.DelegationParams != nil {
 		{
 			size, err := m.DelegationParams.MarshalToSizedBuffer(dAtA[:i])
@@ -3951,6 +4136,69 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *MaintenanceParams) 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 *MaintenanceParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MaintenanceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.MaintenanceCreditEarnPerSuccessfulEpochBlocks != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.MaintenanceCreditEarnPerSuccessfulEpochBlocks))
+		i--
+		dAtA[i] = 0x38
+	}
+	if m.MaintenanceCreditCapBlocks != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.MaintenanceCreditCapBlocks))
+		i--
+		dAtA[i] = 0x30
+	}
+	if m.MaintenanceMaxConcurrentPowerBps != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.MaintenanceMaxConcurrentPowerBps))
+		i--
+		dAtA[i] = 0x28
+	}
+	if m.MaintenanceMaxConcurrentValidators != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.MaintenanceMaxConcurrentValidators))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.MaintenanceMaxWindowBlocks != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.MaintenanceMaxWindowBlocks))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.MaintenanceMinScheduleLeadBlocks != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.MaintenanceMinScheduleLeadBlocks))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.MaintenanceEnabled {
+		i--
+		if m.MaintenanceEnabled {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *GenesisOnlyParams) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -5901,6 +6149,40 @@ func (m *Params) Size() (n int) {
 		l = m.DelegationParams.Size()
 		n += 2 + l + sovParams(uint64(l))
 	}
+	if m.MaintenanceParams != nil {
+		l = m.MaintenanceParams.Size()
+		n += 2 + l + sovParams(uint64(l))
+	}
+	return n
+}
+
+func (m *MaintenanceParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.MaintenanceEnabled {
+		n += 2
+	}
+	if m.MaintenanceMinScheduleLeadBlocks != 0 {
+		n += 1 + sovParams(uint64(m.MaintenanceMinScheduleLeadBlocks))
+	}
+	if m.MaintenanceMaxWindowBlocks != 0 {
+		n += 1 + sovParams(uint64(m.MaintenanceMaxWindowBlocks))
+	}
+	if m.MaintenanceMaxConcurrentValidators != 0 {
+		n += 1 + sovParams(uint64(m.MaintenanceMaxConcurrentValidators))
+	}
+	if m.MaintenanceMaxConcurrentPowerBps != 0 {
+		n += 1 + sovParams(uint64(m.MaintenanceMaxConcurrentPowerBps))
+	}
+	if m.MaintenanceCreditCapBlocks != 0 {
+		n += 1 + sovParams(uint64(m.MaintenanceCreditCapBlocks))
+	}
+	if m.MaintenanceCreditEarnPerSuccessfulEpochBlocks != 0 {
+		n += 1 + sovParams(uint64(m.MaintenanceCreditEarnPerSuccessfulEpochBlocks))
+	}
 	return n
 }
 
@@ -7304,6 +7586,226 @@ func (m *Params) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 17:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceParams", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthParams
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthParams
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.MaintenanceParams == nil {
+				m.MaintenanceParams = &MaintenanceParams{}
+			}
+			if err := m.MaintenanceParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipParams(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthParams
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MaintenanceParams) 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 ErrIntOverflowParams
+			}
+			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: MaintenanceParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MaintenanceParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceEnabled", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.MaintenanceEnabled = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMinScheduleLeadBlocks", wireType)
+			}
+			m.MaintenanceMinScheduleLeadBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaintenanceMinScheduleLeadBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMaxWindowBlocks", wireType)
+			}
+			m.MaintenanceMaxWindowBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaintenanceMaxWindowBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMaxConcurrentValidators", wireType)
+			}
+			m.MaintenanceMaxConcurrentValidators = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaintenanceMaxConcurrentValidators |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceMaxConcurrentPowerBps", wireType)
+			}
+			m.MaintenanceMaxConcurrentPowerBps = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaintenanceMaxConcurrentPowerBps |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceCreditCapBlocks", wireType)
+			}
+			m.MaintenanceCreditCapBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaintenanceCreditCapBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaintenanceCreditEarnPerSuccessfulEpochBlocks", wireType)
+			}
+			m.MaintenanceCreditEarnPerSuccessfulEpochBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaintenanceCreditEarnPerSuccessfulEpochBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipParams(dAtA[iNdEx:])
diff --git a/inference-chain/x/inference/types/poc_delegation.pb.go b/inference-chain/x/inference/types/poc_delegation.pb.go
index 91be57572d..a6488974dd 100644
--- a/inference-chain/x/inference/types/poc_delegation.pb.go
+++ b/inference-chain/x/inference/types/poc_delegation.pb.go
@@ -482,6 +482,186 @@ func (m *BootstrapDelegationSnapshot) GetPreeligibility() []*BootstrapModelPreEl
 	return nil
 }
 
+type DelegationRewardTransfer struct {
+	ModelId string   `protobuf:"bytes,1,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
+	From    string   `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
+	To      string   `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
+	Share   *Decimal `protobuf:"bytes,4,opt,name=share,proto3" json:"share,omitempty"`
+}
+
+func (m *DelegationRewardTransfer) Reset()         { *m = DelegationRewardTransfer{} }
+func (m *DelegationRewardTransfer) String() string { return proto.CompactTextString(m) }
+func (*DelegationRewardTransfer) ProtoMessage()    {}
+func (*DelegationRewardTransfer) Descriptor() ([]byte, []int) {
+	return fileDescriptor_67ab536bbbc39f86, []int{7}
+}
+func (m *DelegationRewardTransfer) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DelegationRewardTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DelegationRewardTransfer.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 *DelegationRewardTransfer) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DelegationRewardTransfer.Merge(m, src)
+}
+func (m *DelegationRewardTransfer) XXX_Size() int {
+	return m.Size()
+}
+func (m *DelegationRewardTransfer) XXX_DiscardUnknown() {
+	xxx_messageInfo_DelegationRewardTransfer.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DelegationRewardTransfer proto.InternalMessageInfo
+
+func (m *DelegationRewardTransfer) GetModelId() string {
+	if m != nil {
+		return m.ModelId
+	}
+	return ""
+}
+
+func (m *DelegationRewardTransfer) GetFrom() string {
+	if m != nil {
+		return m.From
+	}
+	return ""
+}
+
+func (m *DelegationRewardTransfer) GetTo() string {
+	if m != nil {
+		return m.To
+	}
+	return ""
+}
+
+func (m *DelegationRewardTransfer) GetShare() *Decimal {
+	if m != nil {
+		return m.Share
+	}
+	return nil
+}
+
+type DelegationRewardPenalty struct {
+	Participant     string   `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	PenaltyFraction *Decimal `protobuf:"bytes,2,opt,name=penalty_fraction,json=penaltyFraction,proto3" json:"penalty_fraction,omitempty"`
+}
+
+func (m *DelegationRewardPenalty) Reset()         { *m = DelegationRewardPenalty{} }
+func (m *DelegationRewardPenalty) String() string { return proto.CompactTextString(m) }
+func (*DelegationRewardPenalty) ProtoMessage()    {}
+func (*DelegationRewardPenalty) Descriptor() ([]byte, []int) {
+	return fileDescriptor_67ab536bbbc39f86, []int{8}
+}
+func (m *DelegationRewardPenalty) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DelegationRewardPenalty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DelegationRewardPenalty.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 *DelegationRewardPenalty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DelegationRewardPenalty.Merge(m, src)
+}
+func (m *DelegationRewardPenalty) XXX_Size() int {
+	return m.Size()
+}
+func (m *DelegationRewardPenalty) XXX_DiscardUnknown() {
+	xxx_messageInfo_DelegationRewardPenalty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DelegationRewardPenalty proto.InternalMessageInfo
+
+func (m *DelegationRewardPenalty) GetParticipant() string {
+	if m != nil {
+		return m.Participant
+	}
+	return ""
+}
+
+func (m *DelegationRewardPenalty) GetPenaltyFraction() *Decimal {
+	if m != nil {
+		return m.PenaltyFraction
+	}
+	return nil
+}
+
+type DelegationRewardTransferSnapshot struct {
+	EpochIndex uint64                      `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	Transfers  []*DelegationRewardTransfer `protobuf:"bytes,2,rep,name=transfers,proto3" json:"transfers,omitempty"`
+	Penalties  []*DelegationRewardPenalty  `protobuf:"bytes,3,rep,name=penalties,proto3" json:"penalties,omitempty"`
+}
+
+func (m *DelegationRewardTransferSnapshot) Reset()         { *m = DelegationRewardTransferSnapshot{} }
+func (m *DelegationRewardTransferSnapshot) String() string { return proto.CompactTextString(m) }
+func (*DelegationRewardTransferSnapshot) ProtoMessage()    {}
+func (*DelegationRewardTransferSnapshot) Descriptor() ([]byte, []int) {
+	return fileDescriptor_67ab536bbbc39f86, []int{9}
+}
+func (m *DelegationRewardTransferSnapshot) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DelegationRewardTransferSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DelegationRewardTransferSnapshot.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 *DelegationRewardTransferSnapshot) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DelegationRewardTransferSnapshot.Merge(m, src)
+}
+func (m *DelegationRewardTransferSnapshot) XXX_Size() int {
+	return m.Size()
+}
+func (m *DelegationRewardTransferSnapshot) XXX_DiscardUnknown() {
+	xxx_messageInfo_DelegationRewardTransferSnapshot.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DelegationRewardTransferSnapshot proto.InternalMessageInfo
+
+func (m *DelegationRewardTransferSnapshot) GetEpochIndex() uint64 {
+	if m != nil {
+		return m.EpochIndex
+	}
+	return 0
+}
+
+func (m *DelegationRewardTransferSnapshot) GetTransfers() []*DelegationRewardTransfer {
+	if m != nil {
+		return m.Transfers
+	}
+	return nil
+}
+
+func (m *DelegationRewardTransferSnapshot) GetPenalties() []*DelegationRewardPenalty {
+	if m != nil {
+		return m.Penalties
+	}
+	return nil
+}
+
 type MsgSetPoCDelegation struct {
 	Sender     string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
 	ModelId    string `protobuf:"bytes,2,opt,name=model_id,json=modelId,proto3" json:"model_id,omitempty"`
@@ -492,7 +672,7 @@ func (m *MsgSetPoCDelegation) Reset()         { *m = MsgSetPoCDelegation{} }
 func (m *MsgSetPoCDelegation) String() string { return proto.CompactTextString(m) }
 func (*MsgSetPoCDelegation) ProtoMessage()    {}
 func (*MsgSetPoCDelegation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{7}
+	return fileDescriptor_67ab536bbbc39f86, []int{10}
 }
 func (m *MsgSetPoCDelegation) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -549,7 +729,7 @@ func (m *MsgSetPoCDelegationResponse) Reset()         { *m = MsgSetPoCDelegation
 func (m *MsgSetPoCDelegationResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSetPoCDelegationResponse) ProtoMessage()    {}
 func (*MsgSetPoCDelegationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{8}
+	return fileDescriptor_67ab536bbbc39f86, []int{11}
 }
 func (m *MsgSetPoCDelegationResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -587,7 +767,7 @@ func (m *MsgRefusePoCDelegation) Reset()         { *m = MsgRefusePoCDelegation{}
 func (m *MsgRefusePoCDelegation) String() string { return proto.CompactTextString(m) }
 func (*MsgRefusePoCDelegation) ProtoMessage()    {}
 func (*MsgRefusePoCDelegation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{9}
+	return fileDescriptor_67ab536bbbc39f86, []int{12}
 }
 func (m *MsgRefusePoCDelegation) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -637,7 +817,7 @@ func (m *MsgRefusePoCDelegationResponse) Reset()         { *m = MsgRefusePoCDele
 func (m *MsgRefusePoCDelegationResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRefusePoCDelegationResponse) ProtoMessage()    {}
 func (*MsgRefusePoCDelegationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{10}
+	return fileDescriptor_67ab536bbbc39f86, []int{13}
 }
 func (m *MsgRefusePoCDelegationResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -675,7 +855,7 @@ func (m *MsgDeclarePoCIntent) Reset()         { *m = MsgDeclarePoCIntent{} }
 func (m *MsgDeclarePoCIntent) String() string { return proto.CompactTextString(m) }
 func (*MsgDeclarePoCIntent) ProtoMessage()    {}
 func (*MsgDeclarePoCIntent) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{11}
+	return fileDescriptor_67ab536bbbc39f86, []int{14}
 }
 func (m *MsgDeclarePoCIntent) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -725,7 +905,7 @@ func (m *MsgDeclarePoCIntentResponse) Reset()         { *m = MsgDeclarePoCIntent
 func (m *MsgDeclarePoCIntentResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgDeclarePoCIntentResponse) ProtoMessage()    {}
 func (*MsgDeclarePoCIntentResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{12}
+	return fileDescriptor_67ab536bbbc39f86, []int{15}
 }
 func (m *MsgDeclarePoCIntentResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -763,7 +943,7 @@ func (m *QueryPoCDelegationRequest) Reset()         { *m = QueryPoCDelegationReq
 func (m *QueryPoCDelegationRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPoCDelegationRequest) ProtoMessage()    {}
 func (*QueryPoCDelegationRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{13}
+	return fileDescriptor_67ab536bbbc39f86, []int{16}
 }
 func (m *QueryPoCDelegationRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -816,7 +996,7 @@ func (m *QueryPoCDelegationResponse) Reset()         { *m = QueryPoCDelegationRe
 func (m *QueryPoCDelegationResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPoCDelegationResponse) ProtoMessage()    {}
 func (*QueryPoCDelegationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_67ab536bbbc39f86, []int{14}
+	return fileDescriptor_67ab536bbbc39f86, []int{17}
 }
 func (m *QueryPoCDelegationResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -874,6 +1054,9 @@ func init() {
 	proto.RegisterType((*DelegationSnapshot)(nil), "inference.inference.DelegationSnapshot")
 	proto.RegisterType((*BootstrapModelPreEligibility)(nil), "inference.inference.BootstrapModelPreEligibility")
 	proto.RegisterType((*BootstrapDelegationSnapshot)(nil), "inference.inference.BootstrapDelegationSnapshot")
+	proto.RegisterType((*DelegationRewardTransfer)(nil), "inference.inference.DelegationRewardTransfer")
+	proto.RegisterType((*DelegationRewardPenalty)(nil), "inference.inference.DelegationRewardPenalty")
+	proto.RegisterType((*DelegationRewardTransferSnapshot)(nil), "inference.inference.DelegationRewardTransferSnapshot")
 	proto.RegisterType((*MsgSetPoCDelegation)(nil), "inference.inference.MsgSetPoCDelegation")
 	proto.RegisterType((*MsgSetPoCDelegationResponse)(nil), "inference.inference.MsgSetPoCDelegationResponse")
 	proto.RegisterType((*MsgRefusePoCDelegation)(nil), "inference.inference.MsgRefusePoCDelegation")
@@ -889,56 +1072,66 @@ func init() {
 }
 
 var fileDescriptor_67ab536bbbc39f86 = []byte{
-	// 778 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0x49, 0x6f, 0xdb, 0x46,
-	0x14, 0x36, 0x25, 0x2f, 0xf2, 0x93, 0x97, 0x7a, 0x6c, 0xb8, 0xf4, 0x52, 0x5a, 0x65, 0x0b, 0xd4,
-	0x30, 0x50, 0xa9, 0xee, 0x72, 0x69, 0x81, 0x1e, 0x6c, 0x17, 0xb0, 0x0f, 0x72, 0x55, 0xda, 0x75,
-	0x96, 0x0b, 0x41, 0x53, 0xcf, 0xe4, 0x20, 0x14, 0x87, 0x99, 0x19, 0xc9, 0xf1, 0x35, 0xbf, 0x20,
-	0x3f, 0x25, 0x3f, 0x21, 0xc7, 0x1c, 0x7d, 0x4c, 0x4e, 0x09, 0xec, 0x43, 0xf2, 0x33, 0x02, 0xcd,
-	0x50, 0xd4, 0x12, 0x59, 0x46, 0xa0, 0x43, 0x4e, 0x9a, 0x79, 0xdf, 0x9b, 0xef, 0x2d, 0xf3, 0xcd,
-	0x13, 0x61, 0x9b, 0xc6, 0x17, 0xc8, 0x31, 0xf6, 0xb1, 0xd2, 0x5d, 0x25, 0xcc, 0x77, 0xeb, 0x18,
-	0x61, 0xe0, 0x49, 0xca, 0xe2, 0x72, 0xc2, 0x99, 0x64, 0x64, 0x39, 0xc3, 0xcb, 0xd9, 0x6a, 0xfd,
-	0x5b, 0x9f, 0x89, 0x06, 0x13, 0x95, 0x86, 0x08, 0x2a, 0xad, 0xdd, 0xf6, 0x8f, 0xf6, 0x5e, 0x5f,
-	0xd3, 0x80, 0xab, 0x76, 0x15, 0xbd, 0xd1, 0x90, 0x4d, 0x61, 0xbe, 0xc6, 0xf6, 0x0f, 0x32, 0x7e,
-	0xb2, 0x06, 0x85, 0x06, 0xab, 0x63, 0xe4, 0xd2, 0xba, 0x69, 0x94, 0x8c, 0xed, 0x59, 0x67, 0x46,
-	0xed, 0x8f, 0xea, 0x64, 0x13, 0x66, 0xd3, 0x44, 0x18, 0x37, 0x73, 0x0a, 0xeb, 0x1a, 0xc8, 0x16,
-	0x14, 0xd3, 0x0d, 0xba, 0x92, 0x99, 0x79, 0x85, 0x43, 0xc7, 0x74, 0xca, 0xec, 0x23, 0x80, 0x1a,
-	0xdb, 0x77, 0xf0, 0xa2, 0x29, 0xbc, 0x68, 0x54, 0x9c, 0x12, 0x14, 0x13, 0x8f, 0x4b, 0xea, 0xd3,
-	0xc4, 0x8b, 0x65, 0x1a, 0xa9, 0xd7, 0x64, 0x1f, 0xc3, 0x62, 0x3b, 0x6b, 0xca, 0xd1, 0x97, 0x47,
-	0xb1, 0xc4, 0x58, 0x8e, 0xc7, 0x57, 0x83, 0x6f, 0xaa, 0x6d, 0xe7, 0x33, 0x26, 0x69, 0x1c, 0xd4,
-	0xd8, 0x25, 0xf2, 0x51, 0x84, 0xdf, 0xc3, 0x5c, 0x4b, 0x79, 0xba, 0x49, 0xdb, 0x55, 0x31, 0xe6,
-	0x9d, 0x62, 0xab, 0x7b, 0xda, 0x7e, 0x65, 0x00, 0xe9, 0x76, 0xf5, 0x24, 0xf6, 0x12, 0x11, 0x32,
-	0x49, 0x7e, 0x82, 0x45, 0x91, 0xae, 0xdd, 0x10, 0x69, 0x10, 0x4a, 0xc5, 0x9d, 0x77, 0x16, 0x3a,
-	0xe6, 0x43, 0x65, 0x25, 0x07, 0x59, 0x37, 0x29, 0x8b, 0x85, 0x99, 0x2b, 0xe5, 0xb7, 0x8b, 0xbf,
-	0xda, 0xe5, 0x21, 0xd7, 0x5e, 0xee, 0xbb, 0x3f, 0xa7, 0xf7, 0x18, 0xf9, 0x0b, 0x0a, 0x5c, 0xf7,
-	0x5b, 0x98, 0x79, 0x45, 0xb1, 0x75, 0x17, 0x45, 0x7a, 0x2f, 0x4e, 0x76, 0xc0, 0xfe, 0x98, 0x83,
-	0xcd, 0x3d, 0xc6, 0xa4, 0x90, 0xdc, 0x4b, 0x54, 0x7b, 0x6a, 0x1c, 0xff, 0x89, 0x68, 0x40, 0xcf,
-	0x69, 0x44, 0xe5, 0xd5, 0x3d, 0x1d, 0x4a, 0x38, 0xba, 0xa8, 0xbc, 0x23, 0x54, 0x1d, 0x2a, 0x38,
-	0xc5, 0xa4, 0x43, 0x10, 0x21, 0xf9, 0x1d, 0x56, 0x1b, 0x88, 0x52, 0xb8, 0x97, 0xaa, 0x62, 0x57,
-	0x86, 0x1c, 0x45, 0xc8, 0xa2, 0xba, 0x92, 0x4e, 0xc1, 0x59, 0x51, 0xe8, 0x03, 0x05, 0x9e, 0x76,
-	0x30, 0x62, 0x41, 0x51, 0x9f, 0x6a, 0xb9, 0x0d, 0x1a, 0x9b, 0x93, 0xca, 0x75, 0x56, 0x99, 0xce,
-	0xaa, 0x34, 0x26, 0x3f, 0x03, 0xd1, 0x38, 0x47, 0xcf, 0x0f, 0x3d, 0x9d, 0xa9, 0x39, 0xa5, 0xdc,
-	0x96, 0x14, 0xe2, 0xf4, 0x00, 0x64, 0x07, 0x96, 0xa8, 0xd2, 0x8f, 0x1b, 0x32, 0x21, 0x5d, 0x9f,
-	0x35, 0x63, 0x69, 0x4e, 0xab, 0x1b, 0x59, 0xd4, 0xc0, 0x21, 0x13, 0x72, 0xbf, 0x6d, 0x26, 0x3f,
-	0xc0, 0x7c, 0xea, 0xab, 0x33, 0x36, 0x67, 0x94, 0xdf, 0x9c, 0x36, 0xea, 0x44, 0xdb, 0x55, 0xa5,
-	0x91, 0x23, 0x74, 0xfb, 0x44, 0x52, 0x50, 0xde, 0x2b, 0x19, 0xda, 0xa3, 0x35, 0xfb, 0x6d, 0x0e,
-	0x36, 0xb2, 0x56, 0x7f, 0x7d, 0xd9, 0xfc, 0x0d, 0x33, 0xba, 0xa8, 0x8e, 0x6a, 0x7e, 0xbc, 0x93,
-	0xa1, 0xe7, 0x09, 0x3a, 0x9d, 0x43, 0xe4, 0x17, 0x58, 0x91, 0x4c, 0x7a, 0x91, 0x1b, 0xa3, 0xbc,
-	0x64, 0xfc, 0x49, 0xa7, 0x61, 0x93, 0x2a, 0x67, 0xa2, 0xb0, 0x63, 0x0d, 0xa5, 0x6d, 0x7b, 0x04,
-	0x0b, 0x09, 0x47, 0xec, 0x8a, 0xcb, 0x9c, 0x52, 0x81, 0x77, 0x87, 0x06, 0x1e, 0xa5, 0x4a, 0x67,
-	0x80, 0xc8, 0x6e, 0xc1, 0x72, 0x55, 0x04, 0x27, 0x28, 0xfb, 0xe7, 0xdc, 0x2a, 0x4c, 0x0b, 0x8c,
-	0xeb, 0xc8, 0x53, 0xe9, 0xa6, 0xbb, 0x3e, 0x51, 0xe7, 0xfa, 0x45, 0x7d, 0xdf, 0x84, 0xfb, 0xb3,
-	0xf8, 0xfc, 0xc3, 0xcb, 0x9d, 0x94, 0xc8, 0xfe, 0x0e, 0x36, 0x86, 0xc4, 0x75, 0x50, 0x24, 0x2c,
-	0x16, 0x68, 0x3f, 0x84, 0xd5, 0xaa, 0x08, 0xd4, 0xab, 0xc3, 0x71, 0x33, 0xeb, 0x0f, 0x5c, 0x02,
-	0x6b, 0x38, 0x73, 0x16, 0xfb, 0x7f, 0xd5, 0x92, 0x03, 0xf4, 0x23, 0x8f, 0xb7, 0x5d, 0xd2, 0x11,
-	0x3a, 0x6e, 0x60, 0x5d, 0xf1, 0x20, 0x6d, 0x4f, 0xc5, 0x6b, 0xff, 0x35, 0x91, 0x5f, 0x0d, 0xe4,
-	0xf4, 0xb4, 0x89, 0x42, 0x0e, 0xce, 0x68, 0xe3, 0xb3, 0x19, 0x3d, 0x22, 0x0b, 0xfb, 0x9d, 0x01,
-	0xeb, 0xc3, 0xa8, 0x75, 0xe0, 0xc1, 0x47, 0x61, 0x8c, 0x3f, 0x4b, 0x73, 0x5f, 0x38, 0x4b, 0xc7,
-	0x7d, 0x51, 0x7b, 0xff, 0xbe, 0xbe, 0xb1, 0x8c, 0xeb, 0x1b, 0xcb, 0x78, 0x7f, 0x63, 0x19, 0x2f,
-	0x6e, 0xad, 0x89, 0xeb, 0x5b, 0x6b, 0xe2, 0xcd, 0xad, 0x35, 0xf1, 0xf8, 0x8f, 0x80, 0xca, 0xb0,
-	0x79, 0x5e, 0xf6, 0x59, 0xa3, 0x92, 0x70, 0x56, 0x6f, 0xfa, 0x52, 0xf8, 0x74, 0xe0, 0x1b, 0xe2,
-	0x59, 0xcf, 0x5a, 0x5e, 0x25, 0x28, 0xce, 0xa7, 0xd5, 0xdf, 0xff, 0x6f, 0x9f, 0x02, 0x00, 0x00,
-	0xff, 0xff, 0xc5, 0xfc, 0xe7, 0xbc, 0x73, 0x08, 0x00, 0x00,
+	// 943 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
+	0x14, 0xce, 0xda, 0xf9, 0x61, 0x3f, 0xb7, 0x49, 0x3b, 0x8d, 0xd2, 0x4d, 0x1a, 0x1c, 0xb3, 0x20,
+	0x11, 0x55, 0xd4, 0xa6, 0x01, 0x2e, 0x20, 0x71, 0x68, 0x02, 0x34, 0xa0, 0x14, 0xb3, 0x0d, 0xe5,
+	0xc7, 0x65, 0xb5, 0x59, 0x3f, 0x7b, 0x47, 0xac, 0x67, 0x96, 0x99, 0xb1, 0xd3, 0x5c, 0x11, 0x57,
+	0x24, 0xfe, 0x14, 0xfe, 0x04, 0x8e, 0x1c, 0x7b, 0x04, 0x09, 0x09, 0x94, 0x1c, 0xe0, 0xcf, 0x40,
+	0x9e, 0x99, 0x5d, 0xff, 0xc0, 0x4e, 0x82, 0x7c, 0xe8, 0x29, 0x33, 0xef, 0x7b, 0xef, 0x7b, 0xdf,
+	0xbc, 0xfd, 0x32, 0x63, 0xd8, 0xa5, 0xac, 0x8d, 0x02, 0x59, 0x84, 0x8d, 0xe1, 0x2a, 0xe5, 0x51,
+	0xd0, 0xc2, 0x04, 0x3b, 0xa1, 0xa2, 0x9c, 0xd5, 0x53, 0xc1, 0x15, 0x27, 0x77, 0x72, 0xbc, 0x9e,
+	0xaf, 0xb6, 0xee, 0x46, 0x5c, 0x76, 0xb9, 0x6c, 0x74, 0x65, 0xa7, 0xd1, 0x7f, 0x38, 0xf8, 0x63,
+	0xb2, 0xb7, 0x36, 0x0d, 0x10, 0xe8, 0x5d, 0xc3, 0x6c, 0x2c, 0x54, 0x9b, 0xda, 0x32, 0x14, 0x61,
+	0xd7, 0x66, 0x78, 0x14, 0x6e, 0x36, 0xf9, 0xfe, 0x41, 0xae, 0x80, 0x6c, 0x42, 0xa9, 0xcb, 0x5b,
+	0x98, 0x04, 0xb4, 0xe5, 0x3a, 0x35, 0x67, 0xb7, 0xec, 0xaf, 0xe8, 0xfd, 0x61, 0x8b, 0x6c, 0x43,
+	0xd9, 0x4a, 0xe5, 0xc2, 0x2d, 0x68, 0x6c, 0x18, 0x20, 0x3b, 0x50, 0xb1, 0x1b, 0x0c, 0x14, 0x77,
+	0x8b, 0x1a, 0x87, 0x2c, 0x74, 0xcc, 0xbd, 0x43, 0x80, 0x26, 0xdf, 0xf7, 0xb1, 0xdd, 0x93, 0x61,
+	0x72, 0x59, 0x9f, 0x1a, 0x54, 0xd2, 0x50, 0x28, 0x1a, 0xd1, 0x34, 0x64, 0xca, 0x76, 0x1a, 0x0d,
+	0x79, 0x4f, 0x60, 0x6d, 0xa0, 0x9a, 0x0a, 0x8c, 0xd4, 0x21, 0x53, 0xc8, 0xd4, 0x7c, 0x7c, 0x4d,
+	0xb8, 0x75, 0x34, 0x48, 0x7e, 0xc6, 0x15, 0x65, 0x9d, 0x26, 0x3f, 0x45, 0x71, 0x19, 0xe1, 0xab,
+	0x70, 0xa3, 0xaf, 0x33, 0x83, 0x74, 0x90, 0xaa, 0x19, 0x8b, 0x7e, 0xa5, 0x3f, 0xac, 0xf6, 0x7e,
+	0x71, 0x80, 0x0c, 0xa7, 0xfa, 0x94, 0x85, 0xa9, 0x8c, 0xb9, 0x22, 0x6f, 0xc0, 0x9a, 0xb4, 0xeb,
+	0x20, 0x46, 0xda, 0x89, 0x95, 0xe6, 0x2e, 0xfa, 0xab, 0x59, 0xf8, 0xb1, 0x8e, 0x92, 0x83, 0x7c,
+	0x9a, 0x94, 0x33, 0xe9, 0x16, 0x6a, 0xc5, 0xdd, 0xca, 0x9e, 0x57, 0x9f, 0x62, 0x8c, 0xfa, 0xd8,
+	0xf7, 0xf3, 0x47, 0xcb, 0xc8, 0xfb, 0x50, 0x12, 0x66, 0xde, 0xd2, 0x2d, 0x6a, 0x8a, 0x9d, 0x59,
+	0x14, 0xf6, 0xbb, 0xf8, 0x79, 0x81, 0xf7, 0x4f, 0x01, 0xb6, 0x1f, 0x71, 0xae, 0xa4, 0x12, 0x61,
+	0xaa, 0xc7, 0xd3, 0x14, 0xf8, 0x61, 0x42, 0x3b, 0xf4, 0x84, 0x26, 0x54, 0x9d, 0x5d, 0x31, 0xa1,
+	0x54, 0x60, 0x80, 0x3a, 0x3b, 0x41, 0x3d, 0xa1, 0x92, 0x5f, 0x49, 0x33, 0x82, 0x04, 0xc9, 0x3b,
+	0xb0, 0xd1, 0x45, 0x54, 0x32, 0x38, 0xd5, 0x27, 0x0e, 0x54, 0x2c, 0x50, 0xc6, 0x3c, 0x69, 0x69,
+	0xeb, 0x94, 0xfc, 0x75, 0x8d, 0x7e, 0xa9, 0xc1, 0xe3, 0x0c, 0x23, 0x55, 0xa8, 0x98, 0xaa, 0x7e,
+	0xd0, 0xa5, 0xcc, 0x5d, 0xd4, 0xa9, 0x65, 0x1d, 0x7a, 0x76, 0x44, 0x19, 0x79, 0x00, 0xc4, 0xe0,
+	0x02, 0xc3, 0x28, 0x0e, 0x8d, 0x52, 0x77, 0x49, 0xa7, 0xdd, 0xd6, 0x88, 0x3f, 0x02, 0x90, 0xfb,
+	0x70, 0x9b, 0x6a, 0xff, 0x04, 0x31, 0x97, 0x2a, 0x88, 0x78, 0x8f, 0x29, 0x77, 0x59, 0x7f, 0x91,
+	0x35, 0x03, 0x3c, 0xe6, 0x52, 0xed, 0x0f, 0xc2, 0xe4, 0x35, 0xb8, 0x69, 0x73, 0x8d, 0x62, 0x77,
+	0x45, 0xe7, 0xdd, 0x30, 0x41, 0x23, 0x74, 0x70, 0x2a, 0xdb, 0x39, 0xc1, 0x60, 0xcc, 0x24, 0x25,
+	0x9d, 0xbd, 0x9e, 0xa3, 0x23, 0x5e, 0xf3, 0x7e, 0x2f, 0xc0, 0xbd, 0x7c, 0xd4, 0x2f, 0xdf, 0x36,
+	0x1f, 0xc0, 0x8a, 0x39, 0x54, 0xe6, 0x9a, 0xd7, 0x67, 0x32, 0x8c, 0xfc, 0x0b, 0xfa, 0x59, 0x11,
+	0x79, 0x0b, 0xd6, 0x15, 0x57, 0x61, 0x12, 0x30, 0x54, 0xa7, 0x5c, 0x7c, 0x9b, 0x0d, 0x6c, 0x51,
+	0x6b, 0x26, 0x1a, 0x7b, 0x62, 0x20, 0x3b, 0xb6, 0xaf, 0x61, 0x35, 0x15, 0x88, 0x43, 0x73, 0xb9,
+	0x4b, 0xba, 0xf1, 0xc3, 0xa9, 0x8d, 0x2f, 0x73, 0xa5, 0x3f, 0x41, 0xe4, 0xfd, 0xe8, 0x80, 0x3b,
+	0x72, 0x50, 0x3c, 0x0d, 0x45, 0xeb, 0x58, 0x84, 0x4c, 0xb6, 0x2f, 0xff, 0x27, 0x27, 0xb0, 0xd8,
+	0x16, 0xbc, 0x6b, 0xaf, 0x0b, 0xbd, 0x26, 0xab, 0x50, 0xc8, 0xaf, 0xb6, 0x82, 0xe2, 0x64, 0x0f,
+	0x96, 0x64, 0x1c, 0x0a, 0xd4, 0x27, 0xab, 0xec, 0x6d, 0x4f, 0x55, 0x7b, 0x80, 0x11, 0xed, 0x86,
+	0x89, 0x6f, 0x52, 0xbd, 0x1f, 0x1c, 0xb8, 0x3b, 0xa9, 0xa7, 0x89, 0x2c, 0x4c, 0xd4, 0xd9, 0xe4,
+	0x4d, 0xe5, 0xfc, 0xe7, 0xa6, 0x22, 0x1f, 0xc3, 0xad, 0xd4, 0x24, 0x07, 0x6d, 0x11, 0x46, 0x03,
+	0x0a, 0xad, 0xf0, 0xaa, 0xe6, 0x6b, 0xb6, 0xea, 0x23, 0x5b, 0xe4, 0xfd, 0xe1, 0x40, 0x6d, 0xd6,
+	0x58, 0x72, 0xdf, 0xed, 0x40, 0x05, 0x53, 0x1e, 0xc5, 0x01, 0x65, 0x2d, 0x7c, 0xae, 0xf5, 0x2c,
+	0xfa, 0xa0, 0x43, 0x87, 0x83, 0x08, 0xf9, 0x14, 0xca, 0xca, 0x16, 0x65, 0x6e, 0x7b, 0x30, 0x43,
+	0xc7, 0xf4, 0x56, 0xfe, 0xb0, 0x9e, 0x7c, 0x02, 0x65, 0xa3, 0x92, 0x62, 0x66, 0xbc, 0x37, 0xaf,
+	0x45, 0x66, 0xc7, 0xe7, 0x0f, 0xcb, 0xbd, 0x3e, 0xdc, 0x39, 0x92, 0x9d, 0xa7, 0xa8, 0xc6, 0x5f,
+	0xb7, 0x0d, 0x58, 0x96, 0xc8, 0x5a, 0x28, 0xec, 0x6c, 0xed, 0x6e, 0xcc, 0x07, 0x85, 0x71, 0x1f,
+	0x5c, 0xf5, 0xae, 0xbd, 0x57, 0xf9, 0xfe, 0xef, 0x9f, 0xef, 0x5b, 0x22, 0xef, 0x15, 0xb8, 0x37,
+	0xa5, 0xaf, 0x8f, 0x32, 0xe5, 0x4c, 0xa2, 0xf7, 0x15, 0x6c, 0x1c, 0xc9, 0x8e, 0xbe, 0x6b, 0x71,
+	0x5e, 0x65, 0xe3, 0x8d, 0x6b, 0x50, 0x9d, 0xce, 0x9c, 0xf7, 0xfe, 0x42, 0x8f, 0xe4, 0x00, 0xa3,
+	0x24, 0x14, 0x83, 0x14, 0xfb, 0x70, 0xce, 0xdb, 0xd8, 0x9c, 0x78, 0x92, 0x76, 0xe4, 0xc4, 0x9b,
+	0x9f, 0xf7, 0x50, 0x9c, 0x4d, 0x68, 0xfa, 0xae, 0x87, 0x52, 0x5d, 0xc3, 0xef, 0xb3, 0x55, 0x78,
+	0x7f, 0x3a, 0xb0, 0x35, 0x8d, 0xda, 0x34, 0x9e, 0xbc, 0x0a, 0x9d, 0xf9, 0x5f, 0xd0, 0xc2, 0xff,
+	0x7c, 0x41, 0xe7, 0xbd, 0x47, 0x1f, 0x7d, 0xf6, 0xeb, 0x79, 0xd5, 0x79, 0x71, 0x5e, 0x75, 0xfe,
+	0x3a, 0xaf, 0x3a, 0x3f, 0x5d, 0x54, 0x17, 0x5e, 0x5c, 0x54, 0x17, 0x7e, 0xbb, 0xa8, 0x2e, 0x7c,
+	0xf3, 0x6e, 0x87, 0xaa, 0xb8, 0x77, 0x52, 0x8f, 0x78, 0xb7, 0x91, 0x0a, 0xde, 0xea, 0x45, 0x4a,
+	0x46, 0x74, 0xe2, 0x87, 0xde, 0xf3, 0x91, 0xb5, 0x3a, 0x4b, 0x51, 0x9e, 0x2c, 0xeb, 0x1f, 0x7d,
+	0x6f, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x25, 0x85, 0x24, 0x65, 0x8b, 0x0a, 0x00, 0x00,
 }
 
 func (m *PoCDelegation) Marshal() (dAtA []byte, err error) {
@@ -1310,6 +1503,160 @@ func (m *BootstrapDelegationSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, er
 	return len(dAtA) - i, nil
 }
 
+func (m *DelegationRewardTransfer) 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 *DelegationRewardTransfer) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DelegationRewardTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Share != nil {
+		{
+			size, err := m.Share.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPocDelegation(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.To) > 0 {
+		i -= len(m.To)
+		copy(dAtA[i:], m.To)
+		i = encodeVarintPocDelegation(dAtA, i, uint64(len(m.To)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.From) > 0 {
+		i -= len(m.From)
+		copy(dAtA[i:], m.From)
+		i = encodeVarintPocDelegation(dAtA, i, uint64(len(m.From)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.ModelId) > 0 {
+		i -= len(m.ModelId)
+		copy(dAtA[i:], m.ModelId)
+		i = encodeVarintPocDelegation(dAtA, i, uint64(len(m.ModelId)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DelegationRewardPenalty) 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 *DelegationRewardPenalty) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DelegationRewardPenalty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.PenaltyFraction != nil {
+		{
+			size, err := m.PenaltyFraction.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPocDelegation(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintPocDelegation(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DelegationRewardTransferSnapshot) 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 *DelegationRewardTransferSnapshot) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DelegationRewardTransferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Penalties) > 0 {
+		for iNdEx := len(m.Penalties) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Penalties[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPocDelegation(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.Transfers) > 0 {
+		for iNdEx := len(m.Transfers) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Transfers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPocDelegation(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if m.EpochIndex != 0 {
+		i = encodeVarintPocDelegation(dAtA, i, uint64(m.EpochIndex))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *MsgSetPoCDelegation) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1772,28 +2119,94 @@ func (m *BootstrapDelegationSnapshot) Size() (n int) {
 	return n
 }
 
-func (m *MsgSetPoCDelegation) Size() (n int) {
+func (m *DelegationRewardTransfer) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Sender)
+	l = len(m.ModelId)
 	if l > 0 {
 		n += 1 + l + sovPocDelegation(uint64(l))
 	}
-	l = len(m.ModelId)
+	l = len(m.From)
 	if l > 0 {
 		n += 1 + l + sovPocDelegation(uint64(l))
 	}
-	l = len(m.DelegateTo)
+	l = len(m.To)
 	if l > 0 {
 		n += 1 + l + sovPocDelegation(uint64(l))
 	}
+	if m.Share != nil {
+		l = m.Share.Size()
+		n += 1 + l + sovPocDelegation(uint64(l))
+	}
 	return n
 }
 
-func (m *MsgSetPoCDelegationResponse) Size() (n int) {
+func (m *DelegationRewardPenalty) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovPocDelegation(uint64(l))
+	}
+	if m.PenaltyFraction != nil {
+		l = m.PenaltyFraction.Size()
+		n += 1 + l + sovPocDelegation(uint64(l))
+	}
+	return n
+}
+
+func (m *DelegationRewardTransferSnapshot) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.EpochIndex != 0 {
+		n += 1 + sovPocDelegation(uint64(m.EpochIndex))
+	}
+	if len(m.Transfers) > 0 {
+		for _, e := range m.Transfers {
+			l = e.Size()
+			n += 1 + l + sovPocDelegation(uint64(l))
+		}
+	}
+	if len(m.Penalties) > 0 {
+		for _, e := range m.Penalties {
+			l = e.Size()
+			n += 1 + l + sovPocDelegation(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MsgSetPoCDelegation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Sender)
+	if l > 0 {
+		n += 1 + l + sovPocDelegation(uint64(l))
+	}
+	l = len(m.ModelId)
+	if l > 0 {
+		n += 1 + l + sovPocDelegation(uint64(l))
+	}
+	l = len(m.DelegateTo)
+	if l > 0 {
+		n += 1 + l + sovPocDelegation(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgSetPoCDelegationResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -2925,6 +3338,443 @@ func (m *BootstrapDelegationSnapshot) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *DelegationRewardTransfer) 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 ErrIntOverflowPocDelegation
+			}
+			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: DelegationRewardTransfer: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DelegationRewardTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				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 ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ModelId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				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 ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.From = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				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 ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.To = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Share", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Share == nil {
+				m.Share = &Decimal{}
+			}
+			if err := m.Share.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPocDelegation(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DelegationRewardPenalty) 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 ErrIntOverflowPocDelegation
+			}
+			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: DelegationRewardPenalty: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DelegationRewardPenalty: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				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 ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PenaltyFraction", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.PenaltyFraction == nil {
+				m.PenaltyFraction = &Decimal{}
+			}
+			if err := m.PenaltyFraction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPocDelegation(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DelegationRewardTransferSnapshot) 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 ErrIntOverflowPocDelegation
+			}
+			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: DelegationRewardTransferSnapshot: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DelegationRewardTransferSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			}
+			m.EpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Transfers", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Transfers = append(m.Transfers, &DelegationRewardTransfer{})
+			if err := m.Transfers[len(m.Transfers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Penalties", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPocDelegation
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Penalties = append(m.Penalties, &DelegationRewardPenalty{})
+			if err := m.Penalties[len(m.Penalties)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPocDelegation(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPocDelegation
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *MsgSetPoCDelegation) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/inference-chain/x/inference/types/pruning_state.pb.go b/inference-chain/x/inference/types/pruning_state.pb.go
index 849d5e28ff..7bf20a7e2d 100644
--- a/inference-chain/x/inference/types/pruning_state.pb.go
+++ b/inference-chain/x/inference/types/pruning_state.pb.go
@@ -32,6 +32,7 @@ type PruningState struct {
 	MlnodeWeightDistributionsPrunedEpoch int64 `protobuf:"varint,7,opt,name=mlnode_weight_distributions_pruned_epoch,json=mlnodeWeightDistributionsPrunedEpoch,proto3" json:"mlnode_weight_distributions_pruned_epoch,omitempty"`
 	PocValidationsV2PrunedEpoch          int64 `protobuf:"varint,8,opt,name=poc_validations_v2_pruned_epoch,json=pocValidationsV2PrunedEpoch,proto3" json:"poc_validations_v2_pruned_epoch,omitempty"`
 	PocValidationSnapshotsPrunedEpoch    int64 `protobuf:"varint,9,opt,name=poc_validation_snapshots_pruned_epoch,json=pocValidationSnapshotsPrunedEpoch,proto3" json:"poc_validation_snapshots_pruned_epoch,omitempty"`
+	ClaimRecipientsPrunedEpoch           int64 `protobuf:"varint,10,opt,name=claim_recipients_pruned_epoch,json=claimRecipientsPrunedEpoch,proto3" json:"claim_recipients_pruned_epoch,omitempty"`
 }
 
 func (m *PruningState) Reset()         { *m = PruningState{} }
@@ -130,6 +131,13 @@ func (m *PruningState) GetPocValidationSnapshotsPrunedEpoch() int64 {
 	return 0
 }
 
+func (m *PruningState) GetClaimRecipientsPrunedEpoch() int64 {
+	if m != nil {
+		return m.ClaimRecipientsPrunedEpoch
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*PruningState)(nil), "inference.inference.PruningState")
 }
@@ -139,32 +147,34 @@ func init() {
 }
 
 var fileDescriptor_f3e942f788f930ee = []byte{
-	// 395 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x6b, 0xe2, 0x40,
-	0x18, 0x86, 0xcd, 0xba, 0xba, 0xbb, 0xc3, 0x9e, 0x74, 0x5d, 0x5c, 0xb6, 0xa4, 0x5a, 0x2c, 0xf5,
-	0xa4, 0x90, 0xb6, 0xf4, 0x58, 0xb0, 0x16, 0x6f, 0xad, 0x28, 0xa4, 0xd0, 0xcb, 0x90, 0x4c, 0xa6,
-	0xc9, 0x80, 0x99, 0x19, 0x66, 0x26, 0xb6, 0xfd, 0x17, 0xfe, 0xac, 0x1e, 0x3d, 0xf6, 0x58, 0xf4,
-	0x8f, 0x94, 0x4c, 0x30, 0x4e, 0x42, 0xbd, 0x8d, 0xbc, 0xcf, 0xfb, 0xf8, 0x7d, 0x99, 0x01, 0x67,
-	0x84, 0x3e, 0x61, 0x81, 0x29, 0xc2, 0xc3, 0xfd, 0x89, 0x8b, 0x84, 0x12, 0x1a, 0x42, 0xa9, 0x3c,
-	0x85, 0x07, 0x5c, 0x30, 0xc5, 0x1a, 0xcd, 0x3c, 0x1e, 0xe4, 0xa7, 0x93, 0x55, 0x0d, 0xfc, 0x9e,
-	0x66, 0xf0, 0x3c, 0x65, 0x1b, 0x57, 0xa0, 0xcd, 0x19, 0x82, 0xbe, 0xa7, 0x50, 0x84, 0x25, 0x4c,
-	0x45, 0x38, 0x80, 0x98, 0x33, 0x14, 0xb5, 0xad, 0x8e, 0xd5, 0xaf, 0xce, 0x5a, 0x9c, 0xa1, 0x51,
-	0x16, 0x4f, 0x75, 0x7a, 0x9b, 0x86, 0x8d, 0x6b, 0x70, 0x94, 0x16, 0x97, 0xde, 0x82, 0x04, 0x9e,
-	0x22, 0x8c, 0x96, 0xca, 0xdf, 0x74, 0xf9, 0x1f, 0x67, 0xc8, 0xdd, 0x23, 0xa6, 0xe0, 0x02, 0xfc,
-	0xcd, 0xe7, 0x2a, 0x56, 0xab, 0xba, 0xfa, 0x27, 0x4f, 0xcd, 0xd6, 0x1d, 0xe8, 0x69, 0x08, 0x86,
-	0x82, 0x25, 0xfc, 0xf0, 0xdf, 0x7f, 0xd7, 0x8e, 0x8e, 0xfe, 0x31, 0x49, 0xd1, 0x03, 0x53, 0x38,
-	0xa0, 0x15, 0xe0, 0xa5, 0x8c, 0x3c, 0x11, 0x14, 0x05, 0x35, 0x2d, 0x68, 0xee, 0x42, 0xb3, 0x33,
-	0x01, 0x5d, 0xbd, 0xba, 0x03, 0xa5, 0x62, 0x02, 0x43, 0xc4, 0xe2, 0x98, 0xa8, 0xd2, 0x00, 0x75,
-	0xdd, 0x4f, 0xbf, 0x91, 0xeb, 0xcc, 0x53, 0xec, 0x26, 0xa3, 0x4c, 0x91, 0x0b, 0xfa, 0xf1, 0x82,
-	0xb2, 0x00, 0xc3, 0x67, 0x4c, 0xc2, 0x48, 0xc1, 0x80, 0x48, 0x25, 0x88, 0x9f, 0x7c, 0xb1, 0xd0,
-	0x0f, 0xed, 0xeb, 0x65, 0xfc, 0x83, 0xc6, 0xc7, 0x26, 0x6d, 0x7a, 0xc7, 0xe0, 0xb8, 0x7c, 0x37,
-	0x4b, 0xa7, 0xa8, 0xfb, 0xa9, 0x75, 0xff, 0x8b, 0xd7, 0xe3, 0x3a, 0xa6, 0x65, 0x0a, 0x4e, 0x8b,
-	0x16, 0x28, 0xa9, 0xc7, 0x65, 0xc4, 0xca, 0xab, 0xfe, 0xd2, 0xae, 0x6e, 0xc1, 0x35, 0xdf, 0xa1,
-	0x86, 0x71, 0xd6, 0x94, 0x89, 0x4f, 0xb1, 0x2a, 0xb4, 0x47, 0xf7, 0x6f, 0x1b, 0xdb, 0x5a, 0x6f,
-	0x6c, 0xeb, 0x63, 0x63, 0x5b, 0xab, 0xad, 0x5d, 0x59, 0x6f, 0xed, 0xca, 0xfb, 0xd6, 0xae, 0x3c,
-	0x5e, 0x86, 0x44, 0x45, 0x89, 0x3f, 0x40, 0x2c, 0x1e, 0x72, 0xc1, 0x82, 0x04, 0x29, 0x89, 0x48,
-	0xe9, 0xe9, 0xbf, 0x18, 0x67, 0xf5, 0xca, 0xb1, 0xf4, 0xeb, 0xfa, 0xfd, 0x9f, 0x7f, 0x06, 0x00,
-	0x00, 0xff, 0xff, 0x45, 0x0c, 0x1e, 0xba, 0x2a, 0x03, 0x00, 0x00,
+	// 419 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x93, 0x4f, 0x8f, 0xd2, 0x40,
+	0x18, 0xc6, 0xa9, 0x08, 0xea, 0xc4, 0x13, 0x88, 0xc1, 0x7f, 0x15, 0x0c, 0x46, 0x4e, 0x90, 0x54,
+	0x8d, 0x47, 0x23, 0x62, 0xb8, 0x29, 0x81, 0xa4, 0x26, 0x5e, 0x26, 0xed, 0x74, 0x6c, 0x27, 0xa1,
+	0x33, 0x93, 0x99, 0x29, 0xba, 0xdf, 0x62, 0x3f, 0xd6, 0x1e, 0x49, 0xf6, 0xb2, 0xc7, 0x0d, 0x7c,
+	0x91, 0x4d, 0xdf, 0x86, 0x32, 0x6d, 0x96, 0xdb, 0x90, 0xe7, 0xf7, 0xfc, 0x78, 0xdf, 0x4e, 0x06,
+	0x7d, 0x60, 0xfc, 0x2f, 0x55, 0x94, 0x13, 0x3a, 0x3d, 0x9d, 0xa4, 0xca, 0x38, 0xe3, 0x31, 0xd6,
+	0x26, 0x30, 0x74, 0x22, 0x95, 0x30, 0xa2, 0xd3, 0x2d, 0xe3, 0x49, 0x79, 0x7a, 0x77, 0xdd, 0x42,
+	0x4f, 0x97, 0x05, 0xbc, 0xce, 0xd9, 0xce, 0x17, 0xd4, 0x97, 0x82, 0xe0, 0x30, 0x30, 0x24, 0xa1,
+	0x1a, 0xe7, 0x22, 0x1a, 0x61, 0x2a, 0x05, 0x49, 0xfa, 0xce, 0xc0, 0x19, 0x37, 0x57, 0x3d, 0x29,
+	0xc8, 0xac, 0x88, 0x97, 0x90, 0xfe, 0xc8, 0xc3, 0xce, 0x57, 0xf4, 0x3a, 0x2f, 0x6e, 0x83, 0x0d,
+	0x8b, 0x02, 0xc3, 0x04, 0xaf, 0x95, 0x1f, 0x40, 0xf9, 0x85, 0x14, 0xc4, 0x3f, 0x21, 0xb6, 0xe0,
+	0x13, 0x7a, 0x5e, 0xce, 0x55, 0xad, 0x36, 0xa1, 0xfa, 0xac, 0x4c, 0xed, 0xd6, 0x4f, 0x34, 0x02,
+	0x08, 0xc7, 0x4a, 0x64, 0xf2, 0xfc, 0xdf, 0x3f, 0x04, 0xc7, 0x00, 0x7e, 0x2c, 0x72, 0xf4, 0xcc,
+	0x14, 0x1e, 0xea, 0x45, 0x74, 0xab, 0x93, 0x40, 0x45, 0x55, 0x41, 0x0b, 0x04, 0xdd, 0x63, 0x68,
+	0x77, 0x16, 0x68, 0x08, 0xab, 0x7b, 0x58, 0x1b, 0xa1, 0x28, 0x26, 0x22, 0x4d, 0x99, 0xa9, 0x0d,
+	0xd0, 0x86, 0x7e, 0xfe, 0x8d, 0x7c, 0x6f, 0x9d, 0x63, 0xdf, 0x0b, 0xca, 0x16, 0xf9, 0x68, 0x9c,
+	0x6e, 0xb8, 0x88, 0x28, 0xfe, 0x47, 0x59, 0x9c, 0x18, 0x1c, 0x31, 0x6d, 0x14, 0x0b, 0xb3, 0x7b,
+	0x16, 0x7a, 0x04, 0xbe, 0x51, 0xc1, 0xff, 0x06, 0x7c, 0x6e, 0xd3, 0xb6, 0x77, 0x8e, 0xde, 0xd6,
+	0xef, 0x66, 0xeb, 0x55, 0x75, 0x8f, 0x41, 0xf7, 0xaa, 0x7a, 0x3d, 0xbe, 0x67, 0x5b, 0x96, 0xe8,
+	0x7d, 0xd5, 0x82, 0x35, 0x0f, 0xa4, 0x4e, 0x44, 0x7d, 0xd5, 0x27, 0xe0, 0x1a, 0x56, 0x5c, 0xeb,
+	0x23, 0x6a, 0x1b, 0xbf, 0xa1, 0x37, 0x64, 0x13, 0xb0, 0x14, 0x2b, 0x4a, 0x98, 0x64, 0x94, 0xd7,
+	0x4d, 0x08, 0x4c, 0x2f, 0x01, 0x5a, 0x95, 0x8c, 0xa5, 0x58, 0x75, 0x75, 0x16, 0x72, 0x6a, 0x2a,
+	0xb5, 0xd9, 0xaf, 0xab, 0xbd, 0xeb, 0xec, 0xf6, 0xae, 0x73, 0xbb, 0x77, 0x9d, 0xcb, 0x83, 0xdb,
+	0xd8, 0x1d, 0xdc, 0xc6, 0xcd, 0xc1, 0x6d, 0xfc, 0xf9, 0x1c, 0x33, 0x93, 0x64, 0xe1, 0x84, 0x88,
+	0x74, 0x2a, 0x95, 0x88, 0x32, 0x62, 0x34, 0x61, 0xb5, 0xd7, 0xf3, 0xdf, 0x3a, 0x9b, 0x0b, 0x49,
+	0x75, 0xd8, 0x86, 0x27, 0xf4, 0xf1, 0x2e, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x36, 0x9f, 0xaf, 0x6d,
+	0x03, 0x00, 0x00,
 }
 
 func (m *PruningState) Marshal() (dAtA []byte, err error) {
@@ -187,6 +197,11 @@ func (m *PruningState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.ClaimRecipientsPrunedEpoch != 0 {
+		i = encodeVarintPruningState(dAtA, i, uint64(m.ClaimRecipientsPrunedEpoch))
+		i--
+		dAtA[i] = 0x50
+	}
 	if m.PocValidationSnapshotsPrunedEpoch != 0 {
 		i = encodeVarintPruningState(dAtA, i, uint64(m.PocValidationSnapshotsPrunedEpoch))
 		i--
@@ -279,6 +294,9 @@ func (m *PruningState) Size() (n int) {
 	if m.PocValidationSnapshotsPrunedEpoch != 0 {
 		n += 1 + sovPruningState(uint64(m.PocValidationSnapshotsPrunedEpoch))
 	}
+	if m.ClaimRecipientsPrunedEpoch != 0 {
+		n += 1 + sovPruningState(uint64(m.ClaimRecipientsPrunedEpoch))
+	}
 	return n
 }
 
@@ -488,6 +506,25 @@ func (m *PruningState) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClaimRecipientsPrunedEpoch", wireType)
+			}
+			m.ClaimRecipientsPrunedEpoch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPruningState
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ClaimRecipientsPrunedEpoch |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPruningState(dAtA[iNdEx:])
diff --git a/inference-chain/x/inference/types/query.pb.go b/inference-chain/x/inference/types/query.pb.go
index 92263c01ba..bcd4c9f9ae 100644
--- a/inference-chain/x/inference/types/query.pb.go
+++ b/inference-chain/x/inference/types/query.pb.go
@@ -1059,6 +1059,94 @@ func (m *QueryAllSettleAmountResponse) GetPagination() *query.PageResponse {
 	return nil
 }
 
+type QueryEstimateBitcoinRewardRequest struct {
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+}
+
+func (m *QueryEstimateBitcoinRewardRequest) Reset()         { *m = QueryEstimateBitcoinRewardRequest{} }
+func (m *QueryEstimateBitcoinRewardRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryEstimateBitcoinRewardRequest) ProtoMessage()    {}
+func (*QueryEstimateBitcoinRewardRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{22}
+}
+func (m *QueryEstimateBitcoinRewardRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryEstimateBitcoinRewardRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryEstimateBitcoinRewardRequest.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 *QueryEstimateBitcoinRewardRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryEstimateBitcoinRewardRequest.Merge(m, src)
+}
+func (m *QueryEstimateBitcoinRewardRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryEstimateBitcoinRewardRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryEstimateBitcoinRewardRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryEstimateBitcoinRewardRequest proto.InternalMessageInfo
+
+func (m *QueryEstimateBitcoinRewardRequest) GetParticipant() string {
+	if m != nil {
+		return m.Participant
+	}
+	return ""
+}
+
+type QueryEstimateBitcoinRewardResponse struct {
+	SettleAmount SettleAmount `protobuf:"bytes,1,opt,name=settle_amount,json=settleAmount,proto3" json:"settle_amount"`
+}
+
+func (m *QueryEstimateBitcoinRewardResponse) Reset()         { *m = QueryEstimateBitcoinRewardResponse{} }
+func (m *QueryEstimateBitcoinRewardResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryEstimateBitcoinRewardResponse) ProtoMessage()    {}
+func (*QueryEstimateBitcoinRewardResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{23}
+}
+func (m *QueryEstimateBitcoinRewardResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryEstimateBitcoinRewardResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryEstimateBitcoinRewardResponse.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 *QueryEstimateBitcoinRewardResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryEstimateBitcoinRewardResponse.Merge(m, src)
+}
+func (m *QueryEstimateBitcoinRewardResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryEstimateBitcoinRewardResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryEstimateBitcoinRewardResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryEstimateBitcoinRewardResponse proto.InternalMessageInfo
+
+func (m *QueryEstimateBitcoinRewardResponse) GetSettleAmount() SettleAmount {
+	if m != nil {
+		return m.SettleAmount
+	}
+	return SettleAmount{}
+}
+
 type QueryGetEpochGroupValidationsRequest struct {
 	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 	EpochIndex  uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
@@ -1068,7 +1156,7 @@ func (m *QueryGetEpochGroupValidationsRequest) Reset()         { *m = QueryGetEp
 func (m *QueryGetEpochGroupValidationsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetEpochGroupValidationsRequest) ProtoMessage()    {}
 func (*QueryGetEpochGroupValidationsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{22}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{24}
 }
 func (m *QueryGetEpochGroupValidationsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1119,7 +1207,7 @@ func (m *QueryGetEpochGroupValidationsResponse) Reset()         { *m = QueryGetE
 func (m *QueryGetEpochGroupValidationsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetEpochGroupValidationsResponse) ProtoMessage()    {}
 func (*QueryGetEpochGroupValidationsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{23}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{25}
 }
 func (m *QueryGetEpochGroupValidationsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1163,7 +1251,7 @@ func (m *QueryAllEpochGroupValidationsRequest) Reset()         { *m = QueryAllEp
 func (m *QueryAllEpochGroupValidationsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllEpochGroupValidationsRequest) ProtoMessage()    {}
 func (*QueryAllEpochGroupValidationsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{24}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{26}
 }
 func (m *QueryAllEpochGroupValidationsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1208,7 +1296,7 @@ func (m *QueryAllEpochGroupValidationsResponse) Reset()         { *m = QueryAllE
 func (m *QueryAllEpochGroupValidationsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAllEpochGroupValidationsResponse) ProtoMessage()    {}
 func (*QueryAllEpochGroupValidationsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{25}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{27}
 }
 func (m *QueryAllEpochGroupValidationsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1259,7 +1347,7 @@ func (m *QueryPocBatchesForStageRequest) Reset()         { *m = QueryPocBatchesF
 func (m *QueryPocBatchesForStageRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPocBatchesForStageRequest) ProtoMessage()    {}
 func (*QueryPocBatchesForStageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{26}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{28}
 }
 func (m *QueryPocBatchesForStageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1303,7 +1391,7 @@ func (m *QueryPocBatchesForStageResponse) Reset()         { *m = QueryPocBatches
 func (m *QueryPocBatchesForStageResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPocBatchesForStageResponse) ProtoMessage()    {}
 func (*QueryPocBatchesForStageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{27}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{29}
 }
 func (m *QueryPocBatchesForStageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1350,7 +1438,7 @@ func (m *PoCBatchesWithParticipants) Reset()         { *m = PoCBatchesWithPartic
 func (m *PoCBatchesWithParticipants) String() string { return proto.CompactTextString(m) }
 func (*PoCBatchesWithParticipants) ProtoMessage()    {}
 func (*PoCBatchesWithParticipants) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{28}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{30}
 }
 func (m *PoCBatchesWithParticipants) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1415,7 +1503,7 @@ func (m *QueryPocValidationsForStageRequest) Reset()         { *m = QueryPocVali
 func (m *QueryPocValidationsForStageRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPocValidationsForStageRequest) ProtoMessage()    {}
 func (*QueryPocValidationsForStageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{29}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{31}
 }
 func (m *QueryPocValidationsForStageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1459,7 +1547,7 @@ func (m *QueryPocValidationsForStageResponse) Reset()         { *m = QueryPocVal
 func (m *QueryPocValidationsForStageResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPocValidationsForStageResponse) ProtoMessage()    {}
 func (*QueryPocValidationsForStageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{30}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{32}
 }
 func (m *QueryPocValidationsForStageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1506,7 +1594,7 @@ func (m *PoCValidationsWithParticipants) Reset()         { *m = PoCValidationsWi
 func (m *PoCValidationsWithParticipants) String() string { return proto.CompactTextString(m) }
 func (*PoCValidationsWithParticipants) ProtoMessage()    {}
 func (*PoCValidationsWithParticipants) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{31}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{33}
 }
 func (m *PoCValidationsWithParticipants) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1571,7 +1659,7 @@ func (m *QueryPocV2ValidationsForStageRequest) Reset()         { *m = QueryPocV2
 func (m *QueryPocV2ValidationsForStageRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPocV2ValidationsForStageRequest) ProtoMessage()    {}
 func (*QueryPocV2ValidationsForStageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{32}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{34}
 }
 func (m *QueryPocV2ValidationsForStageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1615,7 +1703,7 @@ func (m *QueryPocV2ValidationsForStageResponse) Reset()         { *m = QueryPocV
 func (m *QueryPocV2ValidationsForStageResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPocV2ValidationsForStageResponse) ProtoMessage()    {}
 func (*QueryPocV2ValidationsForStageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{33}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{35}
 }
 func (m *QueryPocV2ValidationsForStageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1663,7 +1751,7 @@ func (m *PoCValidationsWithParticipantsV2) Reset()         { *m = PoCValidations
 func (m *PoCValidationsWithParticipantsV2) String() string { return proto.CompactTextString(m) }
 func (*PoCValidationsWithParticipantsV2) ProtoMessage()    {}
 func (*PoCValidationsWithParticipantsV2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{34}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{36}
 }
 func (m *PoCValidationsWithParticipantsV2) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1738,7 +1826,7 @@ func (m *QueryPoCV2StoreCommitRequest) Reset()         { *m = QueryPoCV2StoreCom
 func (m *QueryPoCV2StoreCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPoCV2StoreCommitRequest) ProtoMessage()    {}
 func (*QueryPoCV2StoreCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{35}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{37}
 }
 func (m *QueryPoCV2StoreCommitRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1798,7 +1886,7 @@ func (m *QueryPoCV2StoreCommitResponse) Reset()         { *m = QueryPoCV2StoreCo
 func (m *QueryPoCV2StoreCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPoCV2StoreCommitResponse) ProtoMessage()    {}
 func (*QueryPoCV2StoreCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{36}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{38}
 }
 func (m *QueryPoCV2StoreCommitResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1858,7 +1946,7 @@ func (m *QueryMLNodeWeightDistributionRequest) Reset()         { *m = QueryMLNod
 func (m *QueryMLNodeWeightDistributionRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryMLNodeWeightDistributionRequest) ProtoMessage()    {}
 func (*QueryMLNodeWeightDistributionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{37}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{39}
 }
 func (m *QueryMLNodeWeightDistributionRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1917,7 +2005,7 @@ func (m *QueryMLNodeWeightDistributionResponse) Reset()         { *m = QueryMLNo
 func (m *QueryMLNodeWeightDistributionResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryMLNodeWeightDistributionResponse) ProtoMessage()    {}
 func (*QueryMLNodeWeightDistributionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{38}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{40}
 }
 func (m *QueryMLNodeWeightDistributionResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1970,7 +2058,7 @@ func (m *QueryAllPoCV2StoreCommitsForStageRequest) Reset() {
 func (m *QueryAllPoCV2StoreCommitsForStageRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllPoCV2StoreCommitsForStageRequest) ProtoMessage()    {}
 func (*QueryAllPoCV2StoreCommitsForStageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{39}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{41}
 }
 func (m *QueryAllPoCV2StoreCommitsForStageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2018,7 +2106,7 @@ func (m *QueryAllPoCV2StoreCommitsForStageResponse) String() string {
 }
 func (*QueryAllPoCV2StoreCommitsForStageResponse) ProtoMessage() {}
 func (*QueryAllPoCV2StoreCommitsForStageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{40}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{42}
 }
 func (m *QueryAllPoCV2StoreCommitsForStageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2066,7 +2154,7 @@ func (m *PoCV2StoreCommitWithAddress) Reset()         { *m = PoCV2StoreCommitWit
 func (m *PoCV2StoreCommitWithAddress) String() string { return proto.CompactTextString(m) }
 func (*PoCV2StoreCommitWithAddress) ProtoMessage()    {}
 func (*PoCV2StoreCommitWithAddress) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{41}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{43}
 }
 func (m *PoCV2StoreCommitWithAddress) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2142,7 +2230,7 @@ func (m *QueryAllMLNodeWeightDistributionsForStageRequest) String() string {
 }
 func (*QueryAllMLNodeWeightDistributionsForStageRequest) ProtoMessage() {}
 func (*QueryAllMLNodeWeightDistributionsForStageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{42}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{44}
 }
 func (m *QueryAllMLNodeWeightDistributionsForStageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2190,7 +2278,7 @@ func (m *QueryAllMLNodeWeightDistributionsForStageResponse) String() string {
 }
 func (*QueryAllMLNodeWeightDistributionsForStageResponse) ProtoMessage() {}
 func (*QueryAllMLNodeWeightDistributionsForStageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{43}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{45}
 }
 func (m *QueryAllMLNodeWeightDistributionsForStageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2236,7 +2324,7 @@ func (m *MLNodeWeightDistributionWithAddress) Reset()         { *m = MLNodeWeigh
 func (m *MLNodeWeightDistributionWithAddress) String() string { return proto.CompactTextString(m) }
 func (*MLNodeWeightDistributionWithAddress) ProtoMessage()    {}
 func (*MLNodeWeightDistributionWithAddress) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{44}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{46}
 }
 func (m *MLNodeWeightDistributionWithAddress) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2293,7 +2381,7 @@ func (m *QueryGetCurrentEpochRequest) Reset()         { *m = QueryGetCurrentEpoc
 func (m *QueryGetCurrentEpochRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetCurrentEpochRequest) ProtoMessage()    {}
 func (*QueryGetCurrentEpochRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{45}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{47}
 }
 func (m *QueryGetCurrentEpochRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2322,7 +2410,6 @@ func (m *QueryGetCurrentEpochRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryGetCurrentEpochRequest proto.InternalMessageInfo
 
-// DEPRECATED: ambiguous query, re-check what it expect as epoch: id, poc_start_block_height, or epoch_group_id
 type QueryGetCurrentEpochResponse struct {
 	Epoch uint64 `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
 }
@@ -2331,7 +2418,7 @@ func (m *QueryGetCurrentEpochResponse) Reset()         { *m = QueryGetCurrentEpo
 func (m *QueryGetCurrentEpochResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetCurrentEpochResponse) ProtoMessage()    {}
 func (*QueryGetCurrentEpochResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{46}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{48}
 }
 func (m *QueryGetCurrentEpochResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2374,7 +2461,7 @@ func (m *QueryGetTokenomicsDataRequest) Reset()         { *m = QueryGetTokenomic
 func (m *QueryGetTokenomicsDataRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetTokenomicsDataRequest) ProtoMessage()    {}
 func (*QueryGetTokenomicsDataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{47}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{49}
 }
 func (m *QueryGetTokenomicsDataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2411,7 +2498,7 @@ func (m *QueryGetTokenomicsDataResponse) Reset()         { *m = QueryGetTokenomi
 func (m *QueryGetTokenomicsDataResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetTokenomicsDataResponse) ProtoMessage()    {}
 func (*QueryGetTokenomicsDataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{48}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{50}
 }
 func (m *QueryGetTokenomicsDataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2459,7 +2546,7 @@ func (m *QueryGetUnitOfComputePriceProposalRequest) String() string {
 }
 func (*QueryGetUnitOfComputePriceProposalRequest) ProtoMessage() {}
 func (*QueryGetUnitOfComputePriceProposalRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{49}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{51}
 }
 func (m *QueryGetUnitOfComputePriceProposalRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2508,7 +2595,7 @@ func (m *QueryGetUnitOfComputePriceProposalResponse) String() string {
 }
 func (*QueryGetUnitOfComputePriceProposalResponse) ProtoMessage() {}
 func (*QueryGetUnitOfComputePriceProposalResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{50}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{52}
 }
 func (m *QueryGetUnitOfComputePriceProposalResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2558,7 +2645,7 @@ func (m *QueryCurrentEpochGroupDataRequest) Reset()         { *m = QueryCurrentE
 func (m *QueryCurrentEpochGroupDataRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCurrentEpochGroupDataRequest) ProtoMessage()    {}
 func (*QueryCurrentEpochGroupDataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{51}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{53}
 }
 func (m *QueryCurrentEpochGroupDataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2595,7 +2682,7 @@ func (m *QueryCurrentEpochGroupDataResponse) Reset()         { *m = QueryCurrent
 func (m *QueryCurrentEpochGroupDataResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCurrentEpochGroupDataResponse) ProtoMessage()    {}
 func (*QueryCurrentEpochGroupDataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{52}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{54}
 }
 func (m *QueryCurrentEpochGroupDataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2638,7 +2725,7 @@ func (m *QueryPreviousEpochGroupDataRequest) Reset()         { *m = QueryPreviou
 func (m *QueryPreviousEpochGroupDataRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPreviousEpochGroupDataRequest) ProtoMessage()    {}
 func (*QueryPreviousEpochGroupDataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{53}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{55}
 }
 func (m *QueryPreviousEpochGroupDataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2675,7 +2762,7 @@ func (m *QueryPreviousEpochGroupDataResponse) Reset()         { *m = QueryPrevio
 func (m *QueryPreviousEpochGroupDataResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPreviousEpochGroupDataResponse) ProtoMessage()    {}
 func (*QueryPreviousEpochGroupDataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{54}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{56}
 }
 func (m *QueryPreviousEpochGroupDataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2719,7 +2806,7 @@ func (m *QueryModelsAllRequest) Reset()         { *m = QueryModelsAllRequest{} }
 func (m *QueryModelsAllRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryModelsAllRequest) ProtoMessage()    {}
 func (*QueryModelsAllRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{55}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{57}
 }
 func (m *QueryModelsAllRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2764,7 +2851,7 @@ func (m *QueryModelsAllResponse) Reset()         { *m = QueryModelsAllResponse{}
 func (m *QueryModelsAllResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryModelsAllResponse) ProtoMessage()    {}
 func (*QueryModelsAllResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{56}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{58}
 }
 func (m *QueryModelsAllResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2816,7 +2903,7 @@ func (m *QueryGetInferenceTimeoutRequest) Reset()         { *m = QueryGetInferen
 func (m *QueryGetInferenceTimeoutRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetInferenceTimeoutRequest) ProtoMessage()    {}
 func (*QueryGetInferenceTimeoutRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{57}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{59}
 }
 func (m *QueryGetInferenceTimeoutRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2867,7 +2954,7 @@ func (m *QueryGetInferenceTimeoutResponse) Reset()         { *m = QueryGetInfere
 func (m *QueryGetInferenceTimeoutResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetInferenceTimeoutResponse) ProtoMessage()    {}
 func (*QueryGetInferenceTimeoutResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{58}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{60}
 }
 func (m *QueryGetInferenceTimeoutResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2911,7 +2998,7 @@ func (m *QueryAllInferenceTimeoutRequest) Reset()         { *m = QueryAllInferen
 func (m *QueryAllInferenceTimeoutRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllInferenceTimeoutRequest) ProtoMessage()    {}
 func (*QueryAllInferenceTimeoutRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{59}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{61}
 }
 func (m *QueryAllInferenceTimeoutRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2956,7 +3043,7 @@ func (m *QueryAllInferenceTimeoutResponse) Reset()         { *m = QueryAllInfere
 func (m *QueryAllInferenceTimeoutResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAllInferenceTimeoutResponse) ProtoMessage()    {}
 func (*QueryAllInferenceTimeoutResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{60}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{62}
 }
 func (m *QueryAllInferenceTimeoutResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3012,7 +3099,7 @@ func (m *QueryGetInferenceValidationDetailsRequest) String() string {
 }
 func (*QueryGetInferenceValidationDetailsRequest) ProtoMessage() {}
 func (*QueryGetInferenceValidationDetailsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{61}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{63}
 }
 func (m *QueryGetInferenceValidationDetailsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3067,7 +3154,7 @@ func (m *QueryGetInferenceValidationDetailsResponse) String() string {
 }
 func (*QueryGetInferenceValidationDetailsResponse) ProtoMessage() {}
 func (*QueryGetInferenceValidationDetailsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{62}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{64}
 }
 func (m *QueryGetInferenceValidationDetailsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3115,7 +3202,7 @@ func (m *QueryAllInferenceValidationDetailsRequest) String() string {
 }
 func (*QueryAllInferenceValidationDetailsRequest) ProtoMessage() {}
 func (*QueryAllInferenceValidationDetailsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{63}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{65}
 }
 func (m *QueryAllInferenceValidationDetailsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3164,7 +3251,7 @@ func (m *QueryAllInferenceValidationDetailsResponse) String() string {
 }
 func (*QueryAllInferenceValidationDetailsResponse) ProtoMessage() {}
 func (*QueryAllInferenceValidationDetailsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{64}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{66}
 }
 func (m *QueryAllInferenceValidationDetailsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3220,7 +3307,7 @@ func (m *QueryGetInferenceValidationParametersRequest) String() string {
 }
 func (*QueryGetInferenceValidationParametersRequest) ProtoMessage() {}
 func (*QueryGetInferenceValidationParametersRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{65}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{67}
 }
 func (m *QueryGetInferenceValidationParametersRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3278,7 +3365,7 @@ func (m *QueryGetInferenceValidationParametersResponse) String() string {
 }
 func (*QueryGetInferenceValidationParametersResponse) ProtoMessage() {}
 func (*QueryGetInferenceValidationParametersResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{66}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{68}
 }
 func (m *QueryGetInferenceValidationParametersResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3344,7 +3431,7 @@ func (m *ValidatorPower) Reset()         { *m = ValidatorPower{} }
 func (m *ValidatorPower) String() string { return proto.CompactTextString(m) }
 func (*ValidatorPower) ProtoMessage()    {}
 func (*ValidatorPower) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{67}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{69}
 }
 func (m *ValidatorPower) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3399,7 +3486,7 @@ func (m *QueryEpochPerformanceSummaryByEpochRequest) String() string {
 }
 func (*QueryEpochPerformanceSummaryByEpochRequest) ProtoMessage() {}
 func (*QueryEpochPerformanceSummaryByEpochRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{68}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{70}
 }
 func (m *QueryEpochPerformanceSummaryByEpochRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3447,7 +3534,7 @@ func (m *QueryEpochPerformanceSummaryByEpochResponse) String() string {
 }
 func (*QueryEpochPerformanceSummaryByEpochResponse) ProtoMessage() {}
 func (*QueryEpochPerformanceSummaryByEpochResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{69}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{71}
 }
 func (m *QueryEpochPerformanceSummaryByEpochResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3496,7 +3583,7 @@ func (m *QueryEpochPerformanceSummaryByParticipantRequest) String() string {
 }
 func (*QueryEpochPerformanceSummaryByParticipantRequest) ProtoMessage() {}
 func (*QueryEpochPerformanceSummaryByParticipantRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{70}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{72}
 }
 func (m *QueryEpochPerformanceSummaryByParticipantRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3551,7 +3638,7 @@ func (m *QueryEpochPerformanceSummaryByParticipantResponse) String() string {
 }
 func (*QueryEpochPerformanceSummaryByParticipantResponse) ProtoMessage() {}
 func (*QueryEpochPerformanceSummaryByParticipantResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{71}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{73}
 }
 func (m *QueryEpochPerformanceSummaryByParticipantResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3597,7 +3684,7 @@ func (m *QueryAllEpochPerformanceSummaryRequest) Reset() {
 func (m *QueryAllEpochPerformanceSummaryRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllEpochPerformanceSummaryRequest) ProtoMessage()    {}
 func (*QueryAllEpochPerformanceSummaryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{72}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{74}
 }
 func (m *QueryAllEpochPerformanceSummaryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3644,7 +3731,7 @@ func (m *QueryAllEpochPerformanceSummaryResponse) Reset() {
 func (m *QueryAllEpochPerformanceSummaryResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAllEpochPerformanceSummaryResponse) ProtoMessage()    {}
 func (*QueryAllEpochPerformanceSummaryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{73}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{75}
 }
 func (m *QueryAllEpochPerformanceSummaryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3695,7 +3782,7 @@ func (m *QueryHardwareNodesRequest) Reset()         { *m = QueryHardwareNodesReq
 func (m *QueryHardwareNodesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryHardwareNodesRequest) ProtoMessage()    {}
 func (*QueryHardwareNodesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{74}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{76}
 }
 func (m *QueryHardwareNodesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3739,7 +3826,7 @@ func (m *QueryHardwareNodesResponse) Reset()         { *m = QueryHardwareNodesRe
 func (m *QueryHardwareNodesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryHardwareNodesResponse) ProtoMessage()    {}
 func (*QueryHardwareNodesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{75}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{77}
 }
 func (m *QueryHardwareNodesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3782,7 +3869,7 @@ func (m *QueryHardwareNodesAllRequest) Reset()         { *m = QueryHardwareNodes
 func (m *QueryHardwareNodesAllRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryHardwareNodesAllRequest) ProtoMessage()    {}
 func (*QueryHardwareNodesAllRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{76}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{78}
 }
 func (m *QueryHardwareNodesAllRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3819,7 +3906,7 @@ func (m *QueryHardwareNodesAllResponse) Reset()         { *m = QueryHardwareNode
 func (m *QueryHardwareNodesAllResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryHardwareNodesAllResponse) ProtoMessage()    {}
 func (*QueryHardwareNodesAllResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{77}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{79}
 }
 func (m *QueryHardwareNodesAllResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3865,7 +3952,7 @@ func (m *QueryGetParticipantCurrentStatsRequest) Reset() {
 func (m *QueryGetParticipantCurrentStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetParticipantCurrentStatsRequest) ProtoMessage()    {}
 func (*QueryGetParticipantCurrentStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{78}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{80}
 }
 func (m *QueryGetParticipantCurrentStatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3912,7 +3999,7 @@ func (m *QueryGetParticipantCurrentStatsResponse) Reset() {
 func (m *QueryGetParticipantCurrentStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetParticipantCurrentStatsResponse) ProtoMessage()    {}
 func (*QueryGetParticipantCurrentStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{79}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{81}
 }
 func (m *QueryGetParticipantCurrentStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3966,7 +4053,7 @@ func (m *QueryGetAllParticipantCurrentStatsRequest) String() string {
 }
 func (*QueryGetAllParticipantCurrentStatsRequest) ProtoMessage() {}
 func (*QueryGetAllParticipantCurrentStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{80}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{82}
 }
 func (m *QueryGetAllParticipantCurrentStatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4009,7 +4096,7 @@ func (m *QueryGetAllParticipantCurrentStatsResponse) String() string {
 }
 func (*QueryGetAllParticipantCurrentStatsResponse) ProtoMessage() {}
 func (*QueryGetAllParticipantCurrentStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{81}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{83}
 }
 func (m *QueryGetAllParticipantCurrentStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4071,7 +4158,7 @@ func (m *ParticipantCurrentStats) Reset()         { *m = ParticipantCurrentStats
 func (m *ParticipantCurrentStats) String() string { return proto.CompactTextString(m) }
 func (*ParticipantCurrentStats) ProtoMessage()    {}
 func (*ParticipantCurrentStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{82}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{84}
 }
 func (m *ParticipantCurrentStats) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4148,7 +4235,7 @@ func (m *ParticipantFullStats) Reset()         { *m = ParticipantFullStats{} }
 func (m *ParticipantFullStats) String() string { return proto.CompactTextString(m) }
 func (*ParticipantFullStats) ProtoMessage()    {}
 func (*ParticipantFullStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{83}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{85}
 }
 func (m *ParticipantFullStats) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4226,7 +4313,7 @@ func (m *QueryParticipantsFullStatsRequest) Reset()         { *m = QueryParticip
 func (m *QueryParticipantsFullStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParticipantsFullStatsRequest) ProtoMessage()    {}
 func (*QueryParticipantsFullStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{84}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{86}
 }
 func (m *QueryParticipantsFullStatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4263,7 +4350,7 @@ func (m *QueryParticipantsFullStatsResponse) Reset()         { *m = QueryPartici
 func (m *QueryParticipantsFullStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParticipantsFullStatsResponse) ProtoMessage()    {}
 func (*QueryParticipantsFullStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{85}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{87}
 }
 func (m *QueryParticipantsFullStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4311,7 +4398,7 @@ func (m *QueryStatsByTimePeriodByDeveloperRequest) Reset() {
 func (m *QueryStatsByTimePeriodByDeveloperRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryStatsByTimePeriodByDeveloperRequest) ProtoMessage()    {}
 func (*QueryStatsByTimePeriodByDeveloperRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{86}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{88}
 }
 func (m *QueryStatsByTimePeriodByDeveloperRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4373,7 +4460,7 @@ func (m *QueryStatsByTimePeriodByDeveloperResponse) String() string {
 }
 func (*QueryStatsByTimePeriodByDeveloperResponse) ProtoMessage() {}
 func (*QueryStatsByTimePeriodByDeveloperResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{87}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{89}
 }
 func (m *QueryStatsByTimePeriodByDeveloperResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4422,7 +4509,7 @@ func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) String() string {
 }
 func (*QueryStatsByDeveloperAndEpochBackwardsRequest) ProtoMessage() {}
 func (*QueryStatsByDeveloperAndEpochBackwardsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{88}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{90}
 }
 func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4477,7 +4564,7 @@ func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) String() string
 }
 func (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest) ProtoMessage() {}
 func (*QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{89}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{91}
 }
 func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4526,7 +4613,7 @@ func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) String() string {
 }
 func (*QueryInferencesAndTokensStatsByTimePeriodRequest) ProtoMessage() {}
 func (*QueryInferencesAndTokensStatsByTimePeriodRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{90}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{92}
 }
 func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4582,7 +4669,7 @@ func (m *QueryInferencesAndTokensStatsByModelsRequest) String() string {
 }
 func (*QueryInferencesAndTokensStatsByModelsRequest) ProtoMessage() {}
 func (*QueryInferencesAndTokensStatsByModelsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{91}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{93}
 }
 func (m *QueryInferencesAndTokensStatsByModelsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4635,7 +4722,7 @@ func (m *ModelStats) Reset()         { *m = ModelStats{} }
 func (m *ModelStats) String() string { return proto.CompactTextString(m) }
 func (*ModelStats) ProtoMessage()    {}
 func (*ModelStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{92}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{94}
 }
 func (m *ModelStats) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4697,7 +4784,7 @@ func (m *QueryInferencesAndTokensStatsByModelsResponse) String() string {
 }
 func (*QueryInferencesAndTokensStatsByModelsResponse) ProtoMessage() {}
 func (*QueryInferencesAndTokensStatsByModelsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{93}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{95}
 }
 func (m *QueryInferencesAndTokensStatsByModelsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4743,7 +4830,7 @@ func (m *QueryInferencesAndTokensStatsResponse) Reset()         { *m = QueryInfe
 func (m *QueryInferencesAndTokensStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryInferencesAndTokensStatsResponse) ProtoMessage()    {}
 func (*QueryInferencesAndTokensStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{94}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{96}
 }
 func (m *QueryInferencesAndTokensStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4800,7 +4887,7 @@ func (m *QueryCountAllParticipantsRequest) Reset()         { *m = QueryCountAllP
 func (m *QueryCountAllParticipantsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCountAllParticipantsRequest) ProtoMessage()    {}
 func (*QueryCountAllParticipantsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{95}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{97}
 }
 func (m *QueryCountAllParticipantsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4837,7 +4924,7 @@ func (m *QueryCountAllParticipantsResponse) Reset()         { *m = QueryCountAll
 func (m *QueryCountAllParticipantsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCountAllParticipantsResponse) ProtoMessage()    {}
 func (*QueryCountAllParticipantsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{96}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{98}
 }
 func (m *QueryCountAllParticipantsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4880,7 +4967,7 @@ func (m *QueryDebugStatsRequest) Reset()         { *m = QueryDebugStatsRequest{}
 func (m *QueryDebugStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryDebugStatsRequest) ProtoMessage()    {}
 func (*QueryDebugStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{97}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{99}
 }
 func (m *QueryDebugStatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4918,7 +5005,7 @@ func (m *QueryDebugStatsResponse) Reset()         { *m = QueryDebugStatsResponse
 func (m *QueryDebugStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryDebugStatsResponse) ProtoMessage()    {}
 func (*QueryDebugStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{98}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{100}
 }
 func (m *QueryDebugStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4974,7 +5061,7 @@ func (m *QueryDebugStatsResponse_TemporaryTimeStat) String() string {
 }
 func (*QueryDebugStatsResponse_TemporaryTimeStat) ProtoMessage() {}
 func (*QueryDebugStatsResponse_TemporaryTimeStat) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{98, 0}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{100, 0}
 }
 func (m *QueryDebugStatsResponse_TemporaryTimeStat) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5030,7 +5117,7 @@ func (m *QueryDebugStatsResponse_TemporaryEpochStat) String() string {
 }
 func (*QueryDebugStatsResponse_TemporaryEpochStat) ProtoMessage() {}
 func (*QueryDebugStatsResponse_TemporaryEpochStat) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{98, 1}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{100, 1}
 }
 func (m *QueryDebugStatsResponse_TemporaryEpochStat) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5082,7 +5169,7 @@ func (m *QueryGetMinimumValidationAverageRequest) Reset() {
 func (m *QueryGetMinimumValidationAverageRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetMinimumValidationAverageRequest) ProtoMessage()    {}
 func (*QueryGetMinimumValidationAverageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{99}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{101}
 }
 func (m *QueryGetMinimumValidationAverageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5123,7 +5210,7 @@ func (m *QueryGetMinimumValidationAverageResponse) Reset() {
 func (m *QueryGetMinimumValidationAverageResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetMinimumValidationAverageResponse) ProtoMessage()    {}
 func (*QueryGetMinimumValidationAverageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{100}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{102}
 }
 func (m *QueryGetMinimumValidationAverageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5181,7 +5268,7 @@ func (m *QueryGetPartialUpgradeRequest) Reset()         { *m = QueryGetPartialUp
 func (m *QueryGetPartialUpgradeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetPartialUpgradeRequest) ProtoMessage()    {}
 func (*QueryGetPartialUpgradeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{101}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{103}
 }
 func (m *QueryGetPartialUpgradeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5225,7 +5312,7 @@ func (m *QueryGetPartialUpgradeResponse) Reset()         { *m = QueryGetPartialU
 func (m *QueryGetPartialUpgradeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetPartialUpgradeResponse) ProtoMessage()    {}
 func (*QueryGetPartialUpgradeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{102}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{104}
 }
 func (m *QueryGetPartialUpgradeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5269,7 +5356,7 @@ func (m *QueryAllPartialUpgradeRequest) Reset()         { *m = QueryAllPartialUp
 func (m *QueryAllPartialUpgradeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllPartialUpgradeRequest) ProtoMessage()    {}
 func (*QueryAllPartialUpgradeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{103}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{105}
 }
 func (m *QueryAllPartialUpgradeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5314,7 +5401,7 @@ func (m *QueryAllPartialUpgradeResponse) Reset()         { *m = QueryAllPartialU
 func (m *QueryAllPartialUpgradeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAllPartialUpgradeResponse) ProtoMessage()    {}
 func (*QueryAllPartialUpgradeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{104}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{106}
 }
 func (m *QueryAllPartialUpgradeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5367,7 +5454,7 @@ func (m *QueryGetBridgeTransactionRequest) Reset()         { *m = QueryGetBridge
 func (m *QueryGetBridgeTransactionRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetBridgeTransactionRequest) ProtoMessage()    {}
 func (*QueryGetBridgeTransactionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{105}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{107}
 }
 func (m *QueryGetBridgeTransactionRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5425,7 +5512,7 @@ func (m *QueryGetBridgeTransactionResponse) Reset()         { *m = QueryGetBridg
 func (m *QueryGetBridgeTransactionResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetBridgeTransactionResponse) ProtoMessage()    {}
 func (*QueryGetBridgeTransactionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{106}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{108}
 }
 func (m *QueryGetBridgeTransactionResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5469,7 +5556,7 @@ func (m *QueryAllBridgeTransactionsRequest) Reset()         { *m = QueryAllBridg
 func (m *QueryAllBridgeTransactionsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllBridgeTransactionsRequest) ProtoMessage()    {}
 func (*QueryAllBridgeTransactionsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{107}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{109}
 }
 func (m *QueryAllBridgeTransactionsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5514,7 +5601,7 @@ func (m *QueryAllBridgeTransactionsResponse) Reset()         { *m = QueryAllBrid
 func (m *QueryAllBridgeTransactionsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAllBridgeTransactionsResponse) ProtoMessage()    {}
 func (*QueryAllBridgeTransactionsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{108}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{110}
 }
 func (m *QueryAllBridgeTransactionsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5569,7 +5656,7 @@ func (m *WrappedTokenBalance) Reset()         { *m = WrappedTokenBalance{} }
 func (m *WrappedTokenBalance) String() string { return proto.CompactTextString(m) }
 func (*WrappedTokenBalance) ProtoMessage()    {}
 func (*WrappedTokenBalance) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{109}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{111}
 }
 func (m *WrappedTokenBalance) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5641,7 +5728,7 @@ func (m *QueryWrappedTokenBalancesRequest) Reset()         { *m = QueryWrappedTo
 func (m *QueryWrappedTokenBalancesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryWrappedTokenBalancesRequest) ProtoMessage()    {}
 func (*QueryWrappedTokenBalancesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{110}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{112}
 }
 func (m *QueryWrappedTokenBalancesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5685,7 +5772,7 @@ func (m *QueryWrappedTokenBalancesResponse) Reset()         { *m = QueryWrappedT
 func (m *QueryWrappedTokenBalancesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryWrappedTokenBalancesResponse) ProtoMessage()    {}
 func (*QueryWrappedTokenBalancesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{111}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{113}
 }
 func (m *QueryWrappedTokenBalancesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5729,7 +5816,7 @@ func (m *QueryBridgeAddressesByChainRequest) Reset()         { *m = QueryBridgeA
 func (m *QueryBridgeAddressesByChainRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryBridgeAddressesByChainRequest) ProtoMessage()    {}
 func (*QueryBridgeAddressesByChainRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{112}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{114}
 }
 func (m *QueryBridgeAddressesByChainRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5773,7 +5860,7 @@ func (m *QueryBridgeAddressesByChainResponse) Reset()         { *m = QueryBridge
 func (m *QueryBridgeAddressesByChainResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryBridgeAddressesByChainResponse) ProtoMessage()    {}
 func (*QueryBridgeAddressesByChainResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{113}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{115}
 }
 func (m *QueryBridgeAddressesByChainResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5819,7 +5906,7 @@ func (m *QueryValidateWrappedTokenForTradeRequest) Reset() {
 func (m *QueryValidateWrappedTokenForTradeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryValidateWrappedTokenForTradeRequest) ProtoMessage()    {}
 func (*QueryValidateWrappedTokenForTradeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{114}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{116}
 }
 func (m *QueryValidateWrappedTokenForTradeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5867,7 +5954,7 @@ func (m *QueryValidateWrappedTokenForTradeResponse) String() string {
 }
 func (*QueryValidateWrappedTokenForTradeResponse) ProtoMessage() {}
 func (*QueryValidateWrappedTokenForTradeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{115}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{117}
 }
 func (m *QueryValidateWrappedTokenForTradeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5911,7 +5998,7 @@ func (m *QueryValidateIbcTokenForTradeRequest) Reset()         { *m = QueryValid
 func (m *QueryValidateIbcTokenForTradeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryValidateIbcTokenForTradeRequest) ProtoMessage()    {}
 func (*QueryValidateIbcTokenForTradeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{116}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{118}
 }
 func (m *QueryValidateIbcTokenForTradeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5956,7 +6043,7 @@ func (m *QueryValidateIbcTokenForTradeResponse) Reset()         { *m = QueryVali
 func (m *QueryValidateIbcTokenForTradeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryValidateIbcTokenForTradeResponse) ProtoMessage()    {}
 func (*QueryValidateIbcTokenForTradeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{117}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{119}
 }
 func (m *QueryValidateIbcTokenForTradeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6006,7 +6093,7 @@ func (m *QueryLiquidityPoolRequest) Reset()         { *m = QueryLiquidityPoolReq
 func (m *QueryLiquidityPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryLiquidityPoolRequest) ProtoMessage()    {}
 func (*QueryLiquidityPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{118}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{120}
 }
 func (m *QueryLiquidityPoolRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6045,7 +6132,7 @@ func (m *QueryLiquidityPoolResponse) Reset()         { *m = QueryLiquidityPoolRe
 func (m *QueryLiquidityPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryLiquidityPoolResponse) ProtoMessage()    {}
 func (*QueryLiquidityPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{119}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{121}
 }
 func (m *QueryLiquidityPoolResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6102,7 +6189,7 @@ func (m *QueryEpochInfoRequest) Reset()         { *m = QueryEpochInfoRequest{} }
 func (m *QueryEpochInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochInfoRequest) ProtoMessage()    {}
 func (*QueryEpochInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{120}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{122}
 }
 func (m *QueryEpochInfoRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6143,7 +6230,7 @@ func (m *QueryEpochInfoResponse) Reset()         { *m = QueryEpochInfoResponse{}
 func (m *QueryEpochInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochInfoResponse) ProtoMessage()    {}
 func (*QueryEpochInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{121}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{123}
 }
 func (m *QueryEpochInfoResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6215,7 +6302,7 @@ func (m *QueryCountPoCbatchesAtHeightRequest) Reset()         { *m = QueryCountP
 func (m *QueryCountPoCbatchesAtHeightRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCountPoCbatchesAtHeightRequest) ProtoMessage()    {}
 func (*QueryCountPoCbatchesAtHeightRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{122}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{124}
 }
 func (m *QueryCountPoCbatchesAtHeightRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6259,7 +6346,7 @@ func (m *QueryCountPoCbatchesAtHeightResponse) Reset()         { *m = QueryCount
 func (m *QueryCountPoCbatchesAtHeightResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCountPoCbatchesAtHeightResponse) ProtoMessage()    {}
 func (*QueryCountPoCbatchesAtHeightResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{123}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{125}
 }
 func (m *QueryCountPoCbatchesAtHeightResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6305,7 +6392,7 @@ func (m *QueryCountPoCvalidationsAtHeightRequest) Reset() {
 func (m *QueryCountPoCvalidationsAtHeightRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCountPoCvalidationsAtHeightRequest) ProtoMessage()    {}
 func (*QueryCountPoCvalidationsAtHeightRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{124}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{126}
 }
 func (m *QueryCountPoCvalidationsAtHeightRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6351,7 +6438,7 @@ func (m *QueryCountPoCvalidationsAtHeightResponse) Reset() {
 func (m *QueryCountPoCvalidationsAtHeightResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCountPoCvalidationsAtHeightResponse) ProtoMessage()    {}
 func (*QueryCountPoCvalidationsAtHeightResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{125}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{127}
 }
 func (m *QueryCountPoCvalidationsAtHeightResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6394,7 +6481,7 @@ func (m *QueryApprovedTokensForTradeRequest) Reset()         { *m = QueryApprove
 func (m *QueryApprovedTokensForTradeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryApprovedTokensForTradeRequest) ProtoMessage()    {}
 func (*QueryApprovedTokensForTradeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{126}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{128}
 }
 func (m *QueryApprovedTokensForTradeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6431,7 +6518,7 @@ func (m *QueryApprovedTokensForTradeResponse) Reset()         { *m = QueryApprov
 func (m *QueryApprovedTokensForTradeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryApprovedTokensForTradeResponse) ProtoMessage()    {}
 func (*QueryApprovedTokensForTradeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{127}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{129}
 }
 func (m *QueryApprovedTokensForTradeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6476,7 +6563,7 @@ func (m *QueryGetModelPerTokenPriceRequest) Reset()         { *m = QueryGetModel
 func (m *QueryGetModelPerTokenPriceRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetModelPerTokenPriceRequest) ProtoMessage()    {}
 func (*QueryGetModelPerTokenPriceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{128}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{130}
 }
 func (m *QueryGetModelPerTokenPriceRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6521,7 +6608,7 @@ func (m *QueryGetModelPerTokenPriceResponse) Reset()         { *m = QueryGetMode
 func (m *QueryGetModelPerTokenPriceResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetModelPerTokenPriceResponse) ProtoMessage()    {}
 func (*QueryGetModelPerTokenPriceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{129}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{131}
 }
 func (m *QueryGetModelPerTokenPriceResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6571,7 +6658,7 @@ func (m *QueryGetAllModelPerTokenPricesRequest) Reset()         { *m = QueryGetA
 func (m *QueryGetAllModelPerTokenPricesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetAllModelPerTokenPricesRequest) ProtoMessage()    {}
 func (*QueryGetAllModelPerTokenPricesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{130}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{132}
 }
 func (m *QueryGetAllModelPerTokenPricesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6609,7 +6696,7 @@ func (m *ModelPrice) Reset()         { *m = ModelPrice{} }
 func (m *ModelPrice) String() string { return proto.CompactTextString(m) }
 func (*ModelPrice) ProtoMessage()    {}
 func (*ModelPrice) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{131}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{133}
 }
 func (m *ModelPrice) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6662,7 +6749,7 @@ func (m *QueryGetAllModelPerTokenPricesResponse) Reset() {
 func (m *QueryGetAllModelPerTokenPricesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetAllModelPerTokenPricesResponse) ProtoMessage()    {}
 func (*QueryGetAllModelPerTokenPricesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{132}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{134}
 }
 func (m *QueryGetAllModelPerTokenPricesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6706,7 +6793,7 @@ func (m *QueryGetModelCapacityRequest) Reset()         { *m = QueryGetModelCapac
 func (m *QueryGetModelCapacityRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetModelCapacityRequest) ProtoMessage()    {}
 func (*QueryGetModelCapacityRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{133}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{135}
 }
 func (m *QueryGetModelCapacityRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6751,7 +6838,7 @@ func (m *QueryGetModelCapacityResponse) Reset()         { *m = QueryGetModelCapa
 func (m *QueryGetModelCapacityResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetModelCapacityResponse) ProtoMessage()    {}
 func (*QueryGetModelCapacityResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{134}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{136}
 }
 func (m *QueryGetModelCapacityResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6801,7 +6888,7 @@ func (m *QueryGetAllModelCapacitiesRequest) Reset()         { *m = QueryGetAllMo
 func (m *QueryGetAllModelCapacitiesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetAllModelCapacitiesRequest) ProtoMessage()    {}
 func (*QueryGetAllModelCapacitiesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{135}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{137}
 }
 func (m *QueryGetAllModelCapacitiesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6838,7 +6925,7 @@ func (m *QueryGetAllModelCapacitiesResponse) Reset()         { *m = QueryGetAllM
 func (m *QueryGetAllModelCapacitiesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetAllModelCapacitiesResponse) ProtoMessage()    {}
 func (*QueryGetAllModelCapacitiesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{136}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{138}
 }
 func (m *QueryGetAllModelCapacitiesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6883,7 +6970,7 @@ func (m *ModelCapacity) Reset()         { *m = ModelCapacity{} }
 func (m *ModelCapacity) String() string { return proto.CompactTextString(m) }
 func (*ModelCapacity) ProtoMessage()    {}
 func (*ModelCapacity) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{137}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{139}
 }
 func (m *ModelCapacity) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6935,7 +7022,7 @@ func (m *QueryGranteesByMessageTypeRequest) Reset()         { *m = QueryGrantees
 func (m *QueryGranteesByMessageTypeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGranteesByMessageTypeRequest) ProtoMessage()    {}
 func (*QueryGranteesByMessageTypeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{138}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{140}
 }
 func (m *QueryGranteesByMessageTypeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -6987,7 +7074,7 @@ func (m *Grantee) Reset()         { *m = Grantee{} }
 func (m *Grantee) String() string { return proto.CompactTextString(m) }
 func (*Grantee) ProtoMessage()    {}
 func (*Grantee) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{139}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{141}
 }
 func (m *Grantee) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7038,7 +7125,7 @@ func (m *QueryGranteesByMessageTypeResponse) Reset()         { *m = QueryGrantee
 func (m *QueryGranteesByMessageTypeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGranteesByMessageTypeResponse) ProtoMessage()    {}
 func (*QueryGranteesByMessageTypeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{140}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{142}
 }
 func (m *QueryGranteesByMessageTypeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7081,7 +7168,7 @@ func (m *QueryParticipantAllowListRequest) Reset()         { *m = QueryParticipa
 func (m *QueryParticipantAllowListRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParticipantAllowListRequest) ProtoMessage()    {}
 func (*QueryParticipantAllowListRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{141}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{143}
 }
 func (m *QueryParticipantAllowListRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7118,7 +7205,7 @@ func (m *QueryParticipantAllowListResponse) Reset()         { *m = QueryParticip
 func (m *QueryParticipantAllowListResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParticipantAllowListResponse) ProtoMessage()    {}
 func (*QueryParticipantAllowListResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{142}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{144}
 }
 func (m *QueryParticipantAllowListResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7161,7 +7248,7 @@ func (m *QueryGetMLNodeVersionRequest) Reset()         { *m = QueryGetMLNodeVers
 func (m *QueryGetMLNodeVersionRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetMLNodeVersionRequest) ProtoMessage()    {}
 func (*QueryGetMLNodeVersionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{143}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{145}
 }
 func (m *QueryGetMLNodeVersionRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7198,7 +7285,7 @@ func (m *QueryGetMLNodeVersionResponse) Reset()         { *m = QueryGetMLNodeVer
 func (m *QueryGetMLNodeVersionResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetMLNodeVersionResponse) ProtoMessage()    {}
 func (*QueryGetMLNodeVersionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{144}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{146}
 }
 func (m *QueryGetMLNodeVersionResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7234,6 +7321,94 @@ func (m *QueryGetMLNodeVersionResponse) GetMlnodeVersion() MLNodeVersion {
 	return MLNodeVersion{}
 }
 
+type QueryGetLastUpgradeHeightRequest struct {
+}
+
+func (m *QueryGetLastUpgradeHeightRequest) Reset()         { *m = QueryGetLastUpgradeHeightRequest{} }
+func (m *QueryGetLastUpgradeHeightRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryGetLastUpgradeHeightRequest) ProtoMessage()    {}
+func (*QueryGetLastUpgradeHeightRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{147}
+}
+func (m *QueryGetLastUpgradeHeightRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryGetLastUpgradeHeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryGetLastUpgradeHeightRequest.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 *QueryGetLastUpgradeHeightRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryGetLastUpgradeHeightRequest.Merge(m, src)
+}
+func (m *QueryGetLastUpgradeHeightRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryGetLastUpgradeHeightRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryGetLastUpgradeHeightRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryGetLastUpgradeHeightRequest proto.InternalMessageInfo
+
+type QueryGetLastUpgradeHeightResponse struct {
+	LastUpgradeHeight int64 `protobuf:"varint,1,opt,name=last_upgrade_height,json=lastUpgradeHeight,proto3" json:"last_upgrade_height,omitempty"`
+	Found             bool  `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
+}
+
+func (m *QueryGetLastUpgradeHeightResponse) Reset()         { *m = QueryGetLastUpgradeHeightResponse{} }
+func (m *QueryGetLastUpgradeHeightResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryGetLastUpgradeHeightResponse) ProtoMessage()    {}
+func (*QueryGetLastUpgradeHeightResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{148}
+}
+func (m *QueryGetLastUpgradeHeightResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryGetLastUpgradeHeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryGetLastUpgradeHeightResponse.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 *QueryGetLastUpgradeHeightResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryGetLastUpgradeHeightResponse.Merge(m, src)
+}
+func (m *QueryGetLastUpgradeHeightResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryGetLastUpgradeHeightResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryGetLastUpgradeHeightResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryGetLastUpgradeHeightResponse proto.InternalMessageInfo
+
+func (m *QueryGetLastUpgradeHeightResponse) GetLastUpgradeHeight() int64 {
+	if m != nil {
+		return m.LastUpgradeHeight
+	}
+	return 0
+}
+
+func (m *QueryGetLastUpgradeHeightResponse) GetFound() bool {
+	if m != nil {
+		return m.Found
+	}
+	return false
+}
+
 // QueryExcludedParticipantsRequest requests excluded participants for an epoch.
 // If epoch_index is 0, the query should return for the current effective epoch.
 type QueryExcludedParticipantsRequest struct {
@@ -7244,7 +7419,7 @@ func (m *QueryExcludedParticipantsRequest) Reset()         { *m = QueryExcludedP
 func (m *QueryExcludedParticipantsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryExcludedParticipantsRequest) ProtoMessage()    {}
 func (*QueryExcludedParticipantsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{145}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{149}
 }
 func (m *QueryExcludedParticipantsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7289,7 +7464,7 @@ func (m *QueryExcludedParticipantsResponse) Reset()         { *m = QueryExcluded
 func (m *QueryExcludedParticipantsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryExcludedParticipantsResponse) ProtoMessage()    {}
 func (*QueryExcludedParticipantsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{146}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{150}
 }
 func (m *QueryExcludedParticipantsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7335,7 +7510,7 @@ func (m *QueryActiveConfirmationPoCEventRequest) Reset() {
 func (m *QueryActiveConfirmationPoCEventRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryActiveConfirmationPoCEventRequest) ProtoMessage()    {}
 func (*QueryActiveConfirmationPoCEventRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{147}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{151}
 }
 func (m *QueryActiveConfirmationPoCEventRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7376,7 +7551,7 @@ func (m *QueryActiveConfirmationPoCEventResponse) Reset() {
 func (m *QueryActiveConfirmationPoCEventResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryActiveConfirmationPoCEventResponse) ProtoMessage()    {}
 func (*QueryActiveConfirmationPoCEventResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{148}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{152}
 }
 func (m *QueryActiveConfirmationPoCEventResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7428,7 +7603,7 @@ func (m *QueryConfirmationPoCEventsRequest) Reset()         { *m = QueryConfirma
 func (m *QueryConfirmationPoCEventsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryConfirmationPoCEventsRequest) ProtoMessage()    {}
 func (*QueryConfirmationPoCEventsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{149}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{153}
 }
 func (m *QueryConfirmationPoCEventsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7473,7 +7648,7 @@ func (m *QueryConfirmationPoCEventsResponse) Reset()         { *m = QueryConfirm
 func (m *QueryConfirmationPoCEventsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryConfirmationPoCEventsResponse) ProtoMessage()    {}
 func (*QueryConfirmationPoCEventsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{150}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{154}
 }
 func (m *QueryConfirmationPoCEventsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7519,7 +7694,7 @@ func (m *ParticipantWithBalance) Reset()         { *m = ParticipantWithBalance{}
 func (m *ParticipantWithBalance) String() string { return proto.CompactTextString(m) }
 func (*ParticipantWithBalance) ProtoMessage()    {}
 func (*ParticipantWithBalance) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{151}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{155}
 }
 func (m *ParticipantWithBalance) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7571,7 +7746,7 @@ func (m *QueryParticipantsWithBalancesRequest) Reset()         { *m = QueryParti
 func (m *QueryParticipantsWithBalancesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParticipantsWithBalancesRequest) ProtoMessage()    {}
 func (*QueryParticipantsWithBalancesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{152}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{156}
 }
 func (m *QueryParticipantsWithBalancesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7618,7 +7793,7 @@ func (m *QueryParticipantsWithBalancesResponse) Reset()         { *m = QueryPart
 func (m *QueryParticipantsWithBalancesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParticipantsWithBalancesResponse) ProtoMessage()    {}
 func (*QueryParticipantsWithBalancesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{153}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{157}
 }
 func (m *QueryParticipantsWithBalancesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7677,7 +7852,7 @@ func (m *QueryRandomSeedsRequest) Reset()         { *m = QueryRandomSeedsRequest
 func (m *QueryRandomSeedsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryRandomSeedsRequest) ProtoMessage()    {}
 func (*QueryRandomSeedsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{154}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{158}
 }
 func (m *QueryRandomSeedsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7722,7 +7897,7 @@ func (m *QueryRandomSeedsResponse) Reset()         { *m = QueryRandomSeedsRespon
 func (m *QueryRandomSeedsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryRandomSeedsResponse) ProtoMessage()    {}
 func (*QueryRandomSeedsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{155}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{159}
 }
 func (m *QueryRandomSeedsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7766,7 +7941,7 @@ func (m *QueryPoCValidationSnapshotRequest) Reset()         { *m = QueryPoCValid
 func (m *QueryPoCValidationSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPoCValidationSnapshotRequest) ProtoMessage()    {}
 func (*QueryPoCValidationSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{156}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{160}
 }
 func (m *QueryPoCValidationSnapshotRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7811,7 +7986,7 @@ func (m *QueryPoCValidationSnapshotResponse) Reset()         { *m = QueryPoCVali
 func (m *QueryPoCValidationSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPoCValidationSnapshotResponse) ProtoMessage()    {}
 func (*QueryPoCValidationSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{157}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{161}
 }
 func (m *QueryPoCValidationSnapshotResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7861,7 +8036,7 @@ func (m *QueryPreservedNodesSnapshotRequest) Reset()         { *m = QueryPreserv
 func (m *QueryPreservedNodesSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPreservedNodesSnapshotRequest) ProtoMessage()    {}
 func (*QueryPreservedNodesSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{158}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{162}
 }
 func (m *QueryPreservedNodesSnapshotRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7899,7 +8074,7 @@ func (m *QueryPreservedNodesSnapshotResponse) Reset()         { *m = QueryPreser
 func (m *QueryPreservedNodesSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPreservedNodesSnapshotResponse) ProtoMessage()    {}
 func (*QueryPreservedNodesSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{159}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{163}
 }
 func (m *QueryPreservedNodesSnapshotResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7950,7 +8125,7 @@ func (m *QueryGetDevshardEscrowRequest) Reset()         { *m = QueryGetDevshardE
 func (m *QueryGetDevshardEscrowRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetDevshardEscrowRequest) ProtoMessage()    {}
 func (*QueryGetDevshardEscrowRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{160}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{164}
 }
 func (m *QueryGetDevshardEscrowRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -7995,7 +8170,7 @@ func (m *QueryGetDevshardEscrowResponse) Reset()         { *m = QueryGetDevshard
 func (m *QueryGetDevshardEscrowResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetDevshardEscrowResponse) ProtoMessage()    {}
 func (*QueryGetDevshardEscrowResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{161}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{165}
 }
 func (m *QueryGetDevshardEscrowResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -8047,7 +8222,7 @@ func (m *QueryGetDevshardHostEpochStatsRequest) Reset()         { *m = QueryGetD
 func (m *QueryGetDevshardHostEpochStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryGetDevshardHostEpochStatsRequest) ProtoMessage()    {}
 func (*QueryGetDevshardHostEpochStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{162}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{166}
 }
 func (m *QueryGetDevshardHostEpochStatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -8101,7 +8276,7 @@ func (m *QueryGetDevshardHostEpochStatsResponse) Reset() {
 func (m *QueryGetDevshardHostEpochStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryGetDevshardHostEpochStatsResponse) ProtoMessage()    {}
 func (*QueryGetDevshardHostEpochStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{163}
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{167}
 }
 func (m *QueryGetDevshardHostEpochStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -8144,1469 +8319,2312 @@ func (m *QueryGetDevshardHostEpochStatsResponse) GetFound() bool {
 	return false
 }
 
-func init() {
-	proto.RegisterType((*QueryParamsRequest)(nil), "inference.inference.QueryParamsRequest")
-	proto.RegisterType((*QueryParamsResponse)(nil), "inference.inference.QueryParamsResponse")
-	proto.RegisterType((*QueryGetInferenceRequest)(nil), "inference.inference.QueryGetInferenceRequest")
-	proto.RegisterType((*QueryGetInferenceResponse)(nil), "inference.inference.QueryGetInferenceResponse")
-	proto.RegisterType((*QueryAllInferenceRequest)(nil), "inference.inference.QueryAllInferenceRequest")
-	proto.RegisterType((*QueryAllInferenceResponse)(nil), "inference.inference.QueryAllInferenceResponse")
-	proto.RegisterType((*QueryGetParticipantRequest)(nil), "inference.inference.QueryGetParticipantRequest")
-	proto.RegisterType((*QueryGetParticipantResponse)(nil), "inference.inference.QueryGetParticipantResponse")
-	proto.RegisterType((*QueryAllParticipantRequest)(nil), "inference.inference.QueryAllParticipantRequest")
-	proto.RegisterType((*QueryAllParticipantResponse)(nil), "inference.inference.QueryAllParticipantResponse")
-	proto.RegisterType((*QueryAccountByAddressRequest)(nil), "inference.inference.QueryAccountByAddressRequest")
-	proto.RegisterType((*QueryAccountByAddressResponse)(nil), "inference.inference.QueryAccountByAddressResponse")
-	proto.RegisterType((*QueryGetRandomExecutorRequest)(nil), "inference.inference.QueryGetRandomExecutorRequest")
-	proto.RegisterType((*QueryGetRandomExecutorResponse)(nil), "inference.inference.QueryGetRandomExecutorResponse")
-	proto.RegisterType((*QueryGetEpochGroupDataRequest)(nil), "inference.inference.QueryGetEpochGroupDataRequest")
-	proto.RegisterType((*QueryGetEpochGroupDataResponse)(nil), "inference.inference.QueryGetEpochGroupDataResponse")
-	proto.RegisterType((*QueryAllEpochGroupDataRequest)(nil), "inference.inference.QueryAllEpochGroupDataRequest")
-	proto.RegisterType((*QueryAllEpochGroupDataResponse)(nil), "inference.inference.QueryAllEpochGroupDataResponse")
-	proto.RegisterType((*QueryGetSettleAmountRequest)(nil), "inference.inference.QueryGetSettleAmountRequest")
-	proto.RegisterType((*QueryGetSettleAmountResponse)(nil), "inference.inference.QueryGetSettleAmountResponse")
-	proto.RegisterType((*QueryAllSettleAmountRequest)(nil), "inference.inference.QueryAllSettleAmountRequest")
-	proto.RegisterType((*QueryAllSettleAmountResponse)(nil), "inference.inference.QueryAllSettleAmountResponse")
-	proto.RegisterType((*QueryGetEpochGroupValidationsRequest)(nil), "inference.inference.QueryGetEpochGroupValidationsRequest")
-	proto.RegisterType((*QueryGetEpochGroupValidationsResponse)(nil), "inference.inference.QueryGetEpochGroupValidationsResponse")
-	proto.RegisterType((*QueryAllEpochGroupValidationsRequest)(nil), "inference.inference.QueryAllEpochGroupValidationsRequest")
-	proto.RegisterType((*QueryAllEpochGroupValidationsResponse)(nil), "inference.inference.QueryAllEpochGroupValidationsResponse")
-	proto.RegisterType((*QueryPocBatchesForStageRequest)(nil), "inference.inference.QueryPocBatchesForStageRequest")
-	proto.RegisterType((*QueryPocBatchesForStageResponse)(nil), "inference.inference.QueryPocBatchesForStageResponse")
-	proto.RegisterType((*PoCBatchesWithParticipants)(nil), "inference.inference.PoCBatchesWithParticipants")
-	proto.RegisterType((*QueryPocValidationsForStageRequest)(nil), "inference.inference.QueryPocValidationsForStageRequest")
-	proto.RegisterType((*QueryPocValidationsForStageResponse)(nil), "inference.inference.QueryPocValidationsForStageResponse")
-	proto.RegisterType((*PoCValidationsWithParticipants)(nil), "inference.inference.PoCValidationsWithParticipants")
-	proto.RegisterType((*QueryPocV2ValidationsForStageRequest)(nil), "inference.inference.QueryPocV2ValidationsForStageRequest")
-	proto.RegisterType((*QueryPocV2ValidationsForStageResponse)(nil), "inference.inference.QueryPocV2ValidationsForStageResponse")
-	proto.RegisterType((*PoCValidationsWithParticipantsV2)(nil), "inference.inference.PoCValidationsWithParticipantsV2")
-	proto.RegisterType((*QueryPoCV2StoreCommitRequest)(nil), "inference.inference.QueryPoCV2StoreCommitRequest")
-	proto.RegisterType((*QueryPoCV2StoreCommitResponse)(nil), "inference.inference.QueryPoCV2StoreCommitResponse")
-	proto.RegisterType((*QueryMLNodeWeightDistributionRequest)(nil), "inference.inference.QueryMLNodeWeightDistributionRequest")
-	proto.RegisterType((*QueryMLNodeWeightDistributionResponse)(nil), "inference.inference.QueryMLNodeWeightDistributionResponse")
-	proto.RegisterType((*QueryAllPoCV2StoreCommitsForStageRequest)(nil), "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest")
-	proto.RegisterType((*QueryAllPoCV2StoreCommitsForStageResponse)(nil), "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse")
-	proto.RegisterType((*PoCV2StoreCommitWithAddress)(nil), "inference.inference.PoCV2StoreCommitWithAddress")
-	proto.RegisterType((*QueryAllMLNodeWeightDistributionsForStageRequest)(nil), "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest")
-	proto.RegisterType((*QueryAllMLNodeWeightDistributionsForStageResponse)(nil), "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse")
-	proto.RegisterType((*MLNodeWeightDistributionWithAddress)(nil), "inference.inference.MLNodeWeightDistributionWithAddress")
-	proto.RegisterType((*QueryGetCurrentEpochRequest)(nil), "inference.inference.QueryGetCurrentEpochRequest")
-	proto.RegisterType((*QueryGetCurrentEpochResponse)(nil), "inference.inference.QueryGetCurrentEpochResponse")
-	proto.RegisterType((*QueryGetTokenomicsDataRequest)(nil), "inference.inference.QueryGetTokenomicsDataRequest")
-	proto.RegisterType((*QueryGetTokenomicsDataResponse)(nil), "inference.inference.QueryGetTokenomicsDataResponse")
-	proto.RegisterType((*QueryGetUnitOfComputePriceProposalRequest)(nil), "inference.inference.QueryGetUnitOfComputePriceProposalRequest")
-	proto.RegisterType((*QueryGetUnitOfComputePriceProposalResponse)(nil), "inference.inference.QueryGetUnitOfComputePriceProposalResponse")
-	proto.RegisterType((*QueryCurrentEpochGroupDataRequest)(nil), "inference.inference.QueryCurrentEpochGroupDataRequest")
-	proto.RegisterType((*QueryCurrentEpochGroupDataResponse)(nil), "inference.inference.QueryCurrentEpochGroupDataResponse")
-	proto.RegisterType((*QueryPreviousEpochGroupDataRequest)(nil), "inference.inference.QueryPreviousEpochGroupDataRequest")
-	proto.RegisterType((*QueryPreviousEpochGroupDataResponse)(nil), "inference.inference.QueryPreviousEpochGroupDataResponse")
-	proto.RegisterType((*QueryModelsAllRequest)(nil), "inference.inference.QueryModelsAllRequest")
-	proto.RegisterType((*QueryModelsAllResponse)(nil), "inference.inference.QueryModelsAllResponse")
-	proto.RegisterType((*QueryGetInferenceTimeoutRequest)(nil), "inference.inference.QueryGetInferenceTimeoutRequest")
-	proto.RegisterType((*QueryGetInferenceTimeoutResponse)(nil), "inference.inference.QueryGetInferenceTimeoutResponse")
-	proto.RegisterType((*QueryAllInferenceTimeoutRequest)(nil), "inference.inference.QueryAllInferenceTimeoutRequest")
-	proto.RegisterType((*QueryAllInferenceTimeoutResponse)(nil), "inference.inference.QueryAllInferenceTimeoutResponse")
-	proto.RegisterType((*QueryGetInferenceValidationDetailsRequest)(nil), "inference.inference.QueryGetInferenceValidationDetailsRequest")
-	proto.RegisterType((*QueryGetInferenceValidationDetailsResponse)(nil), "inference.inference.QueryGetInferenceValidationDetailsResponse")
-	proto.RegisterType((*QueryAllInferenceValidationDetailsRequest)(nil), "inference.inference.QueryAllInferenceValidationDetailsRequest")
-	proto.RegisterType((*QueryAllInferenceValidationDetailsResponse)(nil), "inference.inference.QueryAllInferenceValidationDetailsResponse")
-	proto.RegisterType((*QueryGetInferenceValidationParametersRequest)(nil), "inference.inference.QueryGetInferenceValidationParametersRequest")
-	proto.RegisterType((*QueryGetInferenceValidationParametersResponse)(nil), "inference.inference.QueryGetInferenceValidationParametersResponse")
-	proto.RegisterType((*ValidatorPower)(nil), "inference.inference.ValidatorPower")
-	proto.RegisterType((*QueryEpochPerformanceSummaryByEpochRequest)(nil), "inference.inference.QueryEpochPerformanceSummaryByEpochRequest")
-	proto.RegisterType((*QueryEpochPerformanceSummaryByEpochResponse)(nil), "inference.inference.QueryEpochPerformanceSummaryByEpochResponse")
-	proto.RegisterType((*QueryEpochPerformanceSummaryByParticipantRequest)(nil), "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest")
-	proto.RegisterType((*QueryEpochPerformanceSummaryByParticipantResponse)(nil), "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse")
-	proto.RegisterType((*QueryAllEpochPerformanceSummaryRequest)(nil), "inference.inference.QueryAllEpochPerformanceSummaryRequest")
-	proto.RegisterType((*QueryAllEpochPerformanceSummaryResponse)(nil), "inference.inference.QueryAllEpochPerformanceSummaryResponse")
-	proto.RegisterType((*QueryHardwareNodesRequest)(nil), "inference.inference.QueryHardwareNodesRequest")
-	proto.RegisterType((*QueryHardwareNodesResponse)(nil), "inference.inference.QueryHardwareNodesResponse")
-	proto.RegisterType((*QueryHardwareNodesAllRequest)(nil), "inference.inference.QueryHardwareNodesAllRequest")
-	proto.RegisterType((*QueryHardwareNodesAllResponse)(nil), "inference.inference.QueryHardwareNodesAllResponse")
-	proto.RegisterType((*QueryGetParticipantCurrentStatsRequest)(nil), "inference.inference.QueryGetParticipantCurrentStatsRequest")
-	proto.RegisterType((*QueryGetParticipantCurrentStatsResponse)(nil), "inference.inference.QueryGetParticipantCurrentStatsResponse")
-	proto.RegisterType((*QueryGetAllParticipantCurrentStatsRequest)(nil), "inference.inference.QueryGetAllParticipantCurrentStatsRequest")
-	proto.RegisterType((*QueryGetAllParticipantCurrentStatsResponse)(nil), "inference.inference.QueryGetAllParticipantCurrentStatsResponse")
-	proto.RegisterType((*ParticipantCurrentStats)(nil), "inference.inference.ParticipantCurrentStats")
-	proto.RegisterType((*ParticipantFullStats)(nil), "inference.inference.ParticipantFullStats")
-	proto.RegisterType((*QueryParticipantsFullStatsRequest)(nil), "inference.inference.QueryParticipantsFullStatsRequest")
-	proto.RegisterType((*QueryParticipantsFullStatsResponse)(nil), "inference.inference.QueryParticipantsFullStatsResponse")
-	proto.RegisterType((*QueryStatsByTimePeriodByDeveloperRequest)(nil), "inference.inference.QueryStatsByTimePeriodByDeveloperRequest")
-	proto.RegisterType((*QueryStatsByTimePeriodByDeveloperResponse)(nil), "inference.inference.QueryStatsByTimePeriodByDeveloperResponse")
-	proto.RegisterType((*QueryStatsByDeveloperAndEpochBackwardsRequest)(nil), "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest")
-	proto.RegisterType((*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil), "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest")
-	proto.RegisterType((*QueryInferencesAndTokensStatsByTimePeriodRequest)(nil), "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest")
-	proto.RegisterType((*QueryInferencesAndTokensStatsByModelsRequest)(nil), "inference.inference.QueryInferencesAndTokensStatsByModelsRequest")
-	proto.RegisterType((*ModelStats)(nil), "inference.inference.ModelStats")
-	proto.RegisterType((*QueryInferencesAndTokensStatsByModelsResponse)(nil), "inference.inference.QueryInferencesAndTokensStatsByModelsResponse")
-	proto.RegisterType((*QueryInferencesAndTokensStatsResponse)(nil), "inference.inference.QueryInferencesAndTokensStatsResponse")
-	proto.RegisterType((*QueryCountAllParticipantsRequest)(nil), "inference.inference.QueryCountAllParticipantsRequest")
-	proto.RegisterType((*QueryCountAllParticipantsResponse)(nil), "inference.inference.QueryCountAllParticipantsResponse")
-	proto.RegisterType((*QueryDebugStatsRequest)(nil), "inference.inference.QueryDebugStatsRequest")
-	proto.RegisterType((*QueryDebugStatsResponse)(nil), "inference.inference.QueryDebugStatsResponse")
-	proto.RegisterType((*QueryDebugStatsResponse_TemporaryTimeStat)(nil), "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat")
-	proto.RegisterType((*QueryDebugStatsResponse_TemporaryEpochStat)(nil), "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat")
-	proto.RegisterType((*QueryGetMinimumValidationAverageRequest)(nil), "inference.inference.QueryGetMinimumValidationAverageRequest")
-	proto.RegisterType((*QueryGetMinimumValidationAverageResponse)(nil), "inference.inference.QueryGetMinimumValidationAverageResponse")
-	proto.RegisterType((*QueryGetPartialUpgradeRequest)(nil), "inference.inference.QueryGetPartialUpgradeRequest")
-	proto.RegisterType((*QueryGetPartialUpgradeResponse)(nil), "inference.inference.QueryGetPartialUpgradeResponse")
-	proto.RegisterType((*QueryAllPartialUpgradeRequest)(nil), "inference.inference.QueryAllPartialUpgradeRequest")
-	proto.RegisterType((*QueryAllPartialUpgradeResponse)(nil), "inference.inference.QueryAllPartialUpgradeResponse")
-	proto.RegisterType((*QueryGetBridgeTransactionRequest)(nil), "inference.inference.QueryGetBridgeTransactionRequest")
-	proto.RegisterType((*QueryGetBridgeTransactionResponse)(nil), "inference.inference.QueryGetBridgeTransactionResponse")
-	proto.RegisterType((*QueryAllBridgeTransactionsRequest)(nil), "inference.inference.QueryAllBridgeTransactionsRequest")
-	proto.RegisterType((*QueryAllBridgeTransactionsResponse)(nil), "inference.inference.QueryAllBridgeTransactionsResponse")
-	proto.RegisterType((*WrappedTokenBalance)(nil), "inference.inference.WrappedTokenBalance")
-	proto.RegisterType((*QueryWrappedTokenBalancesRequest)(nil), "inference.inference.QueryWrappedTokenBalancesRequest")
-	proto.RegisterType((*QueryWrappedTokenBalancesResponse)(nil), "inference.inference.QueryWrappedTokenBalancesResponse")
-	proto.RegisterType((*QueryBridgeAddressesByChainRequest)(nil), "inference.inference.QueryBridgeAddressesByChainRequest")
-	proto.RegisterType((*QueryBridgeAddressesByChainResponse)(nil), "inference.inference.QueryBridgeAddressesByChainResponse")
-	proto.RegisterType((*QueryValidateWrappedTokenForTradeRequest)(nil), "inference.inference.QueryValidateWrappedTokenForTradeRequest")
-	proto.RegisterType((*QueryValidateWrappedTokenForTradeResponse)(nil), "inference.inference.QueryValidateWrappedTokenForTradeResponse")
-	proto.RegisterType((*QueryValidateIbcTokenForTradeRequest)(nil), "inference.inference.QueryValidateIbcTokenForTradeRequest")
-	proto.RegisterType((*QueryValidateIbcTokenForTradeResponse)(nil), "inference.inference.QueryValidateIbcTokenForTradeResponse")
-	proto.RegisterType((*QueryLiquidityPoolRequest)(nil), "inference.inference.QueryLiquidityPoolRequest")
-	proto.RegisterType((*QueryLiquidityPoolResponse)(nil), "inference.inference.QueryLiquidityPoolResponse")
-	proto.RegisterType((*QueryEpochInfoRequest)(nil), "inference.inference.QueryEpochInfoRequest")
-	proto.RegisterType((*QueryEpochInfoResponse)(nil), "inference.inference.QueryEpochInfoResponse")
-	proto.RegisterType((*QueryCountPoCbatchesAtHeightRequest)(nil), "inference.inference.QueryCountPoCbatchesAtHeightRequest")
-	proto.RegisterType((*QueryCountPoCbatchesAtHeightResponse)(nil), "inference.inference.QueryCountPoCbatchesAtHeightResponse")
-	proto.RegisterType((*QueryCountPoCvalidationsAtHeightRequest)(nil), "inference.inference.QueryCountPoCvalidationsAtHeightRequest")
-	proto.RegisterType((*QueryCountPoCvalidationsAtHeightResponse)(nil), "inference.inference.QueryCountPoCvalidationsAtHeightResponse")
-	proto.RegisterType((*QueryApprovedTokensForTradeRequest)(nil), "inference.inference.QueryApprovedTokensForTradeRequest")
-	proto.RegisterType((*QueryApprovedTokensForTradeResponse)(nil), "inference.inference.QueryApprovedTokensForTradeResponse")
-	proto.RegisterType((*QueryGetModelPerTokenPriceRequest)(nil), "inference.inference.QueryGetModelPerTokenPriceRequest")
-	proto.RegisterType((*QueryGetModelPerTokenPriceResponse)(nil), "inference.inference.QueryGetModelPerTokenPriceResponse")
-	proto.RegisterType((*QueryGetAllModelPerTokenPricesRequest)(nil), "inference.inference.QueryGetAllModelPerTokenPricesRequest")
-	proto.RegisterType((*ModelPrice)(nil), "inference.inference.ModelPrice")
-	proto.RegisterType((*QueryGetAllModelPerTokenPricesResponse)(nil), "inference.inference.QueryGetAllModelPerTokenPricesResponse")
-	proto.RegisterType((*QueryGetModelCapacityRequest)(nil), "inference.inference.QueryGetModelCapacityRequest")
-	proto.RegisterType((*QueryGetModelCapacityResponse)(nil), "inference.inference.QueryGetModelCapacityResponse")
-	proto.RegisterType((*QueryGetAllModelCapacitiesRequest)(nil), "inference.inference.QueryGetAllModelCapacitiesRequest")
-	proto.RegisterType((*QueryGetAllModelCapacitiesResponse)(nil), "inference.inference.QueryGetAllModelCapacitiesResponse")
-	proto.RegisterType((*ModelCapacity)(nil), "inference.inference.ModelCapacity")
-	proto.RegisterType((*QueryGranteesByMessageTypeRequest)(nil), "inference.inference.QueryGranteesByMessageTypeRequest")
-	proto.RegisterType((*Grantee)(nil), "inference.inference.Grantee")
-	proto.RegisterType((*QueryGranteesByMessageTypeResponse)(nil), "inference.inference.QueryGranteesByMessageTypeResponse")
-	proto.RegisterType((*QueryParticipantAllowListRequest)(nil), "inference.inference.QueryParticipantAllowListRequest")
-	proto.RegisterType((*QueryParticipantAllowListResponse)(nil), "inference.inference.QueryParticipantAllowListResponse")
-	proto.RegisterType((*QueryGetMLNodeVersionRequest)(nil), "inference.inference.QueryGetMLNodeVersionRequest")
-	proto.RegisterType((*QueryGetMLNodeVersionResponse)(nil), "inference.inference.QueryGetMLNodeVersionResponse")
-	proto.RegisterType((*QueryExcludedParticipantsRequest)(nil), "inference.inference.QueryExcludedParticipantsRequest")
-	proto.RegisterType((*QueryExcludedParticipantsResponse)(nil), "inference.inference.QueryExcludedParticipantsResponse")
-	proto.RegisterType((*QueryActiveConfirmationPoCEventRequest)(nil), "inference.inference.QueryActiveConfirmationPoCEventRequest")
-	proto.RegisterType((*QueryActiveConfirmationPoCEventResponse)(nil), "inference.inference.QueryActiveConfirmationPoCEventResponse")
-	proto.RegisterType((*QueryConfirmationPoCEventsRequest)(nil), "inference.inference.QueryConfirmationPoCEventsRequest")
-	proto.RegisterType((*QueryConfirmationPoCEventsResponse)(nil), "inference.inference.QueryConfirmationPoCEventsResponse")
-	proto.RegisterType((*ParticipantWithBalance)(nil), "inference.inference.ParticipantWithBalance")
-	proto.RegisterType((*QueryParticipantsWithBalancesRequest)(nil), "inference.inference.QueryParticipantsWithBalancesRequest")
-	proto.RegisterType((*QueryParticipantsWithBalancesResponse)(nil), "inference.inference.QueryParticipantsWithBalancesResponse")
-	proto.RegisterType((*QueryRandomSeedsRequest)(nil), "inference.inference.QueryRandomSeedsRequest")
-	proto.RegisterType((*QueryRandomSeedsResponse)(nil), "inference.inference.QueryRandomSeedsResponse")
-	proto.RegisterType((*QueryPoCValidationSnapshotRequest)(nil), "inference.inference.QueryPoCValidationSnapshotRequest")
-	proto.RegisterType((*QueryPoCValidationSnapshotResponse)(nil), "inference.inference.QueryPoCValidationSnapshotResponse")
-	proto.RegisterType((*QueryPreservedNodesSnapshotRequest)(nil), "inference.inference.QueryPreservedNodesSnapshotRequest")
-	proto.RegisterType((*QueryPreservedNodesSnapshotResponse)(nil), "inference.inference.QueryPreservedNodesSnapshotResponse")
-	proto.RegisterType((*QueryGetDevshardEscrowRequest)(nil), "inference.inference.QueryGetDevshardEscrowRequest")
-	proto.RegisterType((*QueryGetDevshardEscrowResponse)(nil), "inference.inference.QueryGetDevshardEscrowResponse")
-	proto.RegisterType((*QueryGetDevshardHostEpochStatsRequest)(nil), "inference.inference.QueryGetDevshardHostEpochStatsRequest")
-	proto.RegisterType((*QueryGetDevshardHostEpochStatsResponse)(nil), "inference.inference.QueryGetDevshardHostEpochStatsResponse")
+type QueryMaintenanceCreditRequest struct {
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func init() { proto.RegisterFile("inference/inference/query.proto", fileDescriptor_cf0cfe3b0e1cc5bd) }
-
-var fileDescriptor_cf0cfe3b0e1cc5bd = []byte{
-	// 7085 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3d, 0x59, 0x8c, 0x1c, 0xc7,
-	0x75, 0xea, 0x59, 0x1e, 0xbb, 0xc5, 0xdd, 0xe5, 0xb2, 0x44, 0x91, 0xcb, 0x21, 0xb5, 0xa2, 0x8a,
-	0x94, 0x79, 0x49, 0x3b, 0xe2, 0xf2, 0x10, 0x29, 0x9e, 0x7b, 0xf0, 0x92, 0x48, 0x6a, 0x39, 0xbc,
-	0x24, 0xcb, 0x51, 0xbb, 0xb7, 0xa7, 0x77, 0xb7, 0xad, 0x9e, 0xe9, 0x51, 0x77, 0xcf, 0x92, 0xeb,
-	0xcd, 0xfa, 0x82, 0x01, 0x7f, 0x24, 0x41, 0x12, 0xf8, 0x2b, 0x76, 0x80, 0xc0, 0x48, 0x3e, 0x9c,
-	0x20, 0x08, 0x6c, 0x03, 0x36, 0x62, 0x47, 0x39, 0x01, 0x1b, 0x4e, 0x1c, 0x18, 0x76, 0x6c, 0x18,
-	0x4e, 0x10, 0xd8, 0x8e, 0x1c, 0xd8, 0x81, 0x1c, 0xc4, 0xce, 0x81, 0x7c, 0xe4, 0x23, 0x09, 0xba,
-	0xea, 0x55, 0x5f, 0x53, 0x55, 0xdd, 0x3d, 0xbb, 0x72, 0xf2, 0x43, 0xec, 0x54, 0x57, 0xbd, 0x7a,
-	0x47, 0x1d, 0xef, 0xbd, 0x7a, 0xef, 0x11, 0x3d, 0x61, 0xb7, 0xe6, 0x2d, 0xcf, 0x6a, 0x99, 0x56,
-	0x2d, 0xfe, 0xeb, 0x8d, 0x8e, 0xe5, 0x2d, 0x8f, 0xb7, 0x3d, 0x37, 0x70, 0xf1, 0xa3, 0x51, 0xf3,
-	0x78, 0xf4, 0x57, 0x75, 0x9b, 0xd1, 0xb4, 0x5b, 0x6e, 0x8d, 0xfe, 0xcb, 0xfa, 0x55, 0xb7, 0x2f,
-	0xb8, 0x0b, 0x2e, 0xfd, 0xb3, 0x16, 0xfe, 0x05, 0xad, 0x7b, 0x16, 0x5c, 0x77, 0xc1, 0xb1, 0x6a,
-	0x46, 0xdb, 0xae, 0x19, 0xad, 0x96, 0x1b, 0x18, 0x81, 0xed, 0xb6, 0x7c, 0xf8, 0x7a, 0xd8, 0x74,
-	0xfd, 0xa6, 0xeb, 0xd7, 0xe6, 0x0c, 0x1f, 0x26, 0xad, 0x2d, 0x1d, 0x9d, 0xb3, 0x02, 0xe3, 0x68,
-	0xad, 0x6d, 0x2c, 0xd8, 0x2d, 0xda, 0x19, 0xfa, 0xee, 0x15, 0x21, 0xda, 0x36, 0x3c, 0xa3, 0xc9,
-	0xa1, 0xed, 0x13, 0xf5, 0x88, 0xb1, 0x67, 0x9d, 0x9e, 0x92, 0x80, 0x09, 0x6c, 0xd3, 0x6e, 0x1b,
-	0xad, 0x80, 0x63, 0x26, 0xea, 0x66, 0xb5, 0x5d, 0x73, 0x51, 0x5f, 0xf0, 0xdc, 0x4e, 0x5b, 0x6f,
-	0x18, 0x81, 0x01, 0x7d, 0x0f, 0x88, 0xfa, 0xfa, 0x56, 0x10, 0x38, 0x96, 0x6e, 0x34, 0xdd, 0x4e,
-	0x04, 0xf4, 0x68, 0x1e, 0xd0, 0x25, 0xc3, 0xb1, 0x1b, 0x29, 0x0e, 0x11, 0x21, 0xba, 0xae, 0x39,
-	0x67, 0x04, 0xe6, 0x22, 0xf4, 0x39, 0x24, 0xea, 0x13, 0xb8, 0xaf, 0x5b, 0x2d, 0xb7, 0x69, 0x9b,
-	0x7e, 0x12, 0x55, 0x61, 0xd7, 0x4e, 0xcb, 0x0e, 0x74, 0x77, 0x5e, 0x37, 0xdd, 0x66, 0xbb, 0x13,
-	0x70, 0x46, 0x09, 0x17, 0x46, 0xd3, 0x6d, 0x58, 0x0e, 0x74, 0x18, 0x4b, 0x0a, 0x8f, 0x8b, 0xcd,
-	0x74, 0x6d, 0x2e, 0xb0, 0x23, 0x4a, 0x71, 0xe8, 0x81, 0xdd, 0xb4, 0xdc, 0x0e, 0x67, 0xcd, 0x49,
-	0x75, 0xe7, 0x98, 0x31, 0x7a, 0xc3, 0x0a, 0x0c, 0xdb, 0xe1, 0xfc, 0x39, 0x26, 0x67, 0x69, 0xdb,
-	0xf2, 0xe6, 0x5d, 0xaf, 0x69, 0x84, 0xe3, 0xfd, 0x4e, 0xb3, 0x69, 0xf0, 0x25, 0x2d, 0x16, 0xd8,
-	0xa2, 0xe1, 0x35, 0x1e, 0x18, 0x9e, 0xa5, 0xb7, 0xdc, 0x86, 0xa5, 0x62, 0x17, 0x5d, 0x2c, 0x86,
-	0xa3, 0x77, 0xda, 0x0b, 0x9e, 0x11, 0x75, 0x15, 0x2e, 0xcf, 0x39, 0xcf, 0x6e, 0x2c, 0x28, 0x81,
-	0xf9, 0x81, 0x11, 0xf8, 0x7a, 0xc3, 0x5a, 0xb2, 0x1c, 0xb7, 0x6d, 0x79, 0x2a, 0xde, 0x53, 0xaa,
-	0xa0, 0xc3, 0x41, 0xa1, 0x70, 0x9c, 0x10, 0x75, 0x7d, 0xc9, 0xf2, 0xfc, 0x78, 0xdb, 0x8c, 0x0b,
-	0x41, 0x3d, 0x34, 0x9d, 0x4e, 0xc3, 0x6a, 0xe8, 0xdd, 0x0b, 0xff, 0x59, 0x51, 0x7f, 0xd3, 0x6d,
-	0xcd, 0xdb, 0x5e, 0x93, 0x09, 0xa0, 0xed, 0x9a, 0xba, 0xb5, 0x64, 0x45, 0x23, 0x84, 0xb8, 0x38,
-	0xf6, 0x1b, 0x1d, 0xbb, 0x61, 0x07, 0xcb, 0x7a, 0xdb, 0x75, 0x1d, 0xe5, 0x16, 0x76, 0x4d, 0x7d,
-	0x69, 0x42, 0xb5, 0x3b, 0x3d, 0xa3, 0xd5, 0x70, 0x9b, 0xba, 0x6f, 0x59, 0x0d, 0xd5, 0x46, 0xa2,
-	0x80, 0xe2, 0x75, 0xe2, 0xb7, 0x8c, 0xb6, 0xbf, 0xe8, 0x06, 0x2a, 0xee, 0x37, 0xac, 0x25, 0x3f,
-	0x94, 0xbb, 0x6e, 0xf9, 0xa6, 0xe7, 0x3e, 0x80, 0xae, 0x13, 0x42, 0xe8, 0x9e, 0xe5, 0x5b, 0xde,
-	0x92, 0xd5, 0xa0, 0xeb, 0xc3, 0xcf, 0x82, 0x3f, 0x28, 0xc3, 0xa8, 0x61, 0x39, 0xd6, 0x42, 0xe2,
-	0x1c, 0x23, 0xdb, 0x11, 0xbe, 0x15, 0x9e, 0x74, 0xb3, 0xf4, 0xe8, 0xaa, 0x5b, 0x6f, 0x74, 0x2c,
-	0x3f, 0x20, 0x77, 0xd1, 0xa3, 0xa9, 0x56, 0xbf, 0xed, 0xb6, 0x7c, 0x0b, 0x9f, 0x47, 0x9b, 0xd8,
-	0x11, 0x37, 0xaa, 0xed, 0xd5, 0x0e, 0x6e, 0x99, 0xd8, 0x3d, 0x2e, 0x38, 0x8d, 0xc7, 0xd9, 0xa0,
-	0xa9, 0x81, 0xaf, 0x7e, 0xef, 0x89, 0x47, 0x3e, 0xfd, 0xe3, 0xcf, 0x1c, 0xd6, 0xea, 0x30, 0x8a,
-	0x3c, 0x8b, 0x46, 0x29, 0xd8, 0x2b, 0x56, 0x70, 0x8d, 0x77, 0x87, 0x29, 0xf1, 0x76, 0xb4, 0xd1,
-	0x6e, 0x35, 0xac, 0x87, 0x14, 0xf4, 0x40, 0x9d, 0xfd, 0x20, 0x3a, 0xda, 0x25, 0x18, 0x01, 0xe8,
-	0x4c, 0xa1, 0x81, 0x68, 0x56, 0xc0, 0x68, 0x4c, 0x88, 0x51, 0x34, 0x74, 0x6a, 0x43, 0x88, 0x54,
-	0x3d, 0x1e, 0x46, 0xe6, 0x00, 0xa5, 0x49, 0xc7, 0xe9, 0x42, 0xe9, 0x32, 0x42, 0xf1, 0xb9, 0x0f,
-	0x13, 0xbc, 0x6b, 0x9c, 0x9d, 0x33, 0xe3, 0xe1, 0x39, 0x33, 0xce, 0x6e, 0x26, 0x38, 0x6d, 0xc6,
-	0x67, 0x8d, 0x05, 0x3e, 0xb6, 0x9e, 0x18, 0x49, 0x3e, 0xad, 0x01, 0x15, 0xe9, 0x49, 0xc4, 0x54,
-	0xf4, 0xf5, 0x40, 0x05, 0xbe, 0x92, 0xc2, 0xb4, 0x42, 0x31, 0x3d, 0x90, 0x8b, 0x29, 0x43, 0x20,
-	0x85, 0xea, 0x04, 0xaa, 0x72, 0x7e, 0xcf, 0xc6, 0x9b, 0x51, 0x2d, 0xa3, 0x05, 0xb4, 0x5b, 0x38,
-	0x06, 0xe8, 0xbb, 0x8a, 0xb6, 0x24, 0xf6, 0x35, 0xb0, 0x71, 0xaf, 0x6c, 0xe5, 0xf0, 0x7e, 0x40,
-	0x63, 0x72, 0x28, 0x69, 0x00, 0x72, 0x93, 0x8e, 0x23, 0x40, 0x6e, 0xbd, 0xa4, 0xf5, 0x2d, 0x0d,
-	0xe8, 0xc9, 0x4e, 0x23, 0xa3, 0xa7, 0xaf, 0x47, 0x7a, 0xd6, 0x4d, 0x6a, 0xf8, 0x49, 0x34, 0x38,
-	0xe7, 0xb8, 0xe6, 0xeb, 0xfa, 0xa2, 0x65, 0x2f, 0x2c, 0x06, 0xa3, 0x7d, 0x7b, 0xb5, 0x83, 0x7d,
-	0xf5, 0x2d, 0xb4, 0xed, 0x2a, 0x6d, 0x22, 0xa7, 0xd0, 0x1e, 0x46, 0x94, 0x69, 0x86, 0x2a, 0xc0,
-	0xd4, 0xf2, 0x64, 0xa3, 0xe1, 0x59, 0x3e, 0xdf, 0xf1, 0x78, 0x14, 0x6d, 0x36, 0x58, 0x0b, 0x08,
-	0x97, 0xff, 0x24, 0x0b, 0xe8, 0x71, 0xc9, 0x48, 0x60, 0xc8, 0x0e, 0xb4, 0xa9, 0xdd, 0x99, 0x7b,
-	0xdd, 0x5a, 0x86, 0x91, 0xf0, 0x2b, 0x04, 0x39, 0x67, 0x38, 0xe1, 0x85, 0x47, 0x69, 0xeb, 0xab,
-	0xf3, 0x9f, 0xe1, 0x3a, 0x6a, 0x84, 0xea, 0x00, 0x45, 0x74, 0xa0, 0xce, 0x7e, 0x90, 0x13, 0x30,
-	0xd1, 0x15, 0x2b, 0xa8, 0xd3, 0x33, 0xf6, 0xd2, 0x43, 0xcb, 0xec, 0x04, 0xae, 0x97, 0x58, 0x7e,
-	0xf4, 0xc6, 0xe7, 0xcb, 0x8f, 0xfe, 0x20, 0x0d, 0x34, 0x26, 0x1b, 0x16, 0xed, 0xb0, 0x7e, 0x0b,
-	0xda, 0x4a, 0x2e, 0xbf, 0x68, 0x1c, 0x79, 0x35, 0x46, 0xee, 0x52, 0x78, 0xf3, 0x5d, 0x09, 0x35,
-	0xa4, 0x19, 0x23, 0x30, 0x38, 0x72, 0x4f, 0xa0, 0x2d, 0xec, 0xa2, 0x8f, 0x77, 0xc8, 0x86, 0x3a,
-	0xa2, 0x4d, 0xd7, 0xc2, 0x16, 0xbc, 0x0b, 0xf5, 0x53, 0x84, 0x75, 0xbb, 0x41, 0xf9, 0x31, 0x50,
-	0xdf, 0x4c, 0x7f, 0x5f, 0x6b, 0x90, 0x4e, 0x4c, 0x42, 0x16, 0x38, 0x90, 0x70, 0x1b, 0x8d, 0x64,
-	0xd5, 0x3d, 0x20, 0x65, 0x9f, 0x90, 0x94, 0x34, 0x18, 0xa0, 0x66, 0xd8, 0x4a, 0xb5, 0xc6, 0x92,
-	0x75, 0x1c, 0x31, 0x4d, 0xeb, 0xb5, 0xa5, 0xfe, 0x44, 0x03, 0x02, 0x05, 0x33, 0x29, 0x09, 0xec,
-	0x5b, 0x13, 0x81, 0xeb, 0x77, 0x2c, 0x5e, 0x88, 0x8f, 0xb8, 0xdb, 0x54, 0x93, 0x9e, 0xa4, 0x8a,
-	0x34, 0xe7, 0xd3, 0xde, 0xee, 0x23, 0x6e, 0x20, 0x7d, 0x74, 0x39, 0xb0, 0xfd, 0xba, 0x00, 0x00,
-	0xf9, 0xd7, 0xd1, 0x50, 0x4a, 0x45, 0x07, 0x66, 0x3f, 0x29, 0xa4, 0x3d, 0x09, 0x01, 0x28, 0x1f,
-	0xf4, 0x13, 0x6d, 0xc4, 0x8a, 0x4f, 0x30, 0x11, 0xba, 0xeb, 0x25, 0xd6, 0xcf, 0x6b, 0xfc, 0x50,
-	0xc9, 0xce, 0x23, 0xa7, 0xaa, 0xaf, 0x67, 0xaa, 0xd6, 0x4f, 0x9a, 0x36, 0xda, 0xdf, 0xbd, 0xdd,
-	0xee, 0xc5, 0xc6, 0x4e, 0x61, 0xb1, 0x66, 0x37, 0x7d, 0x25, 0xbb, 0xe9, 0xc9, 0xaf, 0x6b, 0xe8,
-	0xa9, 0x9c, 0xb9, 0x80, 0x57, 0x8b, 0x68, 0xa7, 0xc4, 0xf6, 0x02, 0x09, 0x1d, 0xce, 0xd9, 0x07,
-	0x09, 0xa0, 0xc0, 0xbe, 0xc7, 0x2c, 0xd1, 0x47, 0xd2, 0x02, 0xf2, 0x53, 0x9b, 0x51, 0x40, 0xfe,
-	0x7a, 0x2d, 0x93, 0xbf, 0xe3, 0x3c, 0x90, 0x4f, 0x58, 0x84, 0x07, 0x7d, 0xeb, 0xc8, 0x83, 0xf5,
-	0x5b, 0x4b, 0xd3, 0x70, 0xb2, 0xcd, 0xba, 0xe6, 0x54, 0x68, 0x04, 0x5b, 0xfe, 0x65, 0xd7, 0xbb,
-	0x1d, 0xc4, 0xac, 0xe8, 0xba, 0x9c, 0xb5, 0xee, 0xcb, 0xb9, 0x83, 0x9e, 0x90, 0x02, 0x01, 0xd6,
-	0xd4, 0xd1, 0x40, 0xa8, 0xbf, 0x53, 0x43, 0x1b, 0x98, 0x51, 0x13, 0x5f, 0x62, 0xee, 0x34, 0xc0,
-	0xb8, 0x6f, 0x07, 0x8b, 0x89, 0x2b, 0x8d, 0x73, 0xa4, 0xbf, 0x0d, 0xb3, 0x90, 0x2f, 0x6a, 0xa8,
-	0x2a, 0xef, 0x5e, 0x60, 0xf9, 0xef, 0x44, 0x9b, 0xdb, 0x9d, 0x39, 0x3d, 0xbc, 0xfa, 0x2b, 0xd1,
-	0xd5, 0xff, 0xa2, 0xb5, 0x8c, 0xc7, 0xd0, 0x96, 0x45, 0xeb, 0xa1, 0xce, 0x3f, 0xb2, 0x6b, 0x7e,
-	0x60, 0xd1, 0x7a, 0x38, 0xcb, 0xbe, 0x5f, 0x4c, 0x52, 0xb3, 0x81, 0x52, 0xf3, 0xb8, 0x92, 0x9a,
-	0x2e, 0xdc, 0xaf, 0x20, 0xc2, 0x59, 0x96, 0x90, 0x6b, 0x0f, 0xbc, 0xff, 0x98, 0x86, 0xf6, 0x29,
-	0x21, 0x81, 0x00, 0xde, 0x8b, 0x86, 0xd3, 0x26, 0x1d, 0x48, 0xe1, 0x98, 0x0c, 0xef, 0x04, 0x30,
-	0x89, 0x24, 0x86, 0xda, 0xc9, 0x29, 0xc9, 0x5f, 0x6b, 0x68, 0x4c, 0x3d, 0xee, 0x9d, 0x14, 0xc9,
-	0x4b, 0x5d, 0xf4, 0x31, 0xb9, 0x90, 0x7c, 0xfa, 0xc4, 0xe4, 0x5c, 0x83, 0x63, 0x26, 0xe4, 0xeb,
-	0xc4, 0xda, 0x64, 0xf4, 0x4b, 0xfc, 0x04, 0x91, 0xc3, 0x02, 0x29, 0xcd, 0x49, 0xa4, 0x74, 0xa2,
-	0x07, 0x29, 0xdd, 0x9b, 0x10, 0x13, 0xf6, 0x13, 0x0d, 0xed, 0xcd, 0x1b, 0xf9, 0x4e, 0x4a, 0xea,
-	0x96, 0x44, 0x52, 0xfb, 0xf3, 0x69, 0x94, 0x90, 0x94, 0xd2, 0x4d, 0x37, 0xa6, 0x75, 0xd3, 0xdf,
-	0xe3, 0x97, 0x7c, 0x08, 0x68, 0xe2, 0x76, 0xe0, 0x7a, 0xd6, 0xb4, 0xdb, 0x6c, 0xda, 0x91, 0x36,
-	0x71, 0x1e, 0xed, 0x09, 0xd1, 0xf1, 0x43, 0x39, 0x84, 0xff, 0x7a, 0x81, 0x2e, 0x90, 0xe7, 0x68,
-	0xdb, 0x35, 0xa9, 0xa8, 0x6e, 0x87, 0x3d, 0xa6, 0x62, 0xe1, 0xe2, 0x1a, 0x7a, 0x34, 0xc1, 0x16,
-	0x9d, 0x5b, 0x21, 0x8c, 0x27, 0x38, 0xf1, 0x09, 0xec, 0x8e, 0x14, 0xb2, 0x7d, 0x69, 0x64, 0x17,
-	0x41, 0xa3, 0xed, 0xc6, 0x15, 0xd6, 0xc7, 0x76, 0xb4, 0xd1, 0x8c, 0xf4, 0xab, 0xa1, 0x3a, 0xfb,
-	0x81, 0x77, 0xa3, 0x01, 0xcf, 0x75, 0x03, 0x7d, 0xd1, 0xf0, 0x17, 0xe9, 0xc4, 0x83, 0xf5, 0xfe,
-	0xb0, 0xe1, 0xaa, 0xe1, 0x2f, 0x86, 0x43, 0xe6, 0xdd, 0x4e, 0x8b, 0xcd, 0xd5, 0x5f, 0x67, 0x3f,
-	0xc8, 0xe7, 0x34, 0x58, 0xde, 0x37, 0xae, 0xdf, 0x74, 0x1b, 0xd6, 0x7d, 0x4a, 0xcb, 0x8c, 0xed,
-	0x07, 0x9e, 0x3d, 0xd7, 0x09, 0x79, 0xfa, 0xff, 0x91, 0x3d, 0xef, 0x87, 0x6d, 0x24, 0xc7, 0x19,
-	0xd8, 0x74, 0x06, 0x6d, 0x7e, 0x40, 0xbf, 0xfa, 0x4a, 0x95, 0x2d, 0x09, 0xa7, 0xce, 0x47, 0xc4,
-	0x0c, 0xab, 0x24, 0x19, 0xf6, 0x3e, 0x74, 0x30, 0xb2, 0xaa, 0x33, 0xd2, 0xe9, 0x3a, 0x12, 0xd6,
-	0xc8, 0x33, 0xf2, 0x00, 0x1d, 0x2a, 0x30, 0x17, 0xd0, 0xfa, 0x02, 0xda, 0x6c, 0xb2, 0x4f, 0x40,
-	0xeb, 0xb3, 0xd2, 0x7d, 0x94, 0x04, 0x14, 0xee, 0x79, 0x6e, 0x09, 0x73, 0x00, 0xe4, 0x4d, 0x0d,
-	0xed, 0x56, 0x74, 0x94, 0x09, 0x53, 0x93, 0x0a, 0x33, 0x5a, 0xaf, 0x15, 0xe9, 0x7a, 0xed, 0xcb,
-	0xac, 0xd7, 0xcc, 0xf1, 0xb1, 0x21, 0x7b, 0x7c, 0x28, 0xf6, 0xba, 0x87, 0x9e, 0xe5, 0x7c, 0x93,
-	0x2d, 0x91, 0x75, 0x97, 0xd5, 0xc7, 0x35, 0x74, 0xb4, 0xc4, 0xa4, 0x20, 0xb4, 0xd7, 0xd0, 0x50,
-	0x23, 0xd9, 0x01, 0x44, 0x77, 0x2a, 0x77, 0x99, 0x26, 0xc1, 0x26, 0x45, 0x98, 0x06, 0x47, 0xfe,
-	0x40, 0x43, 0xfb, 0x0a, 0x0c, 0x2b, 0x2f, 0xd0, 0xc4, 0xce, 0xaa, 0x94, 0xde, 0x59, 0x8a, 0xad,
-	0xfd, 0x78, 0x6c, 0xa1, 0x4e, 0x77, 0x3c, 0xcf, 0x6a, 0x31, 0x73, 0x83, 0x3b, 0x74, 0x8f, 0xc7,
-	0xf6, 0x67, 0xfa, 0x73, 0x7c, 0x2e, 0x52, 0x45, 0x19, 0xfc, 0x16, 0xec, 0x07, 0x79, 0x22, 0x76,
-	0x7a, 0xdc, 0x89, 0x1e, 0x70, 0x12, 0x0e, 0x02, 0x12, 0xc4, 0x8e, 0x8b, 0x6c, 0x87, 0x48, 0x6f,
-	0xdd, 0x9a, 0x79, 0xfb, 0x51, 0xfa, 0x2d, 0xd2, 0x50, 0xb8, 0x59, 0x1f, 0xa4, 0x5a, 0xc9, 0x0d,
-	0xd8, 0xde, 0x57, 0xac, 0xe0, 0x6e, 0xcb, 0x0e, 0x5e, 0x9a, 0x9f, 0x66, 0x4f, 0x45, 0xb3, 0x9e,
-	0x6d, 0x5a, 0xb3, 0x9e, 0xdb, 0x76, 0x7d, 0xc3, 0x29, 0x6e, 0x9b, 0x7f, 0x5c, 0x43, 0x87, 0x8b,
-	0xc0, 0x03, 0x8a, 0x5e, 0x44, 0xfd, 0x6d, 0x68, 0x03, 0x52, 0xc4, 0x8a, 0xb8, 0x02, 0x54, 0x04,
-	0x00, 0x8f, 0xa2, 0xcd, 0x0d, 0x6b, 0xde, 0xe8, 0x38, 0x01, 0x18, 0x8f, 0xfc, 0x27, 0xd9, 0x87,
-	0x9e, 0xa4, 0x48, 0x25, 0xc5, 0x95, 0x75, 0xd0, 0x90, 0x65, 0xd0, 0x82, 0x25, 0x9d, 0xde, 0x49,
-	0xe7, 0xd1, 0x7e, 0xae, 0x80, 0x7b, 0xd6, 0x92, 0xed, 0x76, 0x7c, 0x31, 0x82, 0xef, 0xe7, 0xca,
-	0xb5, 0xa4, 0xd7, 0x3b, 0x89, 0xa1, 0x8e, 0x1e, 0x63, 0xb7, 0x5d, 0xb8, 0x45, 0xfc, 0x49, 0xc7,
-	0x59, 0x6f, 0xc3, 0xf6, 0x37, 0x34, 0xb4, 0x23, 0x3b, 0x03, 0x10, 0x74, 0x32, 0x76, 0x55, 0x86,
-	0x9b, 0xbc, 0x2a, 0xde, 0xe4, 0x61, 0x0f, 0x40, 0x9e, 0x75, 0x5f, 0x3f, 0xbb, 0xd4, 0x05, 0x93,
-	0x32, 0xf9, 0x70, 0x72, 0x87, 0xbd, 0x71, 0x72, 0x36, 0x1c, 0x46, 0x23, 0xd6, 0xc3, 0xb6, 0xed,
-	0xd1, 0x01, 0x57, 0xe3, 0xd3, 0x7a, 0x43, 0xbd, 0xab, 0x3d, 0xdc, 0x45, 0x11, 0xde, 0xd7, 0xb8,
-	0xff, 0x32, 0xd9, 0x44, 0x7e, 0x11, 0xed, 0x95, 0x4f, 0x08, 0x5c, 0x79, 0x19, 0x6d, 0xeb, 0x7a,
-	0x71, 0x05, 0xfe, 0x3f, 0xa5, 0x7e, 0xf2, 0x00, 0x48, 0xc0, 0xac, 0x11, 0x3b, 0xd3, 0x4e, 0x6c,
-	0x20, 0x37, 0xf9, 0xc2, 0x92, 0x21, 0x77, 0xbd, 0xa4, 0xfe, 0x65, 0x0d, 0x28, 0x15, 0xce, 0xa5,
-	0xa6, 0xb4, 0x6f, 0xcd, 0x94, 0xae, 0xdf, 0x0a, 0x59, 0x88, 0x4f, 0xd1, 0x68, 0xf2, 0xd8, 0x24,
-	0x98, 0x61, 0xef, 0xda, 0x89, 0xe7, 0x01, 0xe6, 0xd5, 0x6a, 0xc0, 0x12, 0xe1, 0x3f, 0x0b, 0xac,
-	0x8c, 0xdf, 0x4e, 0x9c, 0xaf, 0xaa, 0x99, 0x80, 0x75, 0x1d, 0x54, 0xb5, 0xa5, 0xbd, 0x94, 0x27,
-	0xae, 0x1c, 0x38, 0x70, 0x53, 0x01, 0x98, 0xf8, 0xb1, 0xce, 0x98, 0xcf, 0x8e, 0xf5, 0x5a, 0x4b,
-	0xff, 0xcc, 0x59, 0x93, 0x33, 0x6b, 0x41, 0xd6, 0xf4, 0xbd, 0x23, 0xac, 0x59, 0xbf, 0x25, 0xf7,
-	0x1a, 0x7a, 0x5a, 0xb1, 0x10, 0xe8, 0xbb, 0xb1, 0x15, 0x58, 0x5e, 0xc4, 0xe6, 0x11, 0xd4, 0x67,
-	0x37, 0x18, 0x61, 0x03, 0xf5, 0xf0, 0x4f, 0xbc, 0x07, 0x0d, 0x78, 0xec, 0xa3, 0xe5, 0xc1, 0x5a,
-	0x8b, 0x1b, 0xc8, 0x1f, 0x56, 0xd0, 0x33, 0x05, 0x27, 0x00, 0x8e, 0xde, 0x44, 0x23, 0x60, 0x47,
-	0xbb, 0x9e, 0xde, 0x76, 0x1f, 0x58, 0x9e, 0xaf, 0x7c, 0x76, 0xb8, 0xc7, 0x3b, 0xcf, 0x86, 0x7d,
-	0xeb, 0x5b, 0x97, 0x52, 0xbf, 0x7d, 0xfc, 0x14, 0x1a, 0x36, 0xd9, 0x5d, 0xcc, 0xf5, 0x5f, 0x76,
-	0xad, 0x0f, 0x41, 0x2b, 0x1c, 0xa7, 0xd7, 0xc2, 0x6b, 0x9f, 0x49, 0xad, 0xaf, 0x27, 0xa9, 0xd5,
-	0xf9, 0x78, 0x7c, 0x29, 0x14, 0x0e, 0xa7, 0x8b, 0x6a, 0xfb, 0xb2, 0x23, 0x26, 0xc3, 0x08, 0xbf,
-	0x9e, 0x18, 0x48, 0xae, 0xa0, 0xe1, 0x34, 0x6d, 0xa1, 0x4a, 0x48, 0x19, 0xc2, 0x55, 0x42, 0xfa,
-	0x23, 0xdf, 0xe3, 0x7d, 0x03, 0x56, 0x34, 0xbd, 0xa2, 0x67, 0xe3, 0xa0, 0x97, 0xdb, 0x2c, 0xe6,
-	0x65, 0x6a, 0x39, 0xa9, 0x97, 0xe6, 0xbe, 0x9a, 0x91, 0x4f, 0x6a, 0xe8, 0x48, 0x21, 0x78, 0x20,
-	0x50, 0x07, 0x5c, 0xc8, 0xdd, 0x3d, 0x41, 0xae, 0x4f, 0xcb, 0x15, 0x0a, 0x01, 0x74, 0xb6, 0x39,
-	0x64, 0x20, 0xc9, 0x32, 0x18, 0x4c, 0x52, 0xe4, 0x04, 0xef, 0xd4, 0xb9, 0x0f, 0x85, 0xfb, 0xd1,
-	0x50, 0x42, 0x3d, 0x8d, 0xce, 0xd4, 0x74, 0x23, 0xf9, 0x14, 0xb7, 0x9b, 0x8a, 0xcd, 0x5d, 0x84,
-	0x3d, 0xda, 0x7a, 0xb3, 0xa7, 0x8d, 0xde, 0x95, 0x72, 0xfc, 0x77, 0x77, 0x59, 0xef, 0x03, 0xf5,
-	0x07, 0x1a, 0x3a, 0x90, 0x3b, 0xe5, 0xff, 0xc5, 0x52, 0x59, 0xbf, 0x43, 0xf4, 0x1c, 0x04, 0x93,
-	0x5c, 0x85, 0x08, 0xb1, 0xd0, 0x50, 0x2c, 0xfe, 0x64, 0x45, 0xee, 0x41, 0x10, 0x45, 0x66, 0x38,
-	0xf0, 0xe4, 0x14, 0xda, 0x48, 0x03, 0x8a, 0x40, 0x04, 0x62, 0xe7, 0x6f, 0x7a, 0x28, 0x1b, 0x40,
-	0xc6, 0xc0, 0xc2, 0x4c, 0x7d, 0x8c, 0x95, 0x6e, 0xf2, 0x0a, 0xd8, 0x92, 0xdd, 0xdf, 0xbb, 0xa7,
-	0xee, 0x2b, 0x37, 0xf5, 0x4d, 0x58, 0x66, 0xe9, 0x00, 0x14, 0xb0, 0x89, 0x6e, 0x07, 0x46, 0x10,
-	0xb1, 0xa7, 0x6b, 0x6b, 0x69, 0xa2, 0xad, 0x65, 0xc0, 0x1a, 0x52, 0xc1, 0x8b, 0x63, 0x1f, 0x1e,
-	0x24, 0x35, 0x67, 0xf8, 0x85, 0xc7, 0x10, 0xf2, 0xac, 0x76, 0x27, 0x88, 0xa5, 0xbd, 0xb1, 0x9e,
-	0x68, 0x21, 0x47, 0x62, 0xe5, 0x2b, 0x1d, 0x66, 0x22, 0xc0, 0x9a, 0x7c, 0x3b, 0xa1, 0x40, 0xa9,
-	0x7a, 0x47, 0xaf, 0x68, 0xbb, 0x92, 0x3e, 0x09, 0x7e, 0x1f, 0xd1, 0xd8, 0x3e, 0xe5, 0xca, 0x96,
-	0x01, 0xde, 0xd9, 0x16, 0x7f, 0xe8, 0x72, 0xdd, 0x57, 0xba, 0x5c, 0xf7, 0x78, 0x17, 0xea, 0x87,
-	0xd3, 0xae, 0x01, 0x61, 0x29, 0x5c, 0x73, 0x24, 0x5f, 0xd5, 0xd0, 0x4e, 0xc9, 0x94, 0xe1, 0x3d,
-	0x9a, 0xa4, 0xc1, 0x16, 0x4b, 0x2a, 0xc1, 0xfe, 0x4a, 0x8a, 0xfd, 0x87, 0xd0, 0x88, 0x35, 0x3f,
-	0x6f, 0x99, 0x81, 0xbd, 0x64, 0xe9, 0xd0, 0x63, 0x03, 0xed, 0xb1, 0x35, 0x6a, 0x67, 0xce, 0x15,
-	0xbc, 0x0f, 0x0d, 0x99, 0x46, 0xbb, 0x6d, 0x35, 0x78, 0xbf, 0x8d, 0xb4, 0xdf, 0x20, 0x6b, 0xbc,
-	0x2f, 0x12, 0x67, 0x5f, 0x97, 0x38, 0x3f, 0x5b, 0x41, 0xdb, 0x13, 0xa4, 0x5c, 0xee, 0x38, 0x0e,
-	0xa3, 0xe3, 0x00, 0xda, 0x6a, 0xb0, 0xb8, 0x99, 0x8c, 0x6f, 0x68, 0x18, 0x9a, 0xb9, 0x5f, 0xe8,
-	0x10, 0x1a, 0x71, 0xdb, 0x96, 0x47, 0xf5, 0x90, 0xb4, 0x8f, 0x77, 0x2b, 0x6f, 0xe7, 0x5d, 0x73,
-	0x90, 0xc1, 0x67, 0x50, 0xd5, 0x32, 0xbc, 0x96, 0xd5, 0xd0, 0x4d, 0xd7, 0x6e, 0xf9, 0xd1, 0x02,
-	0x60, 0x0e, 0x1e, 0xc6, 0x86, 0x9d, 0xac, 0xc7, 0x74, 0xd8, 0x21, 0xe9, 0x3c, 0xc0, 0xe7, 0xd0,
-	0x6e, 0xcf, 0x7a, 0x60, 0x78, 0x8d, 0x68, 0xb8, 0x63, 0x04, 0x96, 0xcf, 0x47, 0x33, 0xe6, 0x8c,
-	0xf2, 0x2e, 0x74, 0xfc, 0x75, 0xda, 0x81, 0x0d, 0x3f, 0x04, 0x86, 0xbc, 0x4f, 0xc3, 0x77, 0x1d,
-	0x2b, 0xb0, 0x1a, 0xa3, 0x9b, 0xa8, 0xeb, 0x72, 0x2b, 0x6b, 0x9f, 0xe6, 0xcd, 0x91, 0x83, 0x23,
-	0xf9, 0x70, 0x12, 0x31, 0x8e, 0x2f, 0xfd, 0x0f, 0x70, 0x2f, 0x83, 0xb8, 0x53, 0x64, 0x6d, 0x25,
-	0x5d, 0x6d, 0x7e, 0x6a, 0xa9, 0x1f, 0xca, 0x5b, 0xea, 0x31, 0xb8, 0x6d, 0x49, 0x20, 0xb4, 0x89,
-	0x7c, 0x00, 0xbc, 0xd6, 0xf4, 0xd7, 0xd4, 0x72, 0x68, 0x84, 0xcd, 0x5a, 0x9e, 0xed, 0x36, 0xa6,
-	0x96, 0x67, 0x78, 0x94, 0x2c, 0x3f, 0x5c, 0xf6, 0xa0, 0x81, 0x28, 0x72, 0x16, 0xa4, 0x1c, 0x37,
-	0xe0, 0xdd, 0x68, 0x20, 0xb4, 0x03, 0xf5, 0x79, 0xcf, 0x6d, 0xc2, 0x46, 0xe9, 0x0f, 0x1b, 0x2e,
-	0x7b, 0x6e, 0x13, 0xef, 0x44, 0x9b, 0xe9, 0xc7, 0xc0, 0x85, 0x4d, 0xb2, 0x29, 0xfc, 0x79, 0xc7,
-	0x25, 0x0e, 0x9c, 0x13, 0xea, 0xf9, 0x81, 0x0d, 0x17, 0xd0, 0xc6, 0x7c, 0xca, 0xa3, 0x61, 0x09,
-	0x90, 0x75, 0x36, 0x8e, 0x2c, 0x82, 0xfa, 0x0c, 0x9f, 0xa2, 0xae, 0x93, 0xad, 0x06, 0x15, 0xef,
-	0x94, 0x61, 0xbe, 0x1e, 0x0a, 0xde, 0x2f, 0x46, 0x32, 0xdf, 0xfb, 0xbe, 0xce, 0x8f, 0x40, 0xb6,
-	0xf7, 0xfd, 0x9b, 0xa4, 0x8e, 0x4e, 0xd0, 0x99, 0x22, 0x0d, 0xd7, 0x9f, 0x6c, 0x35, 0xa8, 0xf3,
-	0xcf, 0x87, 0xc9, 0xe9, 0x84, 0x7e, 0xd7, 0x8c, 0x49, 0x98, 0x5a, 0x1a, 0xe6, 0x22, 0x28, 0x63,
-	0x72, 0x98, 0x31, 0xfb, 0x38, 0xb8, 0xde, 0xa4, 0xd2, 0x00, 0x3b, 0x46, 0x3e, 0x13, 0xf3, 0x08,
-	0xad, 0x6d, 0x16, 0x1d, 0x21, 0x0a, 0x86, 0x9d, 0x24, 0xc2, 0xe0, 0xb7, 0x10, 0xb2, 0x61, 0xeb,
-	0xd4, 0x3f, 0xea, 0x73, 0xc8, 0x86, 0xcd, 0x50, 0x09, 0x0f, 0x8a, 0x48, 0xee, 0x3e, 0x3f, 0x28,
-	0xe2, 0x16, 0xe2, 0x83, 0xb8, 0xf3, 0xc9, 0x88, 0x02, 0xe9, 0x06, 0x59, 0x84, 0x38, 0x9d, 0x9c,
-	0xaf, 0xb3, 0x27, 0xe4, 0xce, 0x2d, 0xb6, 0xaf, 0xb6, 0xd0, 0x41, 0x0c, 0x16, 0xf9, 0x04, 0x7f,
-	0xcb, 0x95, 0xcd, 0x1a, 0xcd, 0x96, 0xa2, 0x4d, 0x53, 0xd2, 0x56, 0xc9, 0xd2, 0x86, 0x8f, 0xa3,
-	0x1d, 0x86, 0x19, 0x74, 0x0c, 0x47, 0x8f, 0x1b, 0x75, 0xd3, 0xf5, 0x79, 0x70, 0xe4, 0x76, 0xf6,
-	0x35, 0x46, 0x62, 0xda, 0xf5, 0x03, 0x42, 0xc0, 0xb5, 0x33, 0x4d, 0x8f, 0xe6, 0xd4, 0x55, 0x1b,
-	0x1d, 0x49, 0xa7, 0xb9, 0x63, 0x56, 0xd8, 0x27, 0xf6, 0xa7, 0x07, 0x6e, 0x00, 0x1e, 0xe2, 0xbe,
-	0x3a, 0xfb, 0x41, 0x46, 0xc1, 0x5f, 0x38, 0x63, 0xcd, 0x75, 0x16, 0x52, 0xe7, 0xdc, 0xd7, 0xfb,
-	0xd0, 0xce, 0xae, 0x4f, 0xd1, 0x9b, 0xf6, 0x10, 0xe3, 0xfa, 0xdc, 0x32, 0x75, 0x25, 0x01, 0xdb,
-	0xcf, 0x0b, 0xd9, 0x2e, 0x01, 0x32, 0x7e, 0xc7, 0x6a, 0xb6, 0x5d, 0xcf, 0xf0, 0xe8, 0x1e, 0x08,
-	0x3f, 0x81, 0x54, 0xd8, 0xa6, 0xc0, 0x16, 0x1a, 0x8e, 0xe6, 0x60, 0x27, 0x3d, 0x7b, 0x9d, 0xb8,
-	0xd0, 0xdb, 0x24, 0x74, 0xf3, 0xd2, 0x59, 0x06, 0xfd, 0xc4, 0x76, 0xae, 0x7a, 0x68, 0x5b, 0x17,
-	0x22, 0x39, 0x87, 0x48, 0x74, 0xa8, 0x55, 0x7a, 0x3b, 0xd4, 0xaa, 0x01, 0xc2, 0xdd, 0x78, 0xe5,
-	0x4c, 0x7a, 0x31, 0x3d, 0xe9, 0xe1, 0x42, 0x93, 0x32, 0x43, 0x14, 0x8e, 0xd2, 0x43, 0xb1, 0x0e,
-	0x79, 0xc3, 0x6e, 0xd9, 0xcd, 0x4e, 0x33, 0x36, 0xbf, 0x27, 0x97, 0x2c, 0x2f, 0xb6, 0x5f, 0xc8,
-	0x67, 0x34, 0xb8, 0x64, 0x94, 0x7d, 0x61, 0x31, 0xec, 0x43, 0x43, 0x81, 0x67, 0xcc, 0xcf, 0xdb,
-	0xa6, 0x3e, 0x67, 0xf8, 0xb6, 0x0f, 0x7a, 0xe7, 0x20, 0x34, 0x4e, 0x85, 0x6d, 0xf8, 0x2c, 0xaa,
-	0x36, 0x19, 0xa0, 0x64, 0x0a, 0x82, 0xc1, 0x40, 0x81, 0x5a, 0x31, 0xda, 0x94, 0x4c, 0x25, 0x8c,
-	0x26, 0xde, 0x90, 0x0e, 0xc8, 0x78, 0x2e, 0x7e, 0x18, 0x9a, 0x65, 0xf9, 0x27, 0x77, 0x59, 0xfa,
-	0x09, 0x3f, 0xf1, 0x76, 0xa0, 0x4d, 0x8b, 0x29, 0xbd, 0x98, 0xfd, 0x22, 0x7e, 0xfc, 0x60, 0x94,
-	0x1d, 0x08, 0x04, 0xde, 0x02, 0xcd, 0x2f, 0xfa, 0xa2, 0x7c, 0x08, 0x48, 0x03, 0xe1, 0x0f, 0x01,
-	0x69, 0x00, 0xc9, 0x38, 0x57, 0x31, 0xb6, 0xeb, 0x65, 0x7d, 0xbe, 0x99, 0x88, 0x73, 0x2d, 0x41,
-	0x5e, 0xdf, 0x9a, 0xc8, 0x5b, 0x3f, 0xcb, 0xf2, 0x57, 0xb4, 0xd8, 0x87, 0x3f, 0x45, 0x73, 0x85,
-	0xee, 0x78, 0x46, 0xcb, 0x37, 0xcc, 0x64, 0x3c, 0xc3, 0x93, 0x68, 0xd0, 0xf5, 0xec, 0x05, 0xbb,
-	0xa5, 0x9b, 0x8b, 0x86, 0xdd, 0xe2, 0x26, 0x26, 0x6b, 0x9b, 0x0e, 0x9b, 0xe2, 0x05, 0xd4, 0xea,
-	0x34, 0xe7, 0x22, 0x3f, 0x1d, 0x5b, 0x40, 0x37, 0x69, 0x53, 0xb8, 0x8c, 0x3d, 0xcb, 0xb4, 0xec,
-	0x76, 0x00, 0x6e, 0x10, 0xf6, 0x9c, 0x39, 0x08, 0x8d, 0xcc, 0xf7, 0xf3, 0x61, 0x0d, 0x8e, 0x5a,
-	0x31, 0x3e, 0xc0, 0xd1, 0xf7, 0x20, 0x3c, 0x97, 0xfd, 0xc8, 0xaf, 0xa6, 0x77, 0x09, 0xb9, 0xda,
-	0x05, 0x0b, 0x18, 0x2b, 0x80, 0x43, 0x5e, 0x07, 0x14, 0x26, 0x1d, 0xa7, 0x6b, 0xd8, 0xba, 0xbb,
-	0x83, 0xbf, 0xa6, 0x81, 0xba, 0x2b, 0x99, 0xed, 0xe7, 0x41, 0xf1, 0xfa, 0x2d, 0xa7, 0x1f, 0x68,
-	0xe8, 0xd1, 0xfb, 0x1e, 0x35, 0xa3, 0xe8, 0xa5, 0x3d, 0x05, 0xd1, 0xff, 0x37, 0x11, 0xa2, 0x97,
-	0x7a, 0x78, 0x33, 0xbb, 0x4a, 0x87, 0x3e, 0x43, 0x3b, 0x09, 0x63, 0xda, 0x6d, 0x05, 0x9e, 0x61,
-	0x06, 0xf5, 0x01, 0x0a, 0xe2, 0x5a, 0x6b, 0xde, 0x0d, 0xcf, 0x1a, 0x7f, 0xb9, 0x39, 0xe7, 0x3a,
-	0x3c, 0x8e, 0x8a, 0xfd, 0x4a, 0xe6, 0x1f, 0xc0, 0x63, 0x39, 0xcf, 0x3f, 0xa8, 0xa2, 0xfe, 0x86,
-	0x65, 0xda, 0x4d, 0xc3, 0xf1, 0x21, 0x3e, 0x22, 0xfa, 0x8d, 0x8f, 0xa0, 0x6d, 0xd4, 0x75, 0x13,
-	0x04, 0x56, 0x43, 0xe7, 0xe3, 0x59, 0x9c, 0xc4, 0x48, 0xf4, 0x01, 0x48, 0x21, 0x67, 0x61, 0xc3,
-	0x08, 0xc8, 0x2c, 0x90, 0x59, 0x61, 0xc3, 0xda, 0x12, 0x8f, 0x06, 0x61, 0xcf, 0xa0, 0x7e, 0xc0,
-	0x82, 0x8b, 0xf8, 0xa0, 0x90, 0x57, 0x02, 0x20, 0xf5, 0x68, 0x24, 0xb9, 0x00, 0x0b, 0x8b, 0x71,
-	0x14, 0x2c, 0x49, 0xcb, 0x9f, 0x5a, 0xa6, 0x3b, 0x36, 0xa1, 0x5c, 0xd3, 0x4d, 0x1d, 0xdb, 0xdb,
-	0x9b, 0xe9, 0x6f, 0x9a, 0xa2, 0xb0, 0x4f, 0x09, 0x20, 0xf2, 0xa7, 0x0f, 0x18, 0xfc, 0x9b, 0x32,
-	0x66, 0x97, 0xc1, 0xe1, 0xe2, 0x04, 0x78, 0x3c, 0xb1, 0x29, 0x02, 0x41, 0xee, 0xc2, 0xd5, 0x08,
-	0xb7, 0x54, 0x6a, 0x2d, 0x5c, 0x76, 0xbd, 0x3b, 0xc9, 0x53, 0xfc, 0x10, 0x1a, 0x31, 0x01, 0x5e,
-	0xc6, 0xd8, 0xde, 0x6a, 0xa6, 0xe7, 0x21, 0x97, 0xc1, 0xac, 0x52, 0x83, 0x05, 0x9a, 0x76, 0xa1,
-	0x7e, 0xdb, 0x67, 0x17, 0x29, 0x85, 0xd7, 0x5f, 0xdf, 0x6c, 0xfb, 0x74, 0x24, 0x99, 0x86, 0x20,
-	0x30, 0x0e, 0xe7, 0xda, 0x9c, 0x29, 0x44, 0x6d, 0x37, 0x1a, 0xb0, 0xe7, 0x4c, 0x9d, 0x25, 0xbd,
-	0x30, 0x9c, 0xfa, 0xed, 0x39, 0x73, 0x86, 0xe6, 0xbd, 0xbc, 0x06, 0x0a, 0xb1, 0x1c, 0x48, 0x2e,
-	0x22, 0xa9, 0x15, 0xcd, 0x42, 0x85, 0xa2, 0xdf, 0x64, 0x37, 0x38, 0x0c, 0xaf, 0xf3, 0x24, 0xc8,
-	0x59, 0xd7, 0x8d, 0xdc, 0x72, 0x6f, 0x80, 0x3b, 0x30, 0xf3, 0x11, 0x66, 0x94, 0xae, 0xdd, 0x70,
-	0xd3, 0x99, 0x6e, 0x83, 0xbf, 0xf8, 0x6d, 0xa8, 0xc3, 0xaf, 0x22, 0xca, 0xc3, 0x4e, 0x78, 0x97,
-	0xbf, 0xc4, 0x5c, 0xde, 0xf3, 0x2e, 0xc7, 0xe5, 0x47, 0x15, 0xd0, 0x8f, 0x13, 0x5f, 0x00, 0x91,
-	0xfc, 0x20, 0x51, 0x7c, 0x3a, 0x4a, 0x4e, 0xac, 0xe4, 0x27, 0x27, 0xb2, 0x85, 0x06, 0x03, 0xf0,
-	0x34, 0x1a, 0x4c, 0x79, 0x39, 0xfa, 0x28, 0x80, 0xaa, 0xdc, 0xfd, 0xcb, 0xb3, 0xb9, 0x9c, 0x84,
-	0xeb, 0xe3, 0x0c, 0xaa, 0xda, 0xa1, 0x89, 0x91, 0xc9, 0x4d, 0x35, 0xa8, 0xb3, 0x89, 0x1e, 0x33,
-	0xfd, 0xf5, 0x9d, 0xb6, 0x3f, 0x9d, 0xe8, 0x30, 0xeb, 0x9a, 0x93, 0xf4, 0x33, 0x76, 0xd0, 0xe3,
-	0xac, 0xa3, 0x2e, 0x4e, 0x6e, 0xa5, 0x27, 0x90, 0x4c, 0xfb, 0x4d, 0x83, 0x9c, 0xbe, 0x14, 0x0e,
-	0xa8, 0x57, 0x19, 0xbc, 0xcc, 0x74, 0xf4, 0x1b, 0xb9, 0x02, 0x9b, 0x99, 0x9a, 0x30, 0xb3, 0xee,
-	0xf4, 0x1c, 0x8b, 0x00, 0x9f, 0x84, 0xe7, 0xa9, 0x84, 0x33, 0x39, 0xc1, 0x60, 0x30, 0xb7, 0x53,
-	0xa2, 0x3c, 0x0b, 0xeb, 0x5f, 0x0a, 0x48, 0x14, 0x76, 0xb9, 0x01, 0xc2, 0xd8, 0xc8, 0x8b, 0xa0,
-	0x23, 0xf3, 0xd1, 0x89, 0x78, 0xff, 0xf2, 0xa8, 0x5c, 0x84, 0x93, 0x42, 0x09, 0x4c, 0x89, 0x0e,
-	0x8f, 0x68, 0x99, 0x6c, 0xb7, 0x3d, 0x77, 0x09, 0x4e, 0x03, 0x3f, 0xb3, 0x95, 0xc9, 0x07, 0x81,
-	0x77, 0xb2, 0x5e, 0x91, 0x4b, 0x6a, 0xab, 0x01, 0x3d, 0x62, 0x13, 0x56, 0x6e, 0xc0, 0xc0, 0x05,
-	0x1d, 0x76, 0xac, 0x5b, 0xe9, 0x34, 0xcf, 0x61, 0x23, 0x35, 0x13, 0x39, 0x1f, 0x2b, 0x45, 0xd4,
-	0xa4, 0x9e, 0xb5, 0x3c, 0xfa, 0x85, 0x86, 0x18, 0x25, 0x4e, 0xf2, 0x28, 0x52, 0x4c, 0x4b, 0x47,
-	0x8a, 0xcd, 0x02, 0x99, 0x92, 0xf1, 0x31, 0x8b, 0xda, 0x61, 0x43, 0xf4, 0xfa, 0x17, 0xfe, 0x90,
-	0x84, 0x76, 0x1e, 0x88, 0x73, 0x5c, 0x26, 0x1d, 0xa7, 0x1b, 0x68, 0x64, 0xe5, 0x9e, 0x03, 0x8f,
-	0x06, 0x6d, 0x55, 0xe0, 0x18, 0xcf, 0x5e, 0x49, 0xcc, 0x4e, 0xbc, 0xd8, 0xcf, 0x2f, 0x9b, 0x27,
-	0xca, 0xd1, 0x1c, 0x64, 0xa0, 0xe9, 0xc0, 0x02, 0x8e, 0x0a, 0x3a, 0x9e, 0xef, 0xea, 0x66, 0xd4,
-	0xe2, 0x93, 0xd3, 0x71, 0xe0, 0x1c, 0xed, 0x38, 0x6d, 0xb4, 0x0d, 0xd3, 0x0e, 0x96, 0x0b, 0x30,
-	0xfa, 0x56, 0x6c, 0x24, 0x65, 0x86, 0x02, 0x96, 0x55, 0xd4, 0x6f, 0x42, 0x1b, 0xb0, 0x39, 0xfa,
-	0x2d, 0xe1, 0xf4, 0xbe, 0x58, 0xf6, 0x9c, 0x03, 0x00, 0xd5, 0x8e, 0xb9, 0xbc, 0x1c, 0x0b, 0x58,
-	0xd4, 0x29, 0x0e, 0xb9, 0x62, 0x88, 0x9b, 0xd1, 0x37, 0xe5, 0xcb, 0x4b, 0x8a, 0x04, 0xe0, 0xd4,
-	0xd6, 0x66, 0x1a, 0x38, 0xb9, 0x8c, 0x86, 0x52, 0xfd, 0x54, 0x32, 0x4e, 0x52, 0x5f, 0x49, 0x53,
-	0x4f, 0x96, 0x38, 0x9d, 0x9e, 0xd1, 0x0a, 0xac, 0x50, 0xcd, 0xb8, 0x61, 0xf9, 0xbe, 0xb1, 0x60,
-	0xdd, 0x59, 0x6e, 0x47, 0x6b, 0xfc, 0x00, 0xda, 0xba, 0x40, 0xbf, 0x7b, 0x59, 0xdf, 0x3a, 0x34,
-	0x73, 0x87, 0xf9, 0x41, 0x34, 0xd2, 0x64, 0xc3, 0xf5, 0x60, 0xb9, 0x6d, 0xe9, 0x1d, 0x8f, 0xab,
-	0x8a, 0xc3, 0xcd, 0x18, 0xec, 0x5d, 0xcf, 0x21, 0x67, 0xd1, 0x66, 0x98, 0x52, 0x71, 0xf5, 0xc9,
-	0x02, 0xf7, 0xc9, 0x6b, 0x9c, 0xf1, 0x62, 0xac, 0xa3, 0x77, 0xae, 0xfe, 0x05, 0xe8, 0x00, 0x0c,
-	0xdf, 0x23, 0x64, 0x38, 0x40, 0xa9, 0x47, 0xbd, 0x23, 0xef, 0x54, 0xc2, 0xe3, 0x34, 0xe9, 0x38,
-	0xee, 0x83, 0xeb, 0xb6, 0xcf, 0x0f, 0x4a, 0x32, 0xd9, 0xed, 0x55, 0x4f, 0xf4, 0x01, 0x14, 0xf6,
-	0x64, 0xb5, 0xb4, 0x81, 0xa4, 0xce, 0x35, 0x96, 0x58, 0xf2, 0x34, 0x0c, 0xf5, 0x1e, 0x2b, 0xe1,
-	0xc0, 0xa7, 0x68, 0x27, 0xd6, 0x75, 0xfa, 0x3b, 0x80, 0x7f, 0x09, 0x0d, 0xa7, 0x8b, 0x3f, 0x28,
-	0x5f, 0x13, 0x53, 0x30, 0x78, 0x7a, 0x02, 0x1b, 0x0f, 0x8d, 0x64, 0x1a, 0x08, 0xbf, 0x04, 0x85,
-	0x22, 0x04, 0x6e, 0xb9, 0xfc, 0x48, 0x02, 0x13, 0x38, 0x23, 0x06, 0x12, 0x55, 0x38, 0xd8, 0x68,
-	0x07, 0x56, 0x53, 0xad, 0x6a, 0x0b, 0x20, 0xd4, 0xd9, 0x30, 0x72, 0x90, 0xbf, 0x78, 0x0b, 0x2e,
-	0x5f, 0xb8, 0x98, 0x81, 0x8b, 0x1f, 0x8b, 0x5e, 0xaa, 0x15, 0x5d, 0x63, 0x4f, 0xa8, 0xed, 0x73,
-	0x4d, 0x82, 0x69, 0x7e, 0xfd, 0xb6, 0x0f, 0xaa, 0xc3, 0x05, 0xb4, 0x91, 0xa9, 0x08, 0x95, 0xb2,
-	0x2a, 0x02, 0x1b, 0x47, 0x66, 0x22, 0x87, 0x66, 0x77, 0x9f, 0xe2, 0xec, 0x5d, 0xe0, 0xa1, 0xa8,
-	0x62, 0x28, 0x40, 0xc9, 0x24, 0xda, 0x44, 0x27, 0x55, 0xdf, 0x86, 0x42, 0x6c, 0x61, 0x20, 0xf9,
-	0x2d, 0x0d, 0xed, 0x48, 0x70, 0xfe, 0xbe, 0x1d, 0x2c, 0x72, 0xcb, 0x72, 0xdd, 0x4a, 0x0d, 0xe0,
-	0x33, 0x09, 0xab, 0x8b, 0xf9, 0x00, 0x77, 0xa5, 0x4c, 0x60, 0x6e, 0xfc, 0x4e, 0xbb, 0x36, 0x5f,
-	0xb3, 0xb1, 0xb1, 0xc5, 0x13, 0x2c, 0x93, 0x2b, 0x2c, 0x81, 0xe6, 0xba, 0xbb, 0x0d, 0xde, 0x8e,
-	0xd2, 0xa3, 0xa4, 0x13, 0x02, 0xfb, 0xef, 0xa2, 0xc1, 0xe4, 0x1b, 0x17, 0x08, 0xe1, 0x48, 0x1e,
-	0x87, 0x12, 0xb0, 0x78, 0x66, 0x6e, 0x12, 0xcc, 0xcf, 0xb5, 0x90, 0xc1, 0xf3, 0xe0, 0x28, 0x67,
-	0xb9, 0xfe, 0xb7, 0x2d, 0xab, 0x51, 0x7c, 0x8d, 0xde, 0x82, 0x62, 0x1f, 0xa9, 0xb1, 0xc0, 0x9a,
-	0x13, 0x68, 0xa3, 0x1f, 0x36, 0x28, 0x75, 0x85, 0x78, 0x60, 0x9d, 0xf5, 0x26, 0x2f, 0xf3, 0xf3,
-	0x36, 0x99, 0x66, 0x75, 0x1b, 0xaa, 0xb1, 0x70, 0xc4, 0x8e, 0xa1, 0x1d, 0xd9, 0x1c, 0x89, 0x94,
-	0x1d, 0xf3, 0x68, 0x2a, 0x3b, 0x02, 0x08, 0xfd, 0x88, 0x16, 0xa5, 0x38, 0x0a, 0x41, 0x03, 0xde,
-	0x97, 0x51, 0x3f, 0x2f, 0xfe, 0xa2, 0x4c, 0x14, 0x16, 0x43, 0x89, 0xc6, 0x4a, 0x14, 0x8e, 0x44,
-	0x94, 0x37, 0xab, 0x37, 0x43, 0x03, 0x2f, 0x32, 0xf4, 0x91, 0x8f, 0x6a, 0x71, 0x98, 0xb7, 0xb0,
-	0x1b, 0xe0, 0x7a, 0xa5, 0x0b, 0x57, 0xc9, 0xd2, 0x13, 0x83, 0xc9, 0x43, 0xb6, 0x16, 0x5f, 0x4c,
-	0x33, 0x50, 0x4a, 0xe7, 0x12, 0xad, 0xa4, 0xc3, 0xe5, 0x30, 0x8c, 0x2a, 0x36, 0x0f, 0x60, 0xad,
-	0xd8, 0x8d, 0xa4, 0x37, 0x3a, 0x3b, 0x20, 0x4a, 0x84, 0xda, 0xc4, 0x8a, 0xf1, 0x28, 0xbd, 0xd0,
-	0x99, 0xc1, 0x30, 0x44, 0x9a, 0x08, 0xf5, 0x54, 0x76, 0xd2, 0xab, 0x2e, 0x18, 0x91, 0xa9, 0x60,
-	0x95, 0xdc, 0x40, 0xb1, 0x4c, 0xb0, 0x4f, 0xa5, 0x3b, 0xd8, 0xe7, 0xc3, 0x5a, 0xac, 0x32, 0xcb,
-	0x26, 0x8b, 0x4e, 0xe6, 0xe8, 0xf1, 0x58, 0x2e, 0x18, 0x09, 0x0c, 0x36, 0x52, 0x4c, 0xef, 0xc4,
-	0x77, 0x3f, 0xa4, 0xa1, 0x8d, 0x14, 0x09, 0xfc, 0xab, 0x1a, 0xda, 0xc4, 0x0c, 0x70, 0x7c, 0x40,
-	0xfe, 0xb0, 0x94, 0x2a, 0x45, 0x54, 0x3d, 0x98, 0xdf, 0x91, 0x51, 0x40, 0x26, 0x3e, 0xf2, 0xad,
-	0x7f, 0xfc, 0x78, 0xe5, 0x69, 0x7c, 0xb8, 0xd6, 0xf6, 0xdc, 0x46, 0xc7, 0x0c, 0x7c, 0xd3, 0x96,
-	0x95, 0xf0, 0x82, 0x52, 0x6d, 0xf8, 0x77, 0x35, 0x34, 0x10, 0xbd, 0x01, 0xe2, 0x67, 0xe4, 0x73,
-	0x09, 0x4a, 0x16, 0x55, 0xc7, 0x8b, 0x76, 0x07, 0x04, 0xcf, 0x51, 0x04, 0x9f, 0xc3, 0x27, 0x8a,
-	0x20, 0x18, 0xff, 0xb5, 0x42, 0xe5, 0xbf, 0x8a, 0x7f, 0x47, 0x43, 0x83, 0x11, 0xd0, 0x49, 0xc7,
-	0x51, 0xa1, 0x2b, 0x28, 0x67, 0xa4, 0x42, 0x57, 0x54, 0x98, 0x88, 0x9c, 0xa0, 0xe8, 0xd6, 0xf0,
-	0x33, 0xa5, 0xd0, 0xc5, 0x9f, 0xd5, 0xd0, 0x96, 0xc4, 0xdd, 0x81, 0x6b, 0x4a, 0x2e, 0x75, 0x07,
-	0x48, 0x56, 0x9f, 0x2d, 0x3e, 0x00, 0x30, 0xbd, 0x40, 0x31, 0x3d, 0x8d, 0x9f, 0x2b, 0x28, 0x79,
-	0x0e, 0x20, 0x62, 0xed, 0xef, 0x6b, 0x68, 0x38, 0xad, 0x31, 0xab, 0xd0, 0x16, 0xd6, 0x1f, 0x52,
-	0xa1, 0x2d, 0xae, 0x24, 0x44, 0x9e, 0xa3, 0x68, 0x1f, 0xc5, 0xb5, 0x92, 0x68, 0xe3, 0xaf, 0x68,
-	0x68, 0x24, 0x5b, 0x8e, 0x07, 0x1f, 0x55, 0xcc, 0x2f, 0x2e, 0xfa, 0x53, 0x9d, 0x28, 0x33, 0x04,
-	0x90, 0x7e, 0x91, 0x22, 0x7d, 0x09, 0x4f, 0x97, 0x5a, 0x15, 0x7a, 0x8a, 0xeb, 0x60, 0x6b, 0xac,
-	0xe2, 0x3f, 0xd6, 0xd0, 0xb6, 0xae, 0xba, 0x3d, 0x78, 0x42, 0xb9, 0x00, 0x84, 0xb5, 0x81, 0xaa,
-	0xc7, 0x4a, 0x8d, 0xe9, 0x65, 0xdd, 0x2c, 0x58, 0x81, 0x0e, 0xb5, 0xdf, 0x78, 0x55, 0x20, 0xfc,
-	0x65, 0x0d, 0x0d, 0xa7, 0x73, 0x91, 0x72, 0x90, 0x17, 0x66, 0x49, 0xe5, 0x20, 0x2f, 0xce, 0x99,
-	0x22, 0x2f, 0x50, 0xe4, 0x67, 0xf0, 0x54, 0x11, 0xe4, 0xb3, 0xd9, 0x55, 0xb5, 0x95, 0xc4, 0xd5,
-	0xb2, 0x8a, 0xbf, 0xa4, 0xa1, 0x6d, 0xe9, 0x69, 0xc2, 0x2d, 0x30, 0xa1, 0x5c, 0xd1, 0xa5, 0x49,
-	0x91, 0x16, 0xff, 0x21, 0x67, 0x29, 0x29, 0x27, 0xf1, 0xf1, 0x5e, 0x48, 0xc1, 0x6f, 0x6a, 0x68,
-	0x30, 0x59, 0x3c, 0x06, 0xab, 0x0f, 0x10, 0x41, 0x45, 0x9c, 0xea, 0xd1, 0x12, 0x23, 0x00, 0xe7,
-	0x2b, 0x14, 0xe7, 0x49, 0x7c, 0xa1, 0x08, 0xce, 0xa9, 0x2a, 0x38, 0xb5, 0x95, 0xc4, 0x66, 0x58,
-	0x0d, 0xcf, 0xcb, 0xad, 0xc9, 0x19, 0x42, 0xce, 0xab, 0xcf, 0x92, 0x92, 0x14, 0x48, 0xaa, 0xf3,
-	0x90, 0xd3, 0x94, 0x82, 0x63, 0xf8, 0x68, 0x69, 0x0a, 0xf0, 0x4f, 0x35, 0xf4, 0x98, 0xb0, 0xea,
-	0x0a, 0x3e, 0x5d, 0x70, 0x29, 0x77, 0xd7, 0x9b, 0xa9, 0x3e, 0xdf, 0xcb, 0x50, 0xa0, 0x45, 0xa7,
-	0xb4, 0xbc, 0x82, 0xef, 0x97, 0x5d, 0x41, 0x09, 0x37, 0x71, 0x5a, 0x2e, 0x99, 0x1d, 0xf2, 0x1d,
-	0x0d, 0x8d, 0x0a, 0x51, 0x08, 0xc5, 0x75, 0xba, 0xe0, 0xa2, 0x2f, 0x47, 0x74, 0x5e, 0xb9, 0x1c,
-	0x32, 0x4d, 0x89, 0x3e, 0x87, 0xcf, 0xac, 0x81, 0x68, 0xfc, 0x4d, 0x0d, 0xe1, 0xee, 0xba, 0x33,
-	0x58, 0xb1, 0x8f, 0xa5, 0xa5, 0x6e, 0xaa, 0xc7, 0xcb, 0x0d, 0x02, 0x32, 0x66, 0x29, 0x19, 0x2f,
-	0xe0, 0xab, 0x85, 0xae, 0x41, 0x5e, 0x36, 0xc6, 0xf2, 0xf5, 0x79, 0xd7, 0x63, 0x36, 0x55, 0x6d,
-	0x25, 0x69, 0x35, 0xae, 0xe2, 0x7f, 0xd0, 0xd0, 0x0e, 0x71, 0x39, 0x17, 0xfc, 0x9c, 0x12, 0x45,
-	0x79, 0x99, 0x92, 0xea, 0xa9, 0xf2, 0x03, 0x81, 0xbe, 0x3b, 0x94, 0xbe, 0x9b, 0xf8, 0x7a, 0x51,
-	0xfa, 0x12, 0xe2, 0x91, 0xd3, 0xf8, 0xb6, 0x86, 0x46, 0x65, 0xe5, 0x50, 0x54, 0x0b, 0x32, 0xa7,
-	0x1c, 0x8b, 0x6a, 0x41, 0xe6, 0x55, 0x5f, 0x21, 0xf7, 0x29, 0xa5, 0xb7, 0xf0, 0x4b, 0x85, 0x29,
-	0x9d, 0x28, 0x46, 0xec, 0x7f, 0x69, 0x68, 0x24, 0x5b, 0x57, 0x41, 0xa5, 0xf0, 0x48, 0x6a, 0x95,
-	0xa8, 0x14, 0x1e, 0x59, 0xc9, 0x10, 0xf2, 0x41, 0x4a, 0xd4, 0x32, 0x7e, 0x50, 0x82, 0x28, 0x3f,
-	0x84, 0xa3, 0xb3, 0xaa, 0x10, 0xb5, 0x15, 0x55, 0x7d, 0x84, 0xd5, 0xd4, 0xa9, 0xc3, 0x1d, 0xd9,
-	0xab, 0xb5, 0x15, 0xee, 0x36, 0x5f, 0xc5, 0x9f, 0xac, 0xa0, 0x51, 0x59, 0x2d, 0x02, 0x95, 0xa4,
-	0x73, 0x2a, 0x93, 0xa8, 0x24, 0x9d, 0x57, 0x20, 0x84, 0x7c, 0x4c, 0xa3, 0x5c, 0xf9, 0x90, 0x86,
-	0x3f, 0x50, 0x84, 0x2d, 0xe0, 0x0e, 0x66, 0x11, 0xf6, 0x7a, 0xb2, 0xd4, 0xc2, 0x9a, 0xb9, 0xf3,
-	0x91, 0x0a, 0xda, 0xa3, 0xaa, 0xf3, 0x81, 0xcf, 0xa9, 0xf5, 0xf2, 0x9c, 0x5a, 0x24, 0xd5, 0xf3,
-	0xbd, 0x0e, 0x07, 0x4e, 0x99, 0x94, 0x51, 0xbf, 0x80, 0x5f, 0x2d, 0xc2, 0x27, 0xc3, 0x71, 0x74,
-	0xc1, 0x12, 0xf2, 0x73, 0xb8, 0x84, 0x3f, 0x55, 0x41, 0xfb, 0x8b, 0xd4, 0xcf, 0xc0, 0x97, 0x94,
-	0xd4, 0x14, 0x2d, 0xfa, 0x51, 0xbd, 0xbc, 0x56, 0x30, 0xc0, 0x9c, 0xf7, 0x51, 0xe6, 0x34, 0xf0,
-	0x5c, 0x51, 0xe6, 0xc8, 0x17, 0x52, 0x2e, 0x8f, 0x3e, 0xaf, 0xa1, 0xad, 0x99, 0xf2, 0x17, 0x39,
-	0x9a, 0xa2, 0xa0, 0x90, 0x46, 0x8e, 0xa6, 0x28, 0xaa, 0xad, 0x51, 0xce, 0xec, 0x0f, 0xad, 0x8c,
-	0x54, 0xc2, 0x06, 0xfe, 0x82, 0x86, 0x86, 0xd3, 0x65, 0x31, 0x72, 0x6c, 0x0c, 0x61, 0xa9, 0x8e,
-	0x1c, 0x1b, 0x43, 0x5c, 0xbd, 0x83, 0x9c, 0xa1, 0xa8, 0x9f, 0xc0, 0xc7, 0x8a, 0xa0, 0x9e, 0xa9,
-	0xf3, 0x81, 0x7f, 0xa6, 0xa1, 0xc7, 0x95, 0x25, 0x35, 0xf0, 0x79, 0x25, 0x4e, 0xb9, 0xb5, 0x3d,
-	0xaa, 0x17, 0x7a, 0x1e, 0x0f, 0xf4, 0xdd, 0xa4, 0xf4, 0x5d, 0xc5, 0x97, 0x8b, 0x8a, 0x26, 0x53,
-	0x9c, 0x9e, 0xbd, 0x2f, 0xeb, 0x51, 0x39, 0x8f, 0xaf, 0x6b, 0xe8, 0x31, 0x61, 0x2d, 0x0e, 0x7c,
-	0x52, 0x8e, 0xaa, 0xaa, 0xc2, 0x47, 0xf5, 0xb9, 0xd2, 0xe3, 0x80, 0xb4, 0x19, 0x4a, 0xda, 0x79,
-	0x7c, 0xb6, 0x08, 0x69, 0xa9, 0x15, 0x97, 0xb4, 0xad, 0x7e, 0x53, 0x43, 0x03, 0x51, 0x75, 0x0b,
-	0x7c, 0x58, 0x71, 0x63, 0x64, 0x8a, 0x6c, 0x54, 0x8f, 0x14, 0xea, 0x0b, 0xc8, 0x9e, 0xa4, 0xc8,
-	0x3e, 0x8b, 0xc7, 0x0b, 0x5d, 0x26, 0x74, 0xb8, 0x6e, 0x38, 0x0e, 0xfe, 0xbe, 0x86, 0x46, 0xb2,
-	0x95, 0x13, 0xf0, 0xf1, 0x62, 0x6e, 0xb9, 0x74, 0x79, 0x88, 0xea, 0x89, 0x92, 0xa3, 0x00, 0xf3,
-	0xd7, 0x28, 0xe6, 0x2f, 0xe3, 0x7b, 0xe5, 0xdc, 0x21, 0x50, 0x12, 0xa2, 0xb6, 0x92, 0xad, 0xb4,
-	0xb1, 0x5a, 0x5b, 0x49, 0xd4, 0x4e, 0x58, 0xc5, 0x7f, 0xae, 0xa1, 0x47, 0xb3, 0x93, 0x87, 0xa2,
-	0x38, 0x5e, 0xcc, 0x99, 0x57, 0x9c, 0x48, 0x45, 0x35, 0x8b, 0x1e, 0x1d, 0x97, 0x9c, 0x48, 0xfc,
-	0x3f, 0x1a, 0xaa, 0xca, 0x53, 0xd9, 0x73, 0x4e, 0x81, 0xdc, 0x62, 0x0c, 0x39, 0xa7, 0x40, 0x7e,
-	0x59, 0x05, 0xf2, 0x5e, 0x4a, 0xde, 0xbb, 0xf1, 0xcb, 0xe5, 0xc8, 0xeb, 0xfe, 0x5f, 0x20, 0xc0,
-	0x66, 0xbc, 0xd6, 0xc8, 0x4a, 0xf1, 0x6d, 0x0d, 0x3d, 0x2e, 0x47, 0x24, 0x94, 0xe7, 0xf9, 0x62,
-	0x92, 0xe9, 0x85, 0x09, 0x85, 0x6a, 0x4b, 0x90, 0xab, 0x94, 0x09, 0x53, 0xf8, 0xe2, 0x5a, 0x99,
-	0x80, 0x7f, 0xb9, 0x82, 0xf6, 0xe6, 0x15, 0x60, 0xc0, 0x93, 0x65, 0x85, 0xd6, 0x55, 0x1d, 0xa2,
-	0x3a, 0xb5, 0x16, 0x10, 0x40, 0xb5, 0x41, 0xa9, 0x7e, 0x15, 0xbf, 0x52, 0xf4, 0x02, 0x10, 0x52,
-	0x1e, 0xd7, 0x51, 0xa8, 0xad, 0xd8, 0x8d, 0x50, 0x3f, 0x8d, 0x6a, 0x52, 0xac, 0xe2, 0x7f, 0xd5,
-	0xd0, 0x4e, 0x49, 0xce, 0x38, 0x56, 0x48, 0xad, 0x50, 0xfd, 0x84, 0xea, 0xc5, 0xde, 0x01, 0x00,
-	0x07, 0x6e, 0x53, 0x0e, 0xdc, 0xc0, 0x2f, 0x16, 0x77, 0x22, 0x08, 0xfe, 0x2b, 0x93, 0x8c, 0xb7,
-	0xe4, 0x13, 0x15, 0xb4, 0xbf, 0x48, 0x5d, 0x02, 0x95, 0x3e, 0x5a, 0xa2, 0xa6, 0x82, 0x4a, 0x1f,
-	0x2d, 0x53, 0x1e, 0xa1, 0x9c, 0xb2, 0x5e, 0x90, 0x19, 0x29, 0x13, 0x26, 0x3c, 0x0c, 0xbe, 0xa7,
-	0xa1, 0xaa, 0x04, 0xab, 0xf0, 0x24, 0x38, 0x93, 0xef, 0x11, 0x92, 0xd6, 0x51, 0xa8, 0x9e, 0xed,
-	0x6d, 0x30, 0x90, 0x7f, 0x89, 0x92, 0x7f, 0x01, 0x9f, 0x5b, 0x13, 0xf9, 0xf8, 0x4b, 0x1a, 0x1a,
-	0x4a, 0x25, 0xea, 0x63, 0xc5, 0xd3, 0x93, 0xa8, 0x8c, 0x41, 0xb5, 0x56, 0xb8, 0x7f, 0x2f, 0xa7,
-	0x57, 0xea, 0xff, 0xd6, 0xc9, 0xb8, 0xfd, 0xf0, 0x17, 0x35, 0x34, 0x92, 0xad, 0x51, 0xa0, 0x72,
-	0x35, 0x48, 0xea, 0x1d, 0xa8, 0x5c, 0x0d, 0xb2, 0x12, 0x08, 0xe4, 0x3c, 0xa5, 0xe2, 0x14, 0x3e,
-	0x59, 0x9e, 0x0a, 0xaa, 0x0e, 0xfd, 0x9b, 0x86, 0xaa, 0xf2, 0xa2, 0x05, 0xaa, 0x95, 0x95, 0x5b,
-	0x3a, 0x41, 0xb5, 0xb2, 0xf2, 0xeb, 0x24, 0x90, 0x57, 0x28, 0x65, 0xb7, 0xf1, 0xad, 0xa2, 0xe7,
-	0xac, 0xb4, 0x82, 0x41, 0xd7, 0x76, 0xfa, 0x29, 0x33, 0x33, 0xe4, 0x85, 0x11, 0x72, 0x14, 0x8c,
-	0xdc, 0xfa, 0x0b, 0x39, 0x0a, 0x46, 0x7e, 0x45, 0x06, 0x72, 0x83, 0x52, 0x7f, 0x05, 0x5f, 0x2a,
-	0x4a, 0x3d, 0xf5, 0x03, 0xc8, 0x38, 0x80, 0xbf, 0xa6, 0xa1, 0xd1, 0x34, 0xcf, 0xe3, 0x9c, 0x78,
-	0x95, 0xa1, 0xa1, 0xca, 0xb4, 0x57, 0x19, 0x1a, 0xca, 0xe4, 0xfb, 0x72, 0x8b, 0xb6, 0x3b, 0x4d,
-	0x1f, 0xff, 0x8b, 0x86, 0xf6, 0xa8, 0xd2, 0xdb, 0x55, 0x0e, 0x9c, 0x02, 0x69, 0xf9, 0x2a, 0x07,
-	0x4e, 0x91, 0xac, 0x7a, 0xf2, 0x12, 0xa5, 0xef, 0x1a, 0xbe, 0x52, 0x84, 0xbe, 0x28, 0x85, 0xb4,
-	0xb6, 0x12, 0xfd, 0xb9, 0x5a, 0x4b, 0xa5, 0xef, 0xe2, 0x0f, 0x57, 0x10, 0x91, 0x65, 0xd8, 0xc7,
-	0x09, 0xef, 0x78, 0x2a, 0x17, 0xef, 0xdc, 0xfc, 0x7c, 0x95, 0x8b, 0x2f, 0x2f, 0xfd, 0x9a, 0xbc,
-	0x4a, 0xe9, 0xbe, 0x8b, 0x6f, 0xaf, 0x03, 0xdd, 0x90, 0xb2, 0x3f, 0x17, 0x11, 0xf7, 0x17, 0x1a,
-	0xda, 0xc6, 0x22, 0xf5, 0x93, 0x71, 0x64, 0x0a, 0xf3, 0x44, 0x91, 0x91, 0x5d, 0x3d, 0x59, 0x76,
-	0xd8, 0x5a, 0x57, 0x6e, 0x8d, 0x95, 0xe1, 0x7d, 0x53, 0x43, 0xa3, 0x71, 0x16, 0x74, 0x3a, 0x1d,
-	0x18, 0x1f, 0x29, 0x96, 0x39, 0xcd, 0x28, 0x78, 0xba, 0x4c, 0x9a, 0x75, 0xb9, 0x6b, 0xba, 0x11,
-	0x8e, 0x4f, 0xc8, 0x27, 0x3c, 0x5a, 0xd8, 0xc6, 0xfb, 0x68, 0x05, 0x1d, 0x2a, 0x5c, 0x7f, 0x01,
-	0xbf, 0x50, 0x7e, 0x29, 0xc9, 0x8a, 0x38, 0xac, 0x69, 0x59, 0xf6, 0xb8, 0x1d, 0xe5, 0x4b, 0xf1,
-	0x9f, 0x34, 0xb4, 0xbf, 0x48, 0xc9, 0x08, 0x95, 0xae, 0x5a, 0xa2, 0xe4, 0xc4, 0x9a, 0x88, 0x2f,
-	0x65, 0x88, 0x47, 0x92, 0x8e, 0x4e, 0x9e, 0x9f, 0x68, 0x68, 0x6f, 0x5e, 0xb1, 0x07, 0x95, 0x65,
-	0x56, 0xb0, 0xde, 0x85, 0xca, 0x32, 0x2b, 0x5a, 0x6b, 0x82, 0x5c, 0xa4, 0xa4, 0x3e, 0x8f, 0x4f,
-	0x95, 0x70, 0x09, 0xa5, 0xa9, 0xfd, 0x91, 0x86, 0x76, 0x2b, 0x52, 0xea, 0xb1, 0x5a, 0xa3, 0xc9,
-	0xc9, 0xda, 0xaf, 0x9e, 0xeb, 0x71, 0x74, 0x2f, 0xd1, 0x1b, 0xa1, 0x4a, 0x20, 0x4f, 0xe8, 0xc7,
-	0x7f, 0xca, 0xa3, 0x97, 0xe2, 0x9c, 0xf0, 0x89, 0x7c, 0x6d, 0x2d, 0x9b, 0x05, 0x9f, 0xe3, 0x21,
-	0x16, 0xe7, 0xb3, 0x97, 0x73, 0x33, 0x66, 0xfe, 0xaf, 0xca, 0xda, 0x0a, 0xf7, 0xcd, 0x7f, 0x51,
-	0x43, 0xdb, 0xd2, 0x13, 0xe4, 0xc7, 0x9f, 0x94, 0x26, 0x42, 0x9a, 0x94, 0x5f, 0xce, 0xcd, 0x9d,
-	0x21, 0x02, 0xff, 0x4c, 0x43, 0xdb, 0xba, 0xf2, 0xab, 0xb1, 0xda, 0x9d, 0x28, 0xcb, 0xae, 0x57,
-	0x5d, 0x65, 0xaa, 0x24, 0x78, 0xe2, 0x50, 0x0a, 0xe6, 0x71, 0xa3, 0x08, 0x05, 0x2c, 0xe9, 0x5b,
-	0x0f, 0x62, 0x38, 0xb5, 0x95, 0x64, 0x4e, 0xff, 0x2a, 0x7f, 0x7e, 0x65, 0xf9, 0xfb, 0xd4, 0x9d,
-	0x91, 0xc8, 0xd5, 0x5f, 0xc5, 0x5f, 0xd1, 0x10, 0xee, 0xce, 0x4f, 0x57, 0xa9, 0x9e, 0xaa, 0xf4,
-	0x79, 0x95, 0xea, 0xa9, 0x4c, 0x84, 0x2f, 0x17, 0xbf, 0xd5, 0x4d, 0xb5, 0x8f, 0xbf, 0xad, 0xa1,
-	0x1d, 0xe2, 0x8c, 0x66, 0x55, 0xa0, 0x80, 0x32, 0x89, 0x5a, 0x15, 0x28, 0xa0, 0x4e, 0x9e, 0x2e,
-	0x17, 0x52, 0x04, 0xe4, 0x44, 0x69, 0x3b, 0xb5, 0x15, 0x9e, 0xba, 0x4d, 0xc3, 0x19, 0x87, 0x52,
-	0x09, 0xbd, 0x2a, 0x03, 0x5c, 0x94, 0x16, 0xac, 0x32, 0xc0, 0x85, 0x99, 0xc2, 0xe4, 0x79, 0x8a,
-	0xfb, 0x71, 0x3c, 0x51, 0x04, 0xf7, 0xf4, 0x7f, 0xc7, 0x8a, 0xbf, 0xa5, 0xa1, 0xed, 0xa2, 0x1c,
-	0x78, 0xd5, 0x26, 0x52, 0x64, 0xdc, 0xab, 0x36, 0x91, 0x2a, 0xd5, 0x9e, 0x5c, 0xa7, 0x34, 0x5c,
-	0xc6, 0x33, 0x45, 0x68, 0x78, 0xc0, 0x20, 0xb1, 0xe4, 0x4e, 0x5e, 0x28, 0xc0, 0x4f, 0xc4, 0x36,
-	0xfe, 0xb7, 0x86, 0xf6, 0xa8, 0xf2, 0xcb, 0x55, 0x76, 0x4d, 0x81, 0x74, 0x77, 0x95, 0x5d, 0x53,
-	0x24, 0xad, 0xbd, 0x5c, 0xc8, 0x14, 0xdc, 0x3a, 0x96, 0x9e, 0x26, 0x7b, 0xde, 0xf5, 0xc2, 0x0d,
-	0x15, 0x1e, 0xe5, 0xd9, 0xd4, 0xfb, 0x55, 0xfc, 0x63, 0x0d, 0x8d, 0xca, 0x72, 0xda, 0x55, 0x71,
-	0x0b, 0x39, 0xc9, 0xf4, 0x2a, 0x05, 0x2a, 0x2f, 0x85, 0xbe, 0x5c, 0x2c, 0x4e, 0x44, 0xb4, 0x3d,
-	0x67, 0x76, 0x13, 0x1c, 0x25, 0xf4, 0xaf, 0xe2, 0xbf, 0xd1, 0xd0, 0x0e, 0x71, 0x3e, 0xb0, 0xea,
-	0x18, 0x51, 0xe6, 0x19, 0xab, 0x8e, 0x11, 0x75, 0xea, 0x71, 0x39, 0xf3, 0x20, 0x93, 0xa4, 0x1c,
-	0x13, 0x48, 0x9f, 0xfe, 0xa2, 0x44, 0x7c, 0xd5, 0xd3, 0x5f, 0x36, 0x8f, 0x5f, 0xf5, 0xf4, 0xd7,
-	0x95, 0xd9, 0x5f, 0xee, 0xe9, 0x8f, 0xfb, 0x55, 0xe7, 0xdd, 0x50, 0xbb, 0xdb, 0x29, 0x49, 0x3b,
-	0xc7, 0xa7, 0x72, 0x0c, 0x42, 0x69, 0xca, 0x7b, 0xf5, 0x74, 0x0f, 0x23, 0x81, 0x90, 0x7b, 0x94,
-	0x90, 0x59, 0x7c, 0xb3, 0xd0, 0x83, 0x2b, 0x2d, 0x09, 0xd9, 0x76, 0xf5, 0x38, 0x9a, 0xcd, 0xe0,
-	0x49, 0x41, 0x70, 0xfb, 0xc2, 0x7b, 0x20, 0xfe, 0x4f, 0x0d, 0xed, 0x56, 0x24, 0xb5, 0xab, 0xd4,
-	0xd8, 0xfc, 0xc4, 0x7a, 0x95, 0x1a, 0x5b, 0x20, 0x93, 0x9e, 0xbc, 0x9b, 0x12, 0x7d, 0x07, 0xd7,
-	0x4b, 0x12, 0x9d, 0x8c, 0xfa, 0x92, 0x11, 0xfe, 0x1d, 0x0d, 0x3d, 0x26, 0x4c, 0x52, 0xc7, 0x6a,
-	0x2d, 0x49, 0x9a, 0x15, 0xaf, 0x52, 0x34, 0x94, 0xd9, 0xf0, 0xe5, 0x6e, 0x06, 0xc8, 0x3c, 0xb7,
-	0x3c, 0x38, 0x33, 0x68, 0x8c, 0x40, 0x32, 0x64, 0xe9, 0xef, 0x35, 0xb4, 0x4b, 0x9a, 0xc3, 0x8e,
-	0x9f, 0xcf, 0xf3, 0x36, 0xca, 0x13, 0xec, 0xab, 0x67, 0x7a, 0x1a, 0x0b, 0x44, 0x5e, 0xa6, 0x44,
-	0x5e, 0xc4, 0xe7, 0x0b, 0x07, 0xe3, 0x88, 0x08, 0xf5, 0xf1, 0x9f, 0x69, 0x68, 0x24, 0x9b, 0xf3,
-	0x8e, 0x8f, 0xe6, 0xb3, 0x3e, 0x93, 0x5a, 0x5f, 0x9d, 0x28, 0x33, 0xa4, 0x97, 0xb3, 0x2f, 0x95,
-	0xff, 0xbe, 0x9c, 0x94, 0xd0, 0x5f, 0xb1, 0xa5, 0xd7, 0x9d, 0x3e, 0x9f, 0xb3, 0xf4, 0xa4, 0x49,
-	0xf9, 0x39, 0x4b, 0x4f, 0x9e, 0xa7, 0x5f, 0xce, 0x0e, 0x8e, 0xa5, 0x12, 0x67, 0xf5, 0xe3, 0x7f,
-	0x0f, 0x89, 0x11, 0xa5, 0xa4, 0x2b, 0x89, 0x51, 0x64, 0xde, 0x2b, 0x89, 0x51, 0xe5, 0xbe, 0x13,
-	0x9b, 0x12, 0x63, 0x62, 0xa3, 0x90, 0xd5, 0x0b, 0xa0, 0x42, 0x83, 0x3e, 0x99, 0xbf, 0x5f, 0x5b,
-	0xc9, 0xa4, 0xfd, 0xaf, 0xd6, 0x56, 0xb2, 0xf9, 0xfd, 0xab, 0xf8, 0x73, 0x1a, 0x1a, 0x4a, 0xa5,
-	0x96, 0xe7, 0x2d, 0x41, 0x41, 0xaa, 0x7b, 0xde, 0x12, 0x14, 0x65, 0xbf, 0x97, 0xd3, 0x84, 0xd3,
-	0x79, 0xf2, 0xf8, 0x2f, 0xb5, 0x54, 0x1d, 0xe1, 0x28, 0x73, 0x5f, 0xa5, 0x09, 0x2b, 0xaa, 0x01,
-	0x54, 0x4f, 0x96, 0x1d, 0x06, 0x34, 0x4c, 0x51, 0x1a, 0xce, 0xe2, 0xe7, 0x4b, 0x7a, 0x46, 0x75,
-	0x23, 0x04, 0xa5, 0x3b, 0x21, 0xca, 0xdf, 0xd1, 0xd0, 0x76, 0x51, 0xae, 0xbd, 0x8a, 0x16, 0x45,
-	0x82, 0xbf, 0x8a, 0x16, 0x55, 0x4a, 0x7f, 0x39, 0x87, 0xa1, 0x05, 0x90, 0xf4, 0x94, 0xbb, 0x37,
-	0xfd, 0xb8, 0xfd, 0x96, 0x86, 0xaa, 0xf2, 0xa4, 0x7d, 0xe5, 0xfb, 0x6d, 0x5e, 0x55, 0x00, 0xe5,
-	0xfb, 0x6d, 0x6e, 0x9d, 0x00, 0x72, 0x8d, 0x92, 0x3a, 0x8d, 0x27, 0x0b, 0x9d, 0x15, 0xaa, 0x7a,
-	0x43, 0xf8, 0xfb, 0x1a, 0xda, 0x15, 0x2e, 0x09, 0x61, 0x3a, 0xbf, 0x32, 0x9a, 0x4d, 0x51, 0x45,
-	0x40, 0x19, 0xcd, 0xa6, 0xaa, 0x1b, 0x40, 0x6e, 0x51, 0xca, 0x5e, 0xc4, 0xd7, 0x8a, 0xe9, 0x19,
-	0x22, 0x92, 0xb2, 0x62, 0xfc, 0x82, 0x86, 0xb6, 0xd2, 0x45, 0x1f, 0x27, 0x83, 0x63, 0x85, 0x1f,
-	0xbe, 0x3b, 0xdf, 0xbc, 0xfa, 0x4c, 0xc1, 0xde, 0xbd, 0xdc, 0xaf, 0x90, 0x69, 0x46, 0x93, 0xcc,
-	0x33, 0x88, 0xff, 0xad, 0x86, 0x46, 0x65, 0x99, 0xfe, 0xca, 0xc8, 0x7f, 0x75, 0x39, 0x02, 0x65,
-	0xe4, 0x7f, 0x4e, 0x61, 0x81, 0x72, 0xb4, 0xa5, 0x1e, 0x01, 0x1f, 0xd8, 0xc1, 0x62, 0x64, 0x3e,
-	0x87, 0x5a, 0xfd, 0x63, 0xc2, 0x4c, 0x75, 0xe5, 0xbb, 0xa6, 0x22, 0xf7, 0x5e, 0xf9, 0xae, 0xa9,
-	0x4a, 0xac, 0x27, 0xef, 0xa1, 0x24, 0xdd, 0xc3, 0x77, 0xca, 0xa7, 0x6d, 0xe8, 0x3c, 0x51, 0xbd,
-	0x3b, 0x26, 0x99, 0x7b, 0x3c, 0xff, 0x48, 0x43, 0xc3, 0xe9, 0xb4, 0xf1, 0x1c, 0x9f, 0xad, 0x30,
-	0xa3, 0x3d, 0xc7, 0x67, 0x2b, 0x4e, 0x6a, 0x2f, 0xa7, 0x52, 0x34, 0x00, 0x86, 0xce, 0x92, 0xda,
-	0x6b, 0x2b, 0xa1, 0x7e, 0xf4, 0x4d, 0x0d, 0xed, 0x10, 0x27, 0xe9, 0x2b, 0x13, 0x6c, 0x54, 0x45,
-	0x04, 0x94, 0x09, 0x36, 0xca, 0xb2, 0x02, 0x25, 0x7d, 0xd0, 0x1c, 0x16, 0xc4, 0x4d, 0x44, 0x35,
-	0x05, 0xfe, 0x43, 0x43, 0x3b, 0xc4, 0xf9, 0xed, 0x39, 0x2a, 0xb9, 0x32, 0x8b, 0x3f, 0x47, 0x25,
-	0x57, 0x27, 0xe5, 0x97, 0x0b, 0x4f, 0x8b, 0x24, 0xb5, 0xe8, 0xf2, 0x4a, 0x76, 0x3c, 0x64, 0x42,
-	0x1a, 0x8f, 0x44, 0x53, 0x3f, 0x87, 0x66, 0xdd, 0xe9, 0x19, 0xcb, 0xb1, 0x16, 0x58, 0x11, 0x8e,
-	0x71, 0xe5, 0x8e, 0x89, 0x3b, 0x16, 0xf0, 0x15, 0x66, 0xfa, 0xf7, 0x12, 0xac, 0x13, 0x6e, 0xa0,
-	0x46, 0x04, 0x23, 0x8d, 0xfc, 0xd4, 0x4b, 0x5f, 0x7d, 0x6b, 0x4c, 0xfb, 0xc6, 0x5b, 0x63, 0xda,
-	0x0f, 0xde, 0x1a, 0xd3, 0x7e, 0xed, 0x87, 0x63, 0x8f, 0x7c, 0xe3, 0x87, 0x63, 0x8f, 0x7c, 0xf7,
-	0x87, 0x63, 0x8f, 0xbc, 0xfb, 0xc4, 0x82, 0x1d, 0x2c, 0x76, 0xe6, 0xc6, 0x4d, 0xb7, 0x29, 0x9f,
-	0xe5, 0x61, 0x32, 0x7a, 0x7d, 0xb9, 0x6d, 0xf9, 0x73, 0x9b, 0xda, 0x9e, 0x1b, 0xb8, 0xc7, 0xfe,
-	0x37, 0x00, 0x00, 0xff, 0xff, 0x24, 0xaf, 0xd2, 0xba, 0x88, 0x8e, 0x00, 0x00,
+func (m *QueryMaintenanceCreditRequest) Reset()         { *m = QueryMaintenanceCreditRequest{} }
+func (m *QueryMaintenanceCreditRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceCreditRequest) ProtoMessage()    {}
+func (*QueryMaintenanceCreditRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{168}
+}
+func (m *QueryMaintenanceCreditRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceCreditRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceCreditRequest.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 *QueryMaintenanceCreditRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceCreditRequest.Merge(m, src)
+}
+func (m *QueryMaintenanceCreditRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceCreditRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceCreditRequest.DiscardUnknown(m)
 }
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
+var xxx_messageInfo_QueryMaintenanceCreditRequest proto.InternalMessageInfo
 
-// QueryClient is the client API for Query service.
-//
-// 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 {
-	// Parameters queries the parameters of the module.
-	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
-	// Queries a list of Inference items.
-	Inference(ctx context.Context, in *QueryGetInferenceRequest, opts ...grpc.CallOption) (*QueryGetInferenceResponse, error)
-	InferenceAll(ctx context.Context, in *QueryAllInferenceRequest, opts ...grpc.CallOption) (*QueryAllInferenceResponse, error)
-	// Queries a list of Participant items.
-	Participant(ctx context.Context, in *QueryGetParticipantRequest, opts ...grpc.CallOption) (*QueryGetParticipantResponse, error)
-	ParticipantAll(ctx context.Context, in *QueryAllParticipantRequest, opts ...grpc.CallOption) (*QueryAllParticipantResponse, error)
-	// Queries account public key and balance by address.
-	AccountByAddress(ctx context.Context, in *QueryAccountByAddressRequest, opts ...grpc.CallOption) (*QueryAccountByAddressResponse, error)
-	// Queries a list of GetRandomExecutor items.
-	GetRandomExecutor(ctx context.Context, in *QueryGetRandomExecutorRequest, opts ...grpc.CallOption) (*QueryGetRandomExecutorResponse, error)
-	// Queries a list of EpochGroupData items.
-	EpochGroupData(ctx context.Context, in *QueryGetEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupDataResponse, error)
-	EpochGroupDataAll(ctx context.Context, in *QueryAllEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupDataResponse, error)
-	// Queries a list of SettleAmount items.
-	SettleAmount(ctx context.Context, in *QueryGetSettleAmountRequest, opts ...grpc.CallOption) (*QueryGetSettleAmountResponse, error)
-	SettleAmountAll(ctx context.Context, in *QueryAllSettleAmountRequest, opts ...grpc.CallOption) (*QueryAllSettleAmountResponse, error)
-	// Queries a list of EpochGroupValidations items.
-	EpochGroupValidations(ctx context.Context, in *QueryGetEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupValidationsResponse, error)
-	EpochGroupValidationsAll(ctx context.Context, in *QueryAllEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupValidationsResponse, error)
-	// Queries a list of PocBatchesForStage items.
-	PocBatchesForStage(ctx context.Context, in *QueryPocBatchesForStageRequest, opts ...grpc.CallOption) (*QueryPocBatchesForStageResponse, error)
-	// Queries a list of PocValidationsForStage items.
-	PocValidationsForStage(ctx context.Context, in *QueryPocValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocValidationsForStageResponse, error)
-	// PoC v2 validation queries
-	PocV2ValidationsForStage(ctx context.Context, in *QueryPocV2ValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocV2ValidationsForStageResponse, error)
-	// PoC v2 off-chain commit queries
-	PoCV2StoreCommit(ctx context.Context, in *QueryPoCV2StoreCommitRequest, opts ...grpc.CallOption) (*QueryPoCV2StoreCommitResponse, error)
-	MLNodeWeightDistribution(ctx context.Context, in *QueryMLNodeWeightDistributionRequest, opts ...grpc.CallOption) (*QueryMLNodeWeightDistributionResponse, error)
-	AllPoCV2StoreCommitsForStage(ctx context.Context, in *QueryAllPoCV2StoreCommitsForStageRequest, opts ...grpc.CallOption) (*QueryAllPoCV2StoreCommitsForStageResponse, error)
-	AllMLNodeWeightDistributionsForStage(ctx context.Context, in *QueryAllMLNodeWeightDistributionsForStageRequest, opts ...grpc.CallOption) (*QueryAllMLNodeWeightDistributionsForStageResponse, error)
-	// Queries a list of GetCurrentEpoch items.
-	GetCurrentEpoch(ctx context.Context, in *QueryGetCurrentEpochRequest, opts ...grpc.CallOption) (*QueryGetCurrentEpochResponse, error)
-	// Queries a TokenomicsData by index.
-	TokenomicsData(ctx context.Context, in *QueryGetTokenomicsDataRequest, opts ...grpc.CallOption) (*QueryGetTokenomicsDataResponse, error)
-	// Queries a list of GetUnitOfComputePriceProposal items.
-	GetUnitOfComputePriceProposal(ctx context.Context, in *QueryGetUnitOfComputePriceProposalRequest, opts ...grpc.CallOption) (*QueryGetUnitOfComputePriceProposalResponse, error)
-	// Queries a list of CurrentEpochGroupData items.
-	CurrentEpochGroupData(ctx context.Context, in *QueryCurrentEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryCurrentEpochGroupDataResponse, error)
-	// Queries a list of ModelsAll items.
-	ModelsAll(ctx context.Context, in *QueryModelsAllRequest, opts ...grpc.CallOption) (*QueryModelsAllResponse, error)
-	// Queries a list of InferenceTimeout items.
-	InferenceTimeout(ctx context.Context, in *QueryGetInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryGetInferenceTimeoutResponse, error)
-	InferenceTimeoutAll(ctx context.Context, in *QueryAllInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryAllInferenceTimeoutResponse, error)
-	// BE CAREFUL, epoch_id in the request body meand epoch_group_id!!
-	InferenceValidationDetails(ctx context.Context, in *QueryGetInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationDetailsResponse, error)
-	// Queries a list of InferenceValidationDetails items.
-	InferenceValidationDetailsAll(ctx context.Context, in *QueryAllInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryAllInferenceValidationDetailsResponse, error)
-	// Queries a list of GetInferenceValidationParameters items.
-	GetInferenceValidationParameters(ctx context.Context, in *QueryGetInferenceValidationParametersRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationParametersResponse, error)
-	// Queries a list of EpochPerformanceSummary items.
-	// Returns all EpochPerformanceSummary records for a specific epoch index.
-	EpochPerformanceSummary(ctx context.Context, in *QueryEpochPerformanceSummaryByEpochRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByEpochResponse, error)
-	// Returns a single EpochPerformanceSummary record for a specific epoch index and participant.
-	EpochPerformanceSummaryByParticipant(ctx context.Context, in *QueryEpochPerformanceSummaryByParticipantRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByParticipantResponse, error)
-	EpochPerformanceSummaryAll(ctx context.Context, in *QueryAllEpochPerformanceSummaryRequest, opts ...grpc.CallOption) (*QueryAllEpochPerformanceSummaryResponse, error)
-	// Queries a list of HardwareNodes items.
-	HardwareNodes(ctx context.Context, in *QueryHardwareNodesRequest, opts ...grpc.CallOption) (*QueryHardwareNodesResponse, error)
-	// Queries a list of HardwareNodesAll items.
-	HardwareNodesAll(ctx context.Context, in *QueryHardwareNodesAllRequest, opts ...grpc.CallOption) (*QueryHardwareNodesAllResponse, error)
-	// Queries a list of GetParticipantCurrentStats items.
-	GetParticipantCurrentStats(ctx context.Context, in *QueryGetParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetParticipantCurrentStatsResponse, error)
-	// Queries a list of GetAllParticipantCurrentStats items.
-	GetAllParticipantCurrentStats(ctx context.Context, in *QueryGetAllParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetAllParticipantCurrentStatsResponse, error)
-	GetParticipantsFullStats(ctx context.Context, in *QueryParticipantsFullStatsRequest, opts ...grpc.CallOption) (*QueryParticipantsFullStatsResponse, error)
-	StatsByTimePeriodByDeveloper(ctx context.Context, in *QueryStatsByTimePeriodByDeveloperRequest, opts ...grpc.CallOption) (*QueryStatsByTimePeriodByDeveloperResponse, error)
-	StatsByDeveloperAndEpochsBackwards(ctx context.Context, in *QueryStatsByDeveloperAndEpochBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error)
-	CountParticipants(ctx context.Context, in *QueryCountAllParticipantsRequest, opts ...grpc.CallOption) (*QueryCountAllParticipantsResponse, error)
-	DebugStatsDeveloperStats(ctx context.Context, in *QueryDebugStatsRequest, opts ...grpc.CallOption) (*QueryDebugStatsResponse, error)
-	InferencesAndTokensStatsByEpochsBackwards(ctx context.Context, in *QueryInferencesAndTokensStatsByEpochsBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error)
-	InferencesAndTokensStatsByTimePeriod(ctx context.Context, in *QueryInferencesAndTokensStatsByTimePeriodRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error)
-	InferencesAndTokensStatsByModels(ctx context.Context, in *QueryInferencesAndTokensStatsByModelsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsByModelsResponse, error)
-	// Queries a list of GetMinimumValidationAverage items.
-	GetMinimumValidationAverage(ctx context.Context, in *QueryGetMinimumValidationAverageRequest, opts ...grpc.CallOption) (*QueryGetMinimumValidationAverageResponse, error)
-	// Queries a list of PartialUpgrade items.
-	PartialUpgrade(ctx context.Context, in *QueryGetPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryGetPartialUpgradeResponse, error)
-	PartialUpgradeAll(ctx context.Context, in *QueryAllPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryAllPartialUpgradeResponse, error)
-	// Queries a bridge transaction by its composite key
-	BridgeTransaction(ctx context.Context, in *QueryGetBridgeTransactionRequest, opts ...grpc.CallOption) (*QueryGetBridgeTransactionResponse, error)
-	// Queries all bridge transactions
-	BridgeTransactions(ctx context.Context, in *QueryAllBridgeTransactionsRequest, opts ...grpc.CallOption) (*QueryAllBridgeTransactionsResponse, error)
-	// Queries bridge addresses by chain
-	BridgeAddressesByChain(ctx context.Context, in *QueryBridgeAddressesByChainRequest, opts ...grpc.CallOption) (*QueryBridgeAddressesByChainResponse, error)
-	// Queries the singleton liquidity pool
-	LiquidityPool(ctx context.Context, in *QueryLiquidityPoolRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error)
-	// Queries all wrapped token balances for a specific address
-	WrappedTokenBalances(ctx context.Context, in *QueryWrappedTokenBalancesRequest, opts ...grpc.CallOption) (*QueryWrappedTokenBalancesResponse, error)
-	// Validates a wrapped token for trading through liquidity pools
-	ValidateWrappedTokenForTrade(ctx context.Context, in *QueryValidateWrappedTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateWrappedTokenForTradeResponse, error)
-	// Validates an IBC token for trading through liquidity pools
-	ValidateIbcTokenForTrade(ctx context.Context, in *QueryValidateIbcTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateIbcTokenForTradeResponse, error)
-	// Queries all approved bridge tokens for trading
-	ApprovedTokensForTrade(ctx context.Context, in *QueryApprovedTokensForTradeRequest, opts ...grpc.CallOption) (*QueryApprovedTokensForTradeResponse, error)
-	// Queries a list of EpochInfo items.
-	EpochInfo(ctx context.Context, in *QueryEpochInfoRequest, opts ...grpc.CallOption) (*QueryEpochInfoResponse, error)
-	// Queries a list of CountPoCbatchesAtHeight items.
-	CountPoCbatchesAtHeight(ctx context.Context, in *QueryCountPoCbatchesAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCbatchesAtHeightResponse, error)
-	// Queries a list of CountPoCvalidationsAtHeight items.
-	CountPoCvalidationsAtHeight(ctx context.Context, in *QueryCountPoCvalidationsAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCvalidationsAtHeightResponse, error)
-	// Dynamic pricing queries (Task 7.1)
-	GetModelPerTokenPrice(ctx context.Context, in *QueryGetModelPerTokenPriceRequest, opts ...grpc.CallOption) (*QueryGetModelPerTokenPriceResponse, error)
-	GetAllModelPerTokenPrices(ctx context.Context, in *QueryGetAllModelPerTokenPricesRequest, opts ...grpc.CallOption) (*QueryGetAllModelPerTokenPricesResponse, error)
-	GetModelCapacity(ctx context.Context, in *QueryGetModelCapacityRequest, opts ...grpc.CallOption) (*QueryGetModelCapacityResponse, error)
-	GetAllModelCapacities(ctx context.Context, in *QueryGetAllModelCapacitiesRequest, opts ...grpc.CallOption) (*QueryGetAllModelCapacitiesResponse, error)
-	// Queries all authz grantees with specific message type for an account
-	GranteesByMessageType(ctx context.Context, in *QueryGranteesByMessageTypeRequest, opts ...grpc.CallOption) (*QueryGranteesByMessageTypeResponse, error)
-	// Queries the current MLNode version.
-	MLNodeVersion(ctx context.Context, in *QueryGetMLNodeVersionRequest, opts ...grpc.CallOption) (*QueryGetMLNodeVersionResponse, error)
-	// Queries the participant allowlist.
-	ParticipantAllowList(ctx context.Context, in *QueryParticipantAllowListRequest, opts ...grpc.CallOption) (*QueryParticipantAllowListResponse, error)
-	// Queries the list of excluded participants for an epoch (0 = current epoch).
-	ExcludedParticipants(ctx context.Context, in *QueryExcludedParticipantsRequest, opts ...grpc.CallOption) (*QueryExcludedParticipantsResponse, error)
-	// Queries the currently active confirmation PoC event.
-	ActiveConfirmationPoCEvent(ctx context.Context, in *QueryActiveConfirmationPoCEventRequest, opts ...grpc.CallOption) (*QueryActiveConfirmationPoCEventResponse, error)
-	// Queries confirmation PoC events for a specific epoch.
-	ListConfirmationPoCEvents(ctx context.Context, in *QueryConfirmationPoCEventsRequest, opts ...grpc.CallOption) (*QueryConfirmationPoCEventsResponse, error)
-	// Queries random seeds for a specific epoch.
-	ListRandomSeeds(ctx context.Context, in *QueryRandomSeedsRequest, opts ...grpc.CallOption) (*QueryRandomSeedsResponse, error)
-	ParticipantsWithBalances(ctx context.Context, in *QueryParticipantsWithBalancesRequest, opts ...grpc.CallOption) (*QueryParticipantsWithBalancesResponse, error)
-	// Queries PoC validation snapshot for deterministic sampling synchronization.
-	PoCValidationSnapshot(ctx context.Context, in *QueryPoCValidationSnapshotRequest, opts ...grpc.CallOption) (*QueryPoCValidationSnapshotResponse, error)
-	DevshardEscrow(ctx context.Context, in *QueryGetDevshardEscrowRequest, opts ...grpc.CallOption) (*QueryGetDevshardEscrowResponse, error)
-	// Queries preserved nodes snapshot for the active PoC episode.
-	PreservedNodesSnapshot(ctx context.Context, in *QueryPreservedNodesSnapshotRequest, opts ...grpc.CallOption) (*QueryPreservedNodesSnapshotResponse, error)
-	DevshardHostEpochStats(ctx context.Context, in *QueryGetDevshardHostEpochStatsRequest, opts ...grpc.CallOption) (*QueryGetDevshardHostEpochStatsResponse, error)
-	PoCDelegation(ctx context.Context, in *QueryPoCDelegationRequest, opts ...grpc.CallOption) (*QueryPoCDelegationResponse, error)
+func (m *QueryMaintenanceCreditRequest) GetParticipant() string {
+	if m != nil {
+		return m.Participant
+	}
+	return ""
 }
 
-type queryClient struct {
-	cc grpc1.ClientConn
+type QueryMaintenanceCreditResponse struct {
+	CreditBlocks uint64 `protobuf:"varint,1,opt,name=credit_blocks,json=creditBlocks,proto3" json:"credit_blocks,omitempty"`
+	Found        bool   `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func NewQueryClient(cc grpc1.ClientConn) QueryClient {
-	return &queryClient{cc}
+func (m *QueryMaintenanceCreditResponse) Reset()         { *m = QueryMaintenanceCreditResponse{} }
+func (m *QueryMaintenanceCreditResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceCreditResponse) ProtoMessage()    {}
+func (*QueryMaintenanceCreditResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{169}
 }
-
-func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
-	out := new(QueryParamsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/Params", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceCreditResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceCreditResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceCreditResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceCreditResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceCreditResponse.Merge(m, src)
+}
+func (m *QueryMaintenanceCreditResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceCreditResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceCreditResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) Inference(ctx context.Context, in *QueryGetInferenceRequest, opts ...grpc.CallOption) (*QueryGetInferenceResponse, error) {
-	out := new(QueryGetInferenceResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/Inference", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceCreditResponse proto.InternalMessageInfo
+
+func (m *QueryMaintenanceCreditResponse) GetCreditBlocks() uint64 {
+	if m != nil {
+		return m.CreditBlocks
 	}
-	return out, nil
+	return 0
 }
 
-func (c *queryClient) InferenceAll(ctx context.Context, in *QueryAllInferenceRequest, opts ...grpc.CallOption) (*QueryAllInferenceResponse, error) {
-	out := new(QueryAllInferenceResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceCreditResponse) GetFound() bool {
+	if m != nil {
+		return m.Found
 	}
-	return out, nil
+	return false
 }
 
-func (c *queryClient) Participant(ctx context.Context, in *QueryGetParticipantRequest, opts ...grpc.CallOption) (*QueryGetParticipantResponse, error) {
-	out := new(QueryGetParticipantResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/Participant", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceScheduledRequest struct {
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (c *queryClient) ParticipantAll(ctx context.Context, in *QueryAllParticipantRequest, opts ...grpc.CallOption) (*QueryAllParticipantResponse, error) {
-	out := new(QueryAllParticipantResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ParticipantAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceScheduledRequest) Reset()         { *m = QueryMaintenanceScheduledRequest{} }
+func (m *QueryMaintenanceScheduledRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceScheduledRequest) ProtoMessage()    {}
+func (*QueryMaintenanceScheduledRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{170}
+}
+func (m *QueryMaintenanceScheduledRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceScheduledRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceScheduledRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceScheduledRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceScheduledRequest.Merge(m, src)
+}
+func (m *QueryMaintenanceScheduledRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceScheduledRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceScheduledRequest.DiscardUnknown(m)
 }
 
-func (c *queryClient) AccountByAddress(ctx context.Context, in *QueryAccountByAddressRequest, opts ...grpc.CallOption) (*QueryAccountByAddressResponse, error) {
-	out := new(QueryAccountByAddressResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/AccountByAddress", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceScheduledRequest proto.InternalMessageInfo
+
+func (m *QueryMaintenanceScheduledRequest) GetParticipant() string {
+	if m != nil {
+		return m.Participant
 	}
-	return out, nil
+	return ""
 }
 
-func (c *queryClient) GetRandomExecutor(ctx context.Context, in *QueryGetRandomExecutorRequest, opts ...grpc.CallOption) (*QueryGetRandomExecutorResponse, error) {
-	out := new(QueryGetRandomExecutorResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetRandomExecutor", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceScheduledResponse struct {
+	Reservation *MaintenanceReservation `protobuf:"bytes,1,opt,name=reservation,proto3" json:"reservation,omitempty"`
+	Found       bool                    `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (c *queryClient) EpochGroupData(ctx context.Context, in *QueryGetEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupDataResponse, error) {
-	out := new(QueryGetEpochGroupDataResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupData", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceScheduledResponse) Reset()         { *m = QueryMaintenanceScheduledResponse{} }
+func (m *QueryMaintenanceScheduledResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceScheduledResponse) ProtoMessage()    {}
+func (*QueryMaintenanceScheduledResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{171}
+}
+func (m *QueryMaintenanceScheduledResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceScheduledResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceScheduledResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceScheduledResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceScheduledResponse.Merge(m, src)
+}
+func (m *QueryMaintenanceScheduledResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceScheduledResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceScheduledResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) EpochGroupDataAll(ctx context.Context, in *QueryAllEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupDataResponse, error) {
-	out := new(QueryAllEpochGroupDataResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupDataAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceScheduledResponse proto.InternalMessageInfo
+
+func (m *QueryMaintenanceScheduledResponse) GetReservation() *MaintenanceReservation {
+	if m != nil {
+		return m.Reservation
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryClient) SettleAmount(ctx context.Context, in *QueryGetSettleAmountRequest, opts ...grpc.CallOption) (*QueryGetSettleAmountResponse, error) {
-	out := new(QueryGetSettleAmountResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/SettleAmount", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceScheduledResponse) GetFound() bool {
+	if m != nil {
+		return m.Found
 	}
-	return out, nil
+	return false
 }
 
-func (c *queryClient) SettleAmountAll(ctx context.Context, in *QueryAllSettleAmountRequest, opts ...grpc.CallOption) (*QueryAllSettleAmountResponse, error) {
-	out := new(QueryAllSettleAmountResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/SettleAmountAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceActiveRequest struct {
 }
 
-func (c *queryClient) EpochGroupValidations(ctx context.Context, in *QueryGetEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupValidationsResponse, error) {
-	out := new(QueryGetEpochGroupValidationsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupValidations", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceActiveRequest) Reset()         { *m = QueryMaintenanceActiveRequest{} }
+func (m *QueryMaintenanceActiveRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceActiveRequest) ProtoMessage()    {}
+func (*QueryMaintenanceActiveRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{172}
+}
+func (m *QueryMaintenanceActiveRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceActiveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceActiveRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceActiveRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceActiveRequest.Merge(m, src)
+}
+func (m *QueryMaintenanceActiveRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceActiveRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceActiveRequest.DiscardUnknown(m)
 }
 
-func (c *queryClient) EpochGroupValidationsAll(ctx context.Context, in *QueryAllEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupValidationsResponse, error) {
-	out := new(QueryAllEpochGroupValidationsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupValidationsAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+var xxx_messageInfo_QueryMaintenanceActiveRequest proto.InternalMessageInfo
+
+type QueryMaintenanceActiveResponse struct {
+	Reservations []*MaintenanceReservation `protobuf:"bytes,1,rep,name=reservations,proto3" json:"reservations,omitempty"`
 }
 
-func (c *queryClient) PocBatchesForStage(ctx context.Context, in *QueryPocBatchesForStageRequest, opts ...grpc.CallOption) (*QueryPocBatchesForStageResponse, error) {
-	out := new(QueryPocBatchesForStageResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PocBatchesForStage", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceActiveResponse) Reset()         { *m = QueryMaintenanceActiveResponse{} }
+func (m *QueryMaintenanceActiveResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceActiveResponse) ProtoMessage()    {}
+func (*QueryMaintenanceActiveResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{173}
+}
+func (m *QueryMaintenanceActiveResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceActiveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceActiveResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceActiveResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceActiveResponse.Merge(m, src)
+}
+func (m *QueryMaintenanceActiveResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceActiveResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceActiveResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) PocValidationsForStage(ctx context.Context, in *QueryPocValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocValidationsForStageResponse, error) {
-	out := new(QueryPocValidationsForStageResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PocValidationsForStage", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceActiveResponse proto.InternalMessageInfo
+
+func (m *QueryMaintenanceActiveResponse) GetReservations() []*MaintenanceReservation {
+	if m != nil {
+		return m.Reservations
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryClient) PocV2ValidationsForStage(ctx context.Context, in *QueryPocV2ValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocV2ValidationsForStageResponse, error) {
-	out := new(QueryPocV2ValidationsForStageResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PocV2ValidationsForStage", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceStatusRequest struct {
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (c *queryClient) PoCV2StoreCommit(ctx context.Context, in *QueryPoCV2StoreCommitRequest, opts ...grpc.CallOption) (*QueryPoCV2StoreCommitResponse, error) {
-	out := new(QueryPoCV2StoreCommitResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PoCV2StoreCommit", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceStatusRequest) Reset()         { *m = QueryMaintenanceStatusRequest{} }
+func (m *QueryMaintenanceStatusRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceStatusRequest) ProtoMessage()    {}
+func (*QueryMaintenanceStatusRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{174}
+}
+func (m *QueryMaintenanceStatusRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceStatusRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceStatusRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceStatusRequest.Merge(m, src)
+}
+func (m *QueryMaintenanceStatusRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceStatusRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceStatusRequest.DiscardUnknown(m)
 }
 
-func (c *queryClient) MLNodeWeightDistribution(ctx context.Context, in *QueryMLNodeWeightDistributionRequest, opts ...grpc.CallOption) (*QueryMLNodeWeightDistributionResponse, error) {
-	out := new(QueryMLNodeWeightDistributionResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/MLNodeWeightDistribution", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceStatusRequest proto.InternalMessageInfo
+
+func (m *QueryMaintenanceStatusRequest) GetParticipant() string {
+	if m != nil {
+		return m.Participant
 	}
-	return out, nil
+	return ""
 }
 
-func (c *queryClient) AllPoCV2StoreCommitsForStage(ctx context.Context, in *QueryAllPoCV2StoreCommitsForStageRequest, opts ...grpc.CallOption) (*QueryAllPoCV2StoreCommitsForStageResponse, error) {
-	out := new(QueryAllPoCV2StoreCommitsForStageResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/AllPoCV2StoreCommitsForStage", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceStatusResponse struct {
+	State                *MaintenanceState       `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
+	ActiveReservation    *MaintenanceReservation `protobuf:"bytes,2,opt,name=active_reservation,json=activeReservation,proto3" json:"active_reservation,omitempty"`
+	ScheduledReservation *MaintenanceReservation `protobuf:"bytes,3,opt,name=scheduled_reservation,json=scheduledReservation,proto3" json:"scheduled_reservation,omitempty"`
+	Found                bool                    `protobuf:"varint,4,opt,name=found,proto3" json:"found,omitempty"`
 }
 
-func (c *queryClient) AllMLNodeWeightDistributionsForStage(ctx context.Context, in *QueryAllMLNodeWeightDistributionsForStageRequest, opts ...grpc.CallOption) (*QueryAllMLNodeWeightDistributionsForStageResponse, error) {
-	out := new(QueryAllMLNodeWeightDistributionsForStageResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/AllMLNodeWeightDistributionsForStage", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceStatusResponse) Reset()         { *m = QueryMaintenanceStatusResponse{} }
+func (m *QueryMaintenanceStatusResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceStatusResponse) ProtoMessage()    {}
+func (*QueryMaintenanceStatusResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{175}
+}
+func (m *QueryMaintenanceStatusResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceStatusResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceStatusResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceStatusResponse.Merge(m, src)
+}
+func (m *QueryMaintenanceStatusResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceStatusResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceStatusResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) GetCurrentEpoch(ctx context.Context, in *QueryGetCurrentEpochRequest, opts ...grpc.CallOption) (*QueryGetCurrentEpochResponse, error) {
-	out := new(QueryGetCurrentEpochResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetCurrentEpoch", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceStatusResponse proto.InternalMessageInfo
+
+func (m *QueryMaintenanceStatusResponse) GetState() *MaintenanceState {
+	if m != nil {
+		return m.State
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryClient) TokenomicsData(ctx context.Context, in *QueryGetTokenomicsDataRequest, opts ...grpc.CallOption) (*QueryGetTokenomicsDataResponse, error) {
-	out := new(QueryGetTokenomicsDataResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/TokenomicsData", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceStatusResponse) GetActiveReservation() *MaintenanceReservation {
+	if m != nil {
+		return m.ActiveReservation
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryClient) GetUnitOfComputePriceProposal(ctx context.Context, in *QueryGetUnitOfComputePriceProposalRequest, opts ...grpc.CallOption) (*QueryGetUnitOfComputePriceProposalResponse, error) {
-	out := new(QueryGetUnitOfComputePriceProposalResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetUnitOfComputePriceProposal", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceStatusResponse) GetScheduledReservation() *MaintenanceReservation {
+	if m != nil {
+		return m.ScheduledReservation
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryClient) CurrentEpochGroupData(ctx context.Context, in *QueryCurrentEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryCurrentEpochGroupDataResponse, error) {
-	out := new(QueryCurrentEpochGroupDataResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/CurrentEpochGroupData", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceStatusResponse) GetFound() bool {
+	if m != nil {
+		return m.Found
 	}
-	return out, nil
+	return false
 }
 
-func (c *queryClient) ModelsAll(ctx context.Context, in *QueryModelsAllRequest, opts ...grpc.CallOption) (*QueryModelsAllResponse, error) {
-	out := new(QueryModelsAllResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ModelsAll", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceConcurrencyRequest struct {
+	Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
 }
 
-func (c *queryClient) InferenceTimeout(ctx context.Context, in *QueryGetInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryGetInferenceTimeoutResponse, error) {
-	out := new(QueryGetInferenceTimeoutResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceTimeout", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceConcurrencyRequest) Reset()         { *m = QueryMaintenanceConcurrencyRequest{} }
+func (m *QueryMaintenanceConcurrencyRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceConcurrencyRequest) ProtoMessage()    {}
+func (*QueryMaintenanceConcurrencyRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{176}
+}
+func (m *QueryMaintenanceConcurrencyRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceConcurrencyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceConcurrencyRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceConcurrencyRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceConcurrencyRequest.Merge(m, src)
+}
+func (m *QueryMaintenanceConcurrencyRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceConcurrencyRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceConcurrencyRequest.DiscardUnknown(m)
 }
 
-func (c *queryClient) InferenceTimeoutAll(ctx context.Context, in *QueryAllInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryAllInferenceTimeoutResponse, error) {
-	out := new(QueryAllInferenceTimeoutResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceTimeoutAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceConcurrencyRequest proto.InternalMessageInfo
+
+func (m *QueryMaintenanceConcurrencyRequest) GetHeight() int64 {
+	if m != nil {
+		return m.Height
 	}
-	return out, nil
+	return 0
 }
 
-func (c *queryClient) InferenceValidationDetails(ctx context.Context, in *QueryGetInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationDetailsResponse, error) {
-	out := new(QueryGetInferenceValidationDetailsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceValidationDetails", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceConcurrencyResponse struct {
+	ConcurrentCount    uint32 `protobuf:"varint,1,opt,name=concurrent_count,json=concurrentCount,proto3" json:"concurrent_count,omitempty"`
+	ConcurrentPowerBps int64  `protobuf:"varint,2,opt,name=concurrent_power_bps,json=concurrentPowerBps,proto3" json:"concurrent_power_bps,omitempty"`
 }
 
-func (c *queryClient) InferenceValidationDetailsAll(ctx context.Context, in *QueryAllInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryAllInferenceValidationDetailsResponse, error) {
-	out := new(QueryAllInferenceValidationDetailsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceValidationDetailsAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceConcurrencyResponse) Reset()         { *m = QueryMaintenanceConcurrencyResponse{} }
+func (m *QueryMaintenanceConcurrencyResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceConcurrencyResponse) ProtoMessage()    {}
+func (*QueryMaintenanceConcurrencyResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{177}
+}
+func (m *QueryMaintenanceConcurrencyResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceConcurrencyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceConcurrencyResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceConcurrencyResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceConcurrencyResponse.Merge(m, src)
+}
+func (m *QueryMaintenanceConcurrencyResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceConcurrencyResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceConcurrencyResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) GetInferenceValidationParameters(ctx context.Context, in *QueryGetInferenceValidationParametersRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationParametersResponse, error) {
-	out := new(QueryGetInferenceValidationParametersResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetInferenceValidationParameters", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceConcurrencyResponse proto.InternalMessageInfo
+
+func (m *QueryMaintenanceConcurrencyResponse) GetConcurrentCount() uint32 {
+	if m != nil {
+		return m.ConcurrentCount
 	}
-	return out, nil
+	return 0
 }
 
-func (c *queryClient) EpochPerformanceSummary(ctx context.Context, in *QueryEpochPerformanceSummaryByEpochRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByEpochResponse, error) {
-	out := new(QueryEpochPerformanceSummaryByEpochResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochPerformanceSummary", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceConcurrencyResponse) GetConcurrentPowerBps() int64 {
+	if m != nil {
+		return m.ConcurrentPowerBps
 	}
-	return out, nil
+	return 0
 }
 
-func (c *queryClient) EpochPerformanceSummaryByParticipant(ctx context.Context, in *QueryEpochPerformanceSummaryByParticipantRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByParticipantResponse, error) {
-	out := new(QueryEpochPerformanceSummaryByParticipantResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochPerformanceSummaryByParticipant", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceSchedulabilityRequest struct {
+	Participant    string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
+	StartHeight    int64  `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
+	DurationBlocks uint64 `protobuf:"varint,3,opt,name=duration_blocks,json=durationBlocks,proto3" json:"duration_blocks,omitempty"`
 }
 
-func (c *queryClient) EpochPerformanceSummaryAll(ctx context.Context, in *QueryAllEpochPerformanceSummaryRequest, opts ...grpc.CallOption) (*QueryAllEpochPerformanceSummaryResponse, error) {
-	out := new(QueryAllEpochPerformanceSummaryResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochPerformanceSummaryAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceSchedulabilityRequest) Reset()         { *m = QueryMaintenanceSchedulabilityRequest{} }
+func (m *QueryMaintenanceSchedulabilityRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceSchedulabilityRequest) ProtoMessage()    {}
+func (*QueryMaintenanceSchedulabilityRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{178}
+}
+func (m *QueryMaintenanceSchedulabilityRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceSchedulabilityRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceSchedulabilityRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceSchedulabilityRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceSchedulabilityRequest.Merge(m, src)
+}
+func (m *QueryMaintenanceSchedulabilityRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceSchedulabilityRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceSchedulabilityRequest.DiscardUnknown(m)
 }
 
-func (c *queryClient) HardwareNodes(ctx context.Context, in *QueryHardwareNodesRequest, opts ...grpc.CallOption) (*QueryHardwareNodesResponse, error) {
-	out := new(QueryHardwareNodesResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/HardwareNodes", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceSchedulabilityRequest proto.InternalMessageInfo
+
+func (m *QueryMaintenanceSchedulabilityRequest) GetParticipant() string {
+	if m != nil {
+		return m.Participant
 	}
-	return out, nil
+	return ""
 }
 
-func (c *queryClient) HardwareNodesAll(ctx context.Context, in *QueryHardwareNodesAllRequest, opts ...grpc.CallOption) (*QueryHardwareNodesAllResponse, error) {
-	out := new(QueryHardwareNodesAllResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/HardwareNodesAll", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceSchedulabilityRequest) GetStartHeight() int64 {
+	if m != nil {
+		return m.StartHeight
 	}
-	return out, nil
+	return 0
 }
 
-func (c *queryClient) GetParticipantCurrentStats(ctx context.Context, in *QueryGetParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetParticipantCurrentStatsResponse, error) {
-	out := new(QueryGetParticipantCurrentStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetParticipantCurrentStats", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceSchedulabilityRequest) GetDurationBlocks() uint64 {
+	if m != nil {
+		return m.DurationBlocks
 	}
-	return out, nil
+	return 0
 }
 
-func (c *queryClient) GetAllParticipantCurrentStats(ctx context.Context, in *QueryGetAllParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetAllParticipantCurrentStatsResponse, error) {
-	out := new(QueryGetAllParticipantCurrentStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetAllParticipantCurrentStats", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryMaintenanceSchedulabilityResponse struct {
+	Schedulable     bool   `protobuf:"varint,1,opt,name=schedulable,proto3" json:"schedulable,omitempty"`
+	RejectionReason string `protobuf:"bytes,2,opt,name=rejection_reason,json=rejectionReason,proto3" json:"rejection_reason,omitempty"`
 }
 
-func (c *queryClient) GetParticipantsFullStats(ctx context.Context, in *QueryParticipantsFullStatsRequest, opts ...grpc.CallOption) (*QueryParticipantsFullStatsResponse, error) {
-	out := new(QueryParticipantsFullStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetParticipantsFullStats", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceSchedulabilityResponse) Reset() {
+	*m = QueryMaintenanceSchedulabilityResponse{}
+}
+func (m *QueryMaintenanceSchedulabilityResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryMaintenanceSchedulabilityResponse) ProtoMessage()    {}
+func (*QueryMaintenanceSchedulabilityResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{179}
+}
+func (m *QueryMaintenanceSchedulabilityResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryMaintenanceSchedulabilityResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryMaintenanceSchedulabilityResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryMaintenanceSchedulabilityResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryMaintenanceSchedulabilityResponse.Merge(m, src)
+}
+func (m *QueryMaintenanceSchedulabilityResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryMaintenanceSchedulabilityResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryMaintenanceSchedulabilityResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) StatsByTimePeriodByDeveloper(ctx context.Context, in *QueryStatsByTimePeriodByDeveloperRequest, opts ...grpc.CallOption) (*QueryStatsByTimePeriodByDeveloperResponse, error) {
-	out := new(QueryStatsByTimePeriodByDeveloperResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/StatsByTimePeriodByDeveloper", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryMaintenanceSchedulabilityResponse proto.InternalMessageInfo
+
+func (m *QueryMaintenanceSchedulabilityResponse) GetSchedulable() bool {
+	if m != nil {
+		return m.Schedulable
 	}
-	return out, nil
+	return false
 }
 
-func (c *queryClient) StatsByDeveloperAndEpochsBackwards(ctx context.Context, in *QueryStatsByDeveloperAndEpochBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error) {
-	out := new(QueryInferencesAndTokensStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/StatsByDeveloperAndEpochsBackwards", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryMaintenanceSchedulabilityResponse) GetRejectionReason() string {
+	if m != nil {
+		return m.RejectionReason
 	}
-	return out, nil
+	return ""
 }
 
-func (c *queryClient) CountParticipants(ctx context.Context, in *QueryCountAllParticipantsRequest, opts ...grpc.CallOption) (*QueryCountAllParticipantsResponse, error) {
-	out := new(QueryCountAllParticipantsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/CountParticipants", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryListClaimRecipientsRequest struct {
+	Participant string `protobuf:"bytes,1,opt,name=participant,proto3" json:"participant,omitempty"`
 }
 
-func (c *queryClient) DebugStatsDeveloperStats(ctx context.Context, in *QueryDebugStatsRequest, opts ...grpc.CallOption) (*QueryDebugStatsResponse, error) {
-	out := new(QueryDebugStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/DebugStatsDeveloperStats", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryListClaimRecipientsRequest) Reset()         { *m = QueryListClaimRecipientsRequest{} }
+func (m *QueryListClaimRecipientsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryListClaimRecipientsRequest) ProtoMessage()    {}
+func (*QueryListClaimRecipientsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{180}
+}
+func (m *QueryListClaimRecipientsRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryListClaimRecipientsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryListClaimRecipientsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryListClaimRecipientsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryListClaimRecipientsRequest.Merge(m, src)
+}
+func (m *QueryListClaimRecipientsRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryListClaimRecipientsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryListClaimRecipientsRequest.DiscardUnknown(m)
 }
 
-func (c *queryClient) InferencesAndTokensStatsByEpochsBackwards(ctx context.Context, in *QueryInferencesAndTokensStatsByEpochsBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error) {
-	out := new(QueryInferencesAndTokensStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferencesAndTokensStatsByEpochsBackwards", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryListClaimRecipientsRequest proto.InternalMessageInfo
+
+func (m *QueryListClaimRecipientsRequest) GetParticipant() string {
+	if m != nil {
+		return m.Participant
 	}
-	return out, nil
+	return ""
 }
 
-func (c *queryClient) InferencesAndTokensStatsByTimePeriod(ctx context.Context, in *QueryInferencesAndTokensStatsByTimePeriodRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error) {
-	out := new(QueryInferencesAndTokensStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferencesAndTokensStatsByTimePeriod", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
+type QueryListClaimRecipientsResponse struct {
+	Entries []ClaimRecipientEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries"`
 }
 
-func (c *queryClient) InferencesAndTokensStatsByModels(ctx context.Context, in *QueryInferencesAndTokensStatsByModelsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsByModelsResponse, error) {
-	out := new(QueryInferencesAndTokensStatsByModelsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferencesAndTokensStatsByModels", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *QueryListClaimRecipientsResponse) Reset()         { *m = QueryListClaimRecipientsResponse{} }
+func (m *QueryListClaimRecipientsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryListClaimRecipientsResponse) ProtoMessage()    {}
+func (*QueryListClaimRecipientsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cf0cfe3b0e1cc5bd, []int{181}
+}
+func (m *QueryListClaimRecipientsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryListClaimRecipientsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryListClaimRecipientsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *QueryListClaimRecipientsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryListClaimRecipientsResponse.Merge(m, src)
+}
+func (m *QueryListClaimRecipientsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryListClaimRecipientsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryListClaimRecipientsResponse.DiscardUnknown(m)
 }
 
-func (c *queryClient) GetMinimumValidationAverage(ctx context.Context, in *QueryGetMinimumValidationAverageRequest, opts ...grpc.CallOption) (*QueryGetMinimumValidationAverageResponse, error) {
-	out := new(QueryGetMinimumValidationAverageResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetMinimumValidationAverage", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_QueryListClaimRecipientsResponse proto.InternalMessageInfo
+
+func (m *QueryListClaimRecipientsResponse) GetEntries() []ClaimRecipientEntry {
+	if m != nil {
+		return m.Entries
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryClient) PartialUpgrade(ctx context.Context, in *QueryGetPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryGetPartialUpgradeResponse, error) {
-	out := new(QueryGetPartialUpgradeResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PartialUpgrade", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
+func init() {
+	proto.RegisterType((*QueryParamsRequest)(nil), "inference.inference.QueryParamsRequest")
+	proto.RegisterType((*QueryParamsResponse)(nil), "inference.inference.QueryParamsResponse")
+	proto.RegisterType((*QueryGetInferenceRequest)(nil), "inference.inference.QueryGetInferenceRequest")
+	proto.RegisterType((*QueryGetInferenceResponse)(nil), "inference.inference.QueryGetInferenceResponse")
+	proto.RegisterType((*QueryAllInferenceRequest)(nil), "inference.inference.QueryAllInferenceRequest")
+	proto.RegisterType((*QueryAllInferenceResponse)(nil), "inference.inference.QueryAllInferenceResponse")
+	proto.RegisterType((*QueryGetParticipantRequest)(nil), "inference.inference.QueryGetParticipantRequest")
+	proto.RegisterType((*QueryGetParticipantResponse)(nil), "inference.inference.QueryGetParticipantResponse")
+	proto.RegisterType((*QueryAllParticipantRequest)(nil), "inference.inference.QueryAllParticipantRequest")
+	proto.RegisterType((*QueryAllParticipantResponse)(nil), "inference.inference.QueryAllParticipantResponse")
+	proto.RegisterType((*QueryAccountByAddressRequest)(nil), "inference.inference.QueryAccountByAddressRequest")
+	proto.RegisterType((*QueryAccountByAddressResponse)(nil), "inference.inference.QueryAccountByAddressResponse")
+	proto.RegisterType((*QueryGetRandomExecutorRequest)(nil), "inference.inference.QueryGetRandomExecutorRequest")
+	proto.RegisterType((*QueryGetRandomExecutorResponse)(nil), "inference.inference.QueryGetRandomExecutorResponse")
+	proto.RegisterType((*QueryGetEpochGroupDataRequest)(nil), "inference.inference.QueryGetEpochGroupDataRequest")
+	proto.RegisterType((*QueryGetEpochGroupDataResponse)(nil), "inference.inference.QueryGetEpochGroupDataResponse")
+	proto.RegisterType((*QueryAllEpochGroupDataRequest)(nil), "inference.inference.QueryAllEpochGroupDataRequest")
+	proto.RegisterType((*QueryAllEpochGroupDataResponse)(nil), "inference.inference.QueryAllEpochGroupDataResponse")
+	proto.RegisterType((*QueryGetSettleAmountRequest)(nil), "inference.inference.QueryGetSettleAmountRequest")
+	proto.RegisterType((*QueryGetSettleAmountResponse)(nil), "inference.inference.QueryGetSettleAmountResponse")
+	proto.RegisterType((*QueryAllSettleAmountRequest)(nil), "inference.inference.QueryAllSettleAmountRequest")
+	proto.RegisterType((*QueryAllSettleAmountResponse)(nil), "inference.inference.QueryAllSettleAmountResponse")
+	proto.RegisterType((*QueryEstimateBitcoinRewardRequest)(nil), "inference.inference.QueryEstimateBitcoinRewardRequest")
+	proto.RegisterType((*QueryEstimateBitcoinRewardResponse)(nil), "inference.inference.QueryEstimateBitcoinRewardResponse")
+	proto.RegisterType((*QueryGetEpochGroupValidationsRequest)(nil), "inference.inference.QueryGetEpochGroupValidationsRequest")
+	proto.RegisterType((*QueryGetEpochGroupValidationsResponse)(nil), "inference.inference.QueryGetEpochGroupValidationsResponse")
+	proto.RegisterType((*QueryAllEpochGroupValidationsRequest)(nil), "inference.inference.QueryAllEpochGroupValidationsRequest")
+	proto.RegisterType((*QueryAllEpochGroupValidationsResponse)(nil), "inference.inference.QueryAllEpochGroupValidationsResponse")
+	proto.RegisterType((*QueryPocBatchesForStageRequest)(nil), "inference.inference.QueryPocBatchesForStageRequest")
+	proto.RegisterType((*QueryPocBatchesForStageResponse)(nil), "inference.inference.QueryPocBatchesForStageResponse")
+	proto.RegisterType((*PoCBatchesWithParticipants)(nil), "inference.inference.PoCBatchesWithParticipants")
+	proto.RegisterType((*QueryPocValidationsForStageRequest)(nil), "inference.inference.QueryPocValidationsForStageRequest")
+	proto.RegisterType((*QueryPocValidationsForStageResponse)(nil), "inference.inference.QueryPocValidationsForStageResponse")
+	proto.RegisterType((*PoCValidationsWithParticipants)(nil), "inference.inference.PoCValidationsWithParticipants")
+	proto.RegisterType((*QueryPocV2ValidationsForStageRequest)(nil), "inference.inference.QueryPocV2ValidationsForStageRequest")
+	proto.RegisterType((*QueryPocV2ValidationsForStageResponse)(nil), "inference.inference.QueryPocV2ValidationsForStageResponse")
+	proto.RegisterType((*PoCValidationsWithParticipantsV2)(nil), "inference.inference.PoCValidationsWithParticipantsV2")
+	proto.RegisterType((*QueryPoCV2StoreCommitRequest)(nil), "inference.inference.QueryPoCV2StoreCommitRequest")
+	proto.RegisterType((*QueryPoCV2StoreCommitResponse)(nil), "inference.inference.QueryPoCV2StoreCommitResponse")
+	proto.RegisterType((*QueryMLNodeWeightDistributionRequest)(nil), "inference.inference.QueryMLNodeWeightDistributionRequest")
+	proto.RegisterType((*QueryMLNodeWeightDistributionResponse)(nil), "inference.inference.QueryMLNodeWeightDistributionResponse")
+	proto.RegisterType((*QueryAllPoCV2StoreCommitsForStageRequest)(nil), "inference.inference.QueryAllPoCV2StoreCommitsForStageRequest")
+	proto.RegisterType((*QueryAllPoCV2StoreCommitsForStageResponse)(nil), "inference.inference.QueryAllPoCV2StoreCommitsForStageResponse")
+	proto.RegisterType((*PoCV2StoreCommitWithAddress)(nil), "inference.inference.PoCV2StoreCommitWithAddress")
+	proto.RegisterType((*QueryAllMLNodeWeightDistributionsForStageRequest)(nil), "inference.inference.QueryAllMLNodeWeightDistributionsForStageRequest")
+	proto.RegisterType((*QueryAllMLNodeWeightDistributionsForStageResponse)(nil), "inference.inference.QueryAllMLNodeWeightDistributionsForStageResponse")
+	proto.RegisterType((*MLNodeWeightDistributionWithAddress)(nil), "inference.inference.MLNodeWeightDistributionWithAddress")
+	proto.RegisterType((*QueryGetCurrentEpochRequest)(nil), "inference.inference.QueryGetCurrentEpochRequest")
+	proto.RegisterType((*QueryGetCurrentEpochResponse)(nil), "inference.inference.QueryGetCurrentEpochResponse")
+	proto.RegisterType((*QueryGetTokenomicsDataRequest)(nil), "inference.inference.QueryGetTokenomicsDataRequest")
+	proto.RegisterType((*QueryGetTokenomicsDataResponse)(nil), "inference.inference.QueryGetTokenomicsDataResponse")
+	proto.RegisterType((*QueryGetUnitOfComputePriceProposalRequest)(nil), "inference.inference.QueryGetUnitOfComputePriceProposalRequest")
+	proto.RegisterType((*QueryGetUnitOfComputePriceProposalResponse)(nil), "inference.inference.QueryGetUnitOfComputePriceProposalResponse")
+	proto.RegisterType((*QueryCurrentEpochGroupDataRequest)(nil), "inference.inference.QueryCurrentEpochGroupDataRequest")
+	proto.RegisterType((*QueryCurrentEpochGroupDataResponse)(nil), "inference.inference.QueryCurrentEpochGroupDataResponse")
+	proto.RegisterType((*QueryPreviousEpochGroupDataRequest)(nil), "inference.inference.QueryPreviousEpochGroupDataRequest")
+	proto.RegisterType((*QueryPreviousEpochGroupDataResponse)(nil), "inference.inference.QueryPreviousEpochGroupDataResponse")
+	proto.RegisterType((*QueryModelsAllRequest)(nil), "inference.inference.QueryModelsAllRequest")
+	proto.RegisterType((*QueryModelsAllResponse)(nil), "inference.inference.QueryModelsAllResponse")
+	proto.RegisterType((*QueryGetInferenceTimeoutRequest)(nil), "inference.inference.QueryGetInferenceTimeoutRequest")
+	proto.RegisterType((*QueryGetInferenceTimeoutResponse)(nil), "inference.inference.QueryGetInferenceTimeoutResponse")
+	proto.RegisterType((*QueryAllInferenceTimeoutRequest)(nil), "inference.inference.QueryAllInferenceTimeoutRequest")
+	proto.RegisterType((*QueryAllInferenceTimeoutResponse)(nil), "inference.inference.QueryAllInferenceTimeoutResponse")
+	proto.RegisterType((*QueryGetInferenceValidationDetailsRequest)(nil), "inference.inference.QueryGetInferenceValidationDetailsRequest")
+	proto.RegisterType((*QueryGetInferenceValidationDetailsResponse)(nil), "inference.inference.QueryGetInferenceValidationDetailsResponse")
+	proto.RegisterType((*QueryAllInferenceValidationDetailsRequest)(nil), "inference.inference.QueryAllInferenceValidationDetailsRequest")
+	proto.RegisterType((*QueryAllInferenceValidationDetailsResponse)(nil), "inference.inference.QueryAllInferenceValidationDetailsResponse")
+	proto.RegisterType((*QueryGetInferenceValidationParametersRequest)(nil), "inference.inference.QueryGetInferenceValidationParametersRequest")
+	proto.RegisterType((*QueryGetInferenceValidationParametersResponse)(nil), "inference.inference.QueryGetInferenceValidationParametersResponse")
+	proto.RegisterType((*ValidatorPower)(nil), "inference.inference.ValidatorPower")
+	proto.RegisterType((*QueryEpochPerformanceSummaryByEpochRequest)(nil), "inference.inference.QueryEpochPerformanceSummaryByEpochRequest")
+	proto.RegisterType((*QueryEpochPerformanceSummaryByEpochResponse)(nil), "inference.inference.QueryEpochPerformanceSummaryByEpochResponse")
+	proto.RegisterType((*QueryEpochPerformanceSummaryByParticipantRequest)(nil), "inference.inference.QueryEpochPerformanceSummaryByParticipantRequest")
+	proto.RegisterType((*QueryEpochPerformanceSummaryByParticipantResponse)(nil), "inference.inference.QueryEpochPerformanceSummaryByParticipantResponse")
+	proto.RegisterType((*QueryAllEpochPerformanceSummaryRequest)(nil), "inference.inference.QueryAllEpochPerformanceSummaryRequest")
+	proto.RegisterType((*QueryAllEpochPerformanceSummaryResponse)(nil), "inference.inference.QueryAllEpochPerformanceSummaryResponse")
+	proto.RegisterType((*QueryHardwareNodesRequest)(nil), "inference.inference.QueryHardwareNodesRequest")
+	proto.RegisterType((*QueryHardwareNodesResponse)(nil), "inference.inference.QueryHardwareNodesResponse")
+	proto.RegisterType((*QueryHardwareNodesAllRequest)(nil), "inference.inference.QueryHardwareNodesAllRequest")
+	proto.RegisterType((*QueryHardwareNodesAllResponse)(nil), "inference.inference.QueryHardwareNodesAllResponse")
+	proto.RegisterType((*QueryGetParticipantCurrentStatsRequest)(nil), "inference.inference.QueryGetParticipantCurrentStatsRequest")
+	proto.RegisterType((*QueryGetParticipantCurrentStatsResponse)(nil), "inference.inference.QueryGetParticipantCurrentStatsResponse")
+	proto.RegisterType((*QueryGetAllParticipantCurrentStatsRequest)(nil), "inference.inference.QueryGetAllParticipantCurrentStatsRequest")
+	proto.RegisterType((*QueryGetAllParticipantCurrentStatsResponse)(nil), "inference.inference.QueryGetAllParticipantCurrentStatsResponse")
+	proto.RegisterType((*ParticipantCurrentStats)(nil), "inference.inference.ParticipantCurrentStats")
+	proto.RegisterType((*ParticipantFullStats)(nil), "inference.inference.ParticipantFullStats")
+	proto.RegisterType((*QueryParticipantsFullStatsRequest)(nil), "inference.inference.QueryParticipantsFullStatsRequest")
+	proto.RegisterType((*QueryParticipantsFullStatsResponse)(nil), "inference.inference.QueryParticipantsFullStatsResponse")
+	proto.RegisterType((*QueryStatsByTimePeriodByDeveloperRequest)(nil), "inference.inference.QueryStatsByTimePeriodByDeveloperRequest")
+	proto.RegisterType((*QueryStatsByTimePeriodByDeveloperResponse)(nil), "inference.inference.QueryStatsByTimePeriodByDeveloperResponse")
+	proto.RegisterType((*QueryStatsByDeveloperAndEpochBackwardsRequest)(nil), "inference.inference.QueryStatsByDeveloperAndEpochBackwardsRequest")
+	proto.RegisterType((*QueryInferencesAndTokensStatsByEpochsBackwardsRequest)(nil), "inference.inference.QueryInferencesAndTokensStatsByEpochsBackwardsRequest")
+	proto.RegisterType((*QueryInferencesAndTokensStatsByTimePeriodRequest)(nil), "inference.inference.QueryInferencesAndTokensStatsByTimePeriodRequest")
+	proto.RegisterType((*QueryInferencesAndTokensStatsByModelsRequest)(nil), "inference.inference.QueryInferencesAndTokensStatsByModelsRequest")
+	proto.RegisterType((*ModelStats)(nil), "inference.inference.ModelStats")
+	proto.RegisterType((*QueryInferencesAndTokensStatsByModelsResponse)(nil), "inference.inference.QueryInferencesAndTokensStatsByModelsResponse")
+	proto.RegisterType((*QueryInferencesAndTokensStatsResponse)(nil), "inference.inference.QueryInferencesAndTokensStatsResponse")
+	proto.RegisterType((*QueryCountAllParticipantsRequest)(nil), "inference.inference.QueryCountAllParticipantsRequest")
+	proto.RegisterType((*QueryCountAllParticipantsResponse)(nil), "inference.inference.QueryCountAllParticipantsResponse")
+	proto.RegisterType((*QueryDebugStatsRequest)(nil), "inference.inference.QueryDebugStatsRequest")
+	proto.RegisterType((*QueryDebugStatsResponse)(nil), "inference.inference.QueryDebugStatsResponse")
+	proto.RegisterType((*QueryDebugStatsResponse_TemporaryTimeStat)(nil), "inference.inference.QueryDebugStatsResponse.TemporaryTimeStat")
+	proto.RegisterType((*QueryDebugStatsResponse_TemporaryEpochStat)(nil), "inference.inference.QueryDebugStatsResponse.TemporaryEpochStat")
+	proto.RegisterType((*QueryGetMinimumValidationAverageRequest)(nil), "inference.inference.QueryGetMinimumValidationAverageRequest")
+	proto.RegisterType((*QueryGetMinimumValidationAverageResponse)(nil), "inference.inference.QueryGetMinimumValidationAverageResponse")
+	proto.RegisterType((*QueryGetPartialUpgradeRequest)(nil), "inference.inference.QueryGetPartialUpgradeRequest")
+	proto.RegisterType((*QueryGetPartialUpgradeResponse)(nil), "inference.inference.QueryGetPartialUpgradeResponse")
+	proto.RegisterType((*QueryAllPartialUpgradeRequest)(nil), "inference.inference.QueryAllPartialUpgradeRequest")
+	proto.RegisterType((*QueryAllPartialUpgradeResponse)(nil), "inference.inference.QueryAllPartialUpgradeResponse")
+	proto.RegisterType((*QueryGetBridgeTransactionRequest)(nil), "inference.inference.QueryGetBridgeTransactionRequest")
+	proto.RegisterType((*QueryGetBridgeTransactionResponse)(nil), "inference.inference.QueryGetBridgeTransactionResponse")
+	proto.RegisterType((*QueryAllBridgeTransactionsRequest)(nil), "inference.inference.QueryAllBridgeTransactionsRequest")
+	proto.RegisterType((*QueryAllBridgeTransactionsResponse)(nil), "inference.inference.QueryAllBridgeTransactionsResponse")
+	proto.RegisterType((*WrappedTokenBalance)(nil), "inference.inference.WrappedTokenBalance")
+	proto.RegisterType((*QueryWrappedTokenBalancesRequest)(nil), "inference.inference.QueryWrappedTokenBalancesRequest")
+	proto.RegisterType((*QueryWrappedTokenBalancesResponse)(nil), "inference.inference.QueryWrappedTokenBalancesResponse")
+	proto.RegisterType((*QueryBridgeAddressesByChainRequest)(nil), "inference.inference.QueryBridgeAddressesByChainRequest")
+	proto.RegisterType((*QueryBridgeAddressesByChainResponse)(nil), "inference.inference.QueryBridgeAddressesByChainResponse")
+	proto.RegisterType((*QueryValidateWrappedTokenForTradeRequest)(nil), "inference.inference.QueryValidateWrappedTokenForTradeRequest")
+	proto.RegisterType((*QueryValidateWrappedTokenForTradeResponse)(nil), "inference.inference.QueryValidateWrappedTokenForTradeResponse")
+	proto.RegisterType((*QueryValidateIbcTokenForTradeRequest)(nil), "inference.inference.QueryValidateIbcTokenForTradeRequest")
+	proto.RegisterType((*QueryValidateIbcTokenForTradeResponse)(nil), "inference.inference.QueryValidateIbcTokenForTradeResponse")
+	proto.RegisterType((*QueryLiquidityPoolRequest)(nil), "inference.inference.QueryLiquidityPoolRequest")
+	proto.RegisterType((*QueryLiquidityPoolResponse)(nil), "inference.inference.QueryLiquidityPoolResponse")
+	proto.RegisterType((*QueryEpochInfoRequest)(nil), "inference.inference.QueryEpochInfoRequest")
+	proto.RegisterType((*QueryEpochInfoResponse)(nil), "inference.inference.QueryEpochInfoResponse")
+	proto.RegisterType((*QueryCountPoCbatchesAtHeightRequest)(nil), "inference.inference.QueryCountPoCbatchesAtHeightRequest")
+	proto.RegisterType((*QueryCountPoCbatchesAtHeightResponse)(nil), "inference.inference.QueryCountPoCbatchesAtHeightResponse")
+	proto.RegisterType((*QueryCountPoCvalidationsAtHeightRequest)(nil), "inference.inference.QueryCountPoCvalidationsAtHeightRequest")
+	proto.RegisterType((*QueryCountPoCvalidationsAtHeightResponse)(nil), "inference.inference.QueryCountPoCvalidationsAtHeightResponse")
+	proto.RegisterType((*QueryApprovedTokensForTradeRequest)(nil), "inference.inference.QueryApprovedTokensForTradeRequest")
+	proto.RegisterType((*QueryApprovedTokensForTradeResponse)(nil), "inference.inference.QueryApprovedTokensForTradeResponse")
+	proto.RegisterType((*QueryGetModelPerTokenPriceRequest)(nil), "inference.inference.QueryGetModelPerTokenPriceRequest")
+	proto.RegisterType((*QueryGetModelPerTokenPriceResponse)(nil), "inference.inference.QueryGetModelPerTokenPriceResponse")
+	proto.RegisterType((*QueryGetAllModelPerTokenPricesRequest)(nil), "inference.inference.QueryGetAllModelPerTokenPricesRequest")
+	proto.RegisterType((*ModelPrice)(nil), "inference.inference.ModelPrice")
+	proto.RegisterType((*QueryGetAllModelPerTokenPricesResponse)(nil), "inference.inference.QueryGetAllModelPerTokenPricesResponse")
+	proto.RegisterType((*QueryGetModelCapacityRequest)(nil), "inference.inference.QueryGetModelCapacityRequest")
+	proto.RegisterType((*QueryGetModelCapacityResponse)(nil), "inference.inference.QueryGetModelCapacityResponse")
+	proto.RegisterType((*QueryGetAllModelCapacitiesRequest)(nil), "inference.inference.QueryGetAllModelCapacitiesRequest")
+	proto.RegisterType((*QueryGetAllModelCapacitiesResponse)(nil), "inference.inference.QueryGetAllModelCapacitiesResponse")
+	proto.RegisterType((*ModelCapacity)(nil), "inference.inference.ModelCapacity")
+	proto.RegisterType((*QueryGranteesByMessageTypeRequest)(nil), "inference.inference.QueryGranteesByMessageTypeRequest")
+	proto.RegisterType((*Grantee)(nil), "inference.inference.Grantee")
+	proto.RegisterType((*QueryGranteesByMessageTypeResponse)(nil), "inference.inference.QueryGranteesByMessageTypeResponse")
+	proto.RegisterType((*QueryParticipantAllowListRequest)(nil), "inference.inference.QueryParticipantAllowListRequest")
+	proto.RegisterType((*QueryParticipantAllowListResponse)(nil), "inference.inference.QueryParticipantAllowListResponse")
+	proto.RegisterType((*QueryGetMLNodeVersionRequest)(nil), "inference.inference.QueryGetMLNodeVersionRequest")
+	proto.RegisterType((*QueryGetMLNodeVersionResponse)(nil), "inference.inference.QueryGetMLNodeVersionResponse")
+	proto.RegisterType((*QueryGetLastUpgradeHeightRequest)(nil), "inference.inference.QueryGetLastUpgradeHeightRequest")
+	proto.RegisterType((*QueryGetLastUpgradeHeightResponse)(nil), "inference.inference.QueryGetLastUpgradeHeightResponse")
+	proto.RegisterType((*QueryExcludedParticipantsRequest)(nil), "inference.inference.QueryExcludedParticipantsRequest")
+	proto.RegisterType((*QueryExcludedParticipantsResponse)(nil), "inference.inference.QueryExcludedParticipantsResponse")
+	proto.RegisterType((*QueryActiveConfirmationPoCEventRequest)(nil), "inference.inference.QueryActiveConfirmationPoCEventRequest")
+	proto.RegisterType((*QueryActiveConfirmationPoCEventResponse)(nil), "inference.inference.QueryActiveConfirmationPoCEventResponse")
+	proto.RegisterType((*QueryConfirmationPoCEventsRequest)(nil), "inference.inference.QueryConfirmationPoCEventsRequest")
+	proto.RegisterType((*QueryConfirmationPoCEventsResponse)(nil), "inference.inference.QueryConfirmationPoCEventsResponse")
+	proto.RegisterType((*ParticipantWithBalance)(nil), "inference.inference.ParticipantWithBalance")
+	proto.RegisterType((*QueryParticipantsWithBalancesRequest)(nil), "inference.inference.QueryParticipantsWithBalancesRequest")
+	proto.RegisterType((*QueryParticipantsWithBalancesResponse)(nil), "inference.inference.QueryParticipantsWithBalancesResponse")
+	proto.RegisterType((*QueryRandomSeedsRequest)(nil), "inference.inference.QueryRandomSeedsRequest")
+	proto.RegisterType((*QueryRandomSeedsResponse)(nil), "inference.inference.QueryRandomSeedsResponse")
+	proto.RegisterType((*QueryPoCValidationSnapshotRequest)(nil), "inference.inference.QueryPoCValidationSnapshotRequest")
+	proto.RegisterType((*QueryPoCValidationSnapshotResponse)(nil), "inference.inference.QueryPoCValidationSnapshotResponse")
+	proto.RegisterType((*QueryPreservedNodesSnapshotRequest)(nil), "inference.inference.QueryPreservedNodesSnapshotRequest")
+	proto.RegisterType((*QueryPreservedNodesSnapshotResponse)(nil), "inference.inference.QueryPreservedNodesSnapshotResponse")
+	proto.RegisterType((*QueryGetDevshardEscrowRequest)(nil), "inference.inference.QueryGetDevshardEscrowRequest")
+	proto.RegisterType((*QueryGetDevshardEscrowResponse)(nil), "inference.inference.QueryGetDevshardEscrowResponse")
+	proto.RegisterType((*QueryGetDevshardHostEpochStatsRequest)(nil), "inference.inference.QueryGetDevshardHostEpochStatsRequest")
+	proto.RegisterType((*QueryGetDevshardHostEpochStatsResponse)(nil), "inference.inference.QueryGetDevshardHostEpochStatsResponse")
+	proto.RegisterType((*QueryMaintenanceCreditRequest)(nil), "inference.inference.QueryMaintenanceCreditRequest")
+	proto.RegisterType((*QueryMaintenanceCreditResponse)(nil), "inference.inference.QueryMaintenanceCreditResponse")
+	proto.RegisterType((*QueryMaintenanceScheduledRequest)(nil), "inference.inference.QueryMaintenanceScheduledRequest")
+	proto.RegisterType((*QueryMaintenanceScheduledResponse)(nil), "inference.inference.QueryMaintenanceScheduledResponse")
+	proto.RegisterType((*QueryMaintenanceActiveRequest)(nil), "inference.inference.QueryMaintenanceActiveRequest")
+	proto.RegisterType((*QueryMaintenanceActiveResponse)(nil), "inference.inference.QueryMaintenanceActiveResponse")
+	proto.RegisterType((*QueryMaintenanceStatusRequest)(nil), "inference.inference.QueryMaintenanceStatusRequest")
+	proto.RegisterType((*QueryMaintenanceStatusResponse)(nil), "inference.inference.QueryMaintenanceStatusResponse")
+	proto.RegisterType((*QueryMaintenanceConcurrencyRequest)(nil), "inference.inference.QueryMaintenanceConcurrencyRequest")
+	proto.RegisterType((*QueryMaintenanceConcurrencyResponse)(nil), "inference.inference.QueryMaintenanceConcurrencyResponse")
+	proto.RegisterType((*QueryMaintenanceSchedulabilityRequest)(nil), "inference.inference.QueryMaintenanceSchedulabilityRequest")
+	proto.RegisterType((*QueryMaintenanceSchedulabilityResponse)(nil), "inference.inference.QueryMaintenanceSchedulabilityResponse")
+	proto.RegisterType((*QueryListClaimRecipientsRequest)(nil), "inference.inference.QueryListClaimRecipientsRequest")
+	proto.RegisterType((*QueryListClaimRecipientsResponse)(nil), "inference.inference.QueryListClaimRecipientsResponse")
+}
+
+func init() { proto.RegisterFile("inference/inference/query.proto", fileDescriptor_cf0cfe3b0e1cc5bd) }
+
+var fileDescriptor_cf0cfe3b0e1cc5bd = []byte{
+	// 7801 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x7d, 0x6b, 0x8c, 0x1c, 0xc7,
+	0x75, 0xae, 0x7a, 0x96, 0x8f, 0xdd, 0xe2, 0x72, 0x77, 0x59, 0xa4, 0xc8, 0xe5, 0x90, 0x5a, 0x51,
+	0x4d, 0xc9, 0x22, 0x29, 0x69, 0x47, 0x5c, 0x89, 0x94, 0x28, 0xbe, 0xb4, 0x2f, 0x3e, 0x24, 0x92,
+	0x5a, 0x0e, 0x29, 0xea, 0xe5, 0xab, 0x76, 0x4f, 0x4f, 0xef, 0x6e, 0x5b, 0x3d, 0xd3, 0xa3, 0xee,
+	0x9e, 0x25, 0xd7, 0x7b, 0xd7, 0xbe, 0x16, 0x0c, 0xf8, 0x02, 0xbe, 0x17, 0x4e, 0x60, 0xe4, 0x47,
+	0xec, 0x00, 0x81, 0x91, 0xfc, 0x70, 0x82, 0x20, 0xb0, 0x0d, 0xd8, 0x88, 0x1d, 0xe5, 0x0d, 0x1b,
+	0x8e, 0x1d, 0x18, 0x76, 0x64, 0x18, 0x71, 0x12, 0xd8, 0x8e, 0x1c, 0xd8, 0x81, 0x1d, 0xd8, 0xce,
+	0x03, 0xf9, 0x91, 0x1f, 0x49, 0xd0, 0x55, 0xa7, 0xba, 0xab, 0x7b, 0xaa, 0xaa, 0xbb, 0x67, 0x57,
+	0x4e, 0xfe, 0x10, 0x9c, 0xee, 0xaa, 0x53, 0xe7, 0x51, 0x75, 0xfa, 0xd4, 0xa9, 0x53, 0xdf, 0xa2,
+	0x7b, 0x9d, 0xf6, 0xa2, 0xed, 0xdb, 0x6d, 0xcb, 0xae, 0x25, 0xff, 0x7b, 0xbd, 0x6b, 0xfb, 0xab,
+	0x93, 0x1d, 0xdf, 0x0b, 0x3d, 0xbc, 0x3b, 0x7e, 0x3c, 0x19, 0xff, 0xaf, 0xba, 0xcb, 0x6c, 0x39,
+	0x6d, 0xaf, 0x46, 0xfe, 0xa5, 0xed, 0xaa, 0x7b, 0x96, 0xbc, 0x25, 0x8f, 0xfc, 0xb7, 0x16, 0xfd,
+	0x0f, 0x9e, 0x1e, 0x5c, 0xf2, 0xbc, 0x25, 0xd7, 0xae, 0x99, 0x1d, 0xa7, 0x66, 0xb6, 0xdb, 0x5e,
+	0x68, 0x86, 0x8e, 0xd7, 0x0e, 0xe0, 0xed, 0x31, 0xcb, 0x0b, 0x5a, 0x5e, 0x50, 0x6b, 0x98, 0x01,
+	0x0c, 0x5a, 0x5b, 0x39, 0xde, 0xb0, 0x43, 0xf3, 0x78, 0xad, 0x63, 0x2e, 0x39, 0x6d, 0xd2, 0x18,
+	0xda, 0x1e, 0x12, 0x31, 0xda, 0x31, 0x7d, 0xb3, 0xc5, 0xa8, 0x1d, 0x16, 0xb5, 0x48, 0xb8, 0xa7,
+	0x8d, 0x1e, 0x90, 0x90, 0x09, 0x1d, 0xcb, 0xe9, 0x98, 0xed, 0x90, 0x71, 0x26, 0x6a, 0x66, 0x77,
+	0x3c, 0x6b, 0xd9, 0x58, 0xf2, 0xbd, 0x6e, 0xc7, 0x68, 0x9a, 0xa1, 0x09, 0x6d, 0x1f, 0x14, 0xb5,
+	0x0d, 0xec, 0x30, 0x74, 0x6d, 0xc3, 0x6c, 0x79, 0xdd, 0x98, 0xe8, 0xf1, 0x3c, 0xa2, 0x2b, 0xa6,
+	0xeb, 0x34, 0x53, 0x1a, 0xd2, 0x85, 0xec, 0x7a, 0x56, 0xc3, 0x0c, 0xad, 0x65, 0x68, 0x73, 0x54,
+	0xd4, 0x26, 0xf4, 0x5e, 0xb3, 0xdb, 0x5e, 0xcb, 0xb1, 0x02, 0x9e, 0x55, 0x61, 0xd3, 0x6e, 0xdb,
+	0x09, 0x0d, 0x6f, 0xd1, 0xb0, 0xbc, 0x56, 0xa7, 0x1b, 0x32, 0x45, 0x09, 0x27, 0x46, 0xcb, 0x6b,
+	0xda, 0x2e, 0x34, 0x98, 0xe0, 0x8d, 0xc7, 0xcc, 0x66, 0x79, 0x0e, 0x33, 0xd8, 0x43, 0x4a, 0x73,
+	0x18, 0xa1, 0xd3, 0xb2, 0xbd, 0x2e, 0x53, 0xcd, 0x49, 0x75, 0xe3, 0x44, 0x31, 0x46, 0xd3, 0x0e,
+	0x4d, 0xc7, 0x65, 0xfa, 0x79, 0x4c, 0xae, 0xd2, 0x8e, 0xed, 0x2f, 0x7a, 0x7e, 0xcb, 0x8c, 0xfa,
+	0x07, 0xdd, 0x56, 0xcb, 0x64, 0x53, 0x5a, 0x6c, 0xb0, 0x65, 0xd3, 0x6f, 0xde, 0x36, 0x7d, 0xdb,
+	0x68, 0x7b, 0x4d, 0x5b, 0xa5, 0x2e, 0x32, 0x59, 0x4c, 0xd7, 0xe8, 0x76, 0x96, 0x7c, 0x33, 0x6e,
+	0x2a, 0x9c, 0x9e, 0x0d, 0xdf, 0x69, 0x2e, 0x29, 0x89, 0x05, 0xa1, 0x19, 0x06, 0x46, 0xd3, 0x5e,
+	0xb1, 0x5d, 0xaf, 0x63, 0xfb, 0x2a, 0xdd, 0x13, 0xa9, 0xa0, 0xc1, 0x11, 0xa1, 0x71, 0xdc, 0x88,
+	0x75, 0x63, 0xc5, 0xf6, 0x83, 0x64, 0xd9, 0x4c, 0x0a, 0x49, 0xdd, 0xb1, 0xdc, 0x6e, 0xd3, 0x6e,
+	0x1a, 0xbd, 0x13, 0xff, 0x51, 0x51, 0x7b, 0xcb, 0x6b, 0x2f, 0x3a, 0x7e, 0x8b, 0x1a, 0xa0, 0xe3,
+	0x59, 0x86, 0xbd, 0x62, 0xc7, 0x3d, 0x84, 0xbc, 0xb8, 0xce, 0xeb, 0x5d, 0xa7, 0xe9, 0x84, 0xab,
+	0x46, 0xc7, 0xf3, 0x5c, 0xe5, 0x12, 0xf6, 0x2c, 0x63, 0x65, 0x4a, 0xb5, 0x3a, 0x7d, 0xb3, 0xdd,
+	0xf4, 0x5a, 0x46, 0x60, 0xdb, 0x4d, 0xd5, 0x42, 0x22, 0x84, 0x92, 0x79, 0x12, 0xb4, 0xcd, 0x4e,
+	0xb0, 0xec, 0x85, 0x2a, 0xed, 0x37, 0xed, 0x95, 0x20, 0xb2, 0xbb, 0x61, 0x07, 0x96, 0xef, 0xdd,
+	0x56, 0x31, 0xd1, 0x32, 0x9d, 0x76, 0x68, 0xb7, 0xcd, 0xc4, 0x93, 0x4c, 0x09, 0x99, 0xf0, 0xed,
+	0xc0, 0xf6, 0x57, 0xec, 0x26, 0x99, 0x46, 0x41, 0x96, 0x8b, 0x23, 0x32, 0xc6, 0x9b, 0xb6, 0x6b,
+	0x2f, 0xf1, 0xee, 0x4e, 0xc8, 0xaf, 0xe5, 0x9a, 0x4e, 0xcb, 0xf0, 0x6d, 0xcb, 0xe9, 0x38, 0xb1,
+	0x01, 0xf4, 0x3d, 0x08, 0x5f, 0x8f, 0x7c, 0xe7, 0x02, 0x71, 0x86, 0x75, 0xfb, 0xf5, 0xae, 0x1d,
+	0x84, 0xfa, 0xf3, 0x68, 0x77, 0xea, 0x69, 0xd0, 0xf1, 0xda, 0x81, 0x8d, 0xcf, 0xa1, 0x6d, 0xd4,
+	0x69, 0x8e, 0x6b, 0x87, 0xb4, 0x23, 0x3b, 0xa6, 0x0e, 0x4c, 0x0a, 0xfc, 0xfb, 0x24, 0xed, 0x34,
+	0x33, 0xf4, 0x95, 0xef, 0xde, 0x7b, 0xd7, 0xa7, 0x7e, 0xf4, 0xe9, 0x63, 0x5a, 0x1d, 0x7a, 0xe9,
+	0x8f, 0xa2, 0x71, 0x42, 0xf6, 0xa2, 0x1d, 0x5e, 0x66, 0xcd, 0x61, 0x48, 0xbc, 0x07, 0x6d, 0x75,
+	0xda, 0x4d, 0xfb, 0x0e, 0x21, 0x3d, 0x54, 0xa7, 0x3f, 0x74, 0x03, 0xed, 0x17, 0xf4, 0x00, 0x76,
+	0x66, 0xd0, 0x50, 0x3c, 0x2a, 0x70, 0x34, 0x21, 0xe4, 0x28, 0xee, 0x3a, 0xb3, 0x25, 0x62, 0xaa,
+	0x9e, 0x74, 0xd3, 0x1b, 0xc0, 0xd2, 0xb4, 0xeb, 0xf6, 0xb0, 0x74, 0x01, 0xa1, 0xe4, 0x4b, 0x02,
+	0x03, 0xbc, 0x6b, 0x92, 0x7a, 0xae, 0xc9, 0xc8, 0x73, 0x4d, 0xd2, 0x6f, 0x1d, 0xf8, 0xaf, 0xc9,
+	0x05, 0x73, 0x89, 0xf5, 0xad, 0x73, 0x3d, 0xf5, 0x4f, 0x69, 0x20, 0x45, 0x7a, 0x10, 0xb1, 0x14,
+	0x03, 0x7d, 0x48, 0x81, 0x2f, 0xa6, 0x38, 0xad, 0x10, 0x4e, 0x1f, 0xcc, 0xe5, 0x94, 0x32, 0x90,
+	0x62, 0x75, 0x0a, 0x55, 0x99, 0xbe, 0x17, 0x92, 0xe5, 0xad, 0xb6, 0xd1, 0x12, 0x3a, 0x20, 0xec,
+	0x03, 0xf2, 0x5d, 0x42, 0x3b, 0x38, 0x4f, 0x01, 0x6a, 0x3c, 0x24, 0x9b, 0x39, 0xac, 0x1d, 0xc8,
+	0xc8, 0x77, 0xd5, 0x9b, 0xc0, 0xdc, 0xb4, 0xeb, 0x0a, 0x98, 0xdb, 0x2c, 0x6b, 0xbd, 0xa5, 0x81,
+	0x3c, 0xd9, 0x61, 0x64, 0xf2, 0x0c, 0xf4, 0x29, 0xcf, 0xa6, 0x59, 0x0d, 0xdf, 0x87, 0x86, 0x1b,
+	0xae, 0x67, 0xbd, 0x66, 0x2c, 0xdb, 0xce, 0xd2, 0x72, 0x38, 0x3e, 0x70, 0x48, 0x3b, 0x32, 0x50,
+	0xdf, 0x41, 0x9e, 0x5d, 0x22, 0x8f, 0xf4, 0x27, 0xd1, 0x41, 0x2a, 0x94, 0x65, 0x45, 0x41, 0xc5,
+	0xcc, 0xea, 0x74, 0xb3, 0xe9, 0xdb, 0x01, 0x5b, 0xf1, 0x78, 0x1c, 0x6d, 0x37, 0xe9, 0x13, 0x30,
+	0x2e, 0xfb, 0xa9, 0x2f, 0xa1, 0x7b, 0x24, 0x3d, 0x41, 0x21, 0x7b, 0xd1, 0xb6, 0x4e, 0xb7, 0xf1,
+	0x9a, 0xbd, 0x0a, 0x3d, 0xe1, 0x57, 0x44, 0xb2, 0x61, 0xba, 0x91, 0xd3, 0x23, 0xb2, 0x0d, 0xd4,
+	0xd9, 0xcf, 0x68, 0x1e, 0x35, 0xa3, 0x00, 0x83, 0x30, 0x3a, 0x54, 0xa7, 0x3f, 0xf4, 0x13, 0x30,
+	0xd0, 0x45, 0x3b, 0xac, 0x13, 0xaf, 0x3d, 0x7f, 0xc7, 0xb6, 0xba, 0xa1, 0xe7, 0x73, 0xd3, 0x8f,
+	0xc4, 0x10, 0x6c, 0xfa, 0x91, 0x1f, 0x7a, 0x13, 0x4d, 0xc8, 0xba, 0xc5, 0x2b, 0x6c, 0xd0, 0x86,
+	0x67, 0x25, 0xa7, 0x5f, 0xdc, 0x4f, 0x7f, 0x25, 0x61, 0x6e, 0x3e, 0xfa, 0x96, 0x5e, 0x8c, 0x62,
+	0xae, 0x39, 0x33, 0x34, 0x19, 0x73, 0xf7, 0xa2, 0x1d, 0x34, 0x74, 0x48, 0x56, 0xc8, 0x96, 0x3a,
+	0x22, 0x8f, 0x2e, 0x47, 0x4f, 0xf0, 0x7e, 0x34, 0x48, 0x18, 0x36, 0x9c, 0x26, 0xd1, 0xc7, 0x50,
+	0x7d, 0x3b, 0xf9, 0x7d, 0xb9, 0xa9, 0x77, 0x13, 0x11, 0xb2, 0xc4, 0x41, 0x84, 0x1b, 0x68, 0x2c,
+	0x1b, 0x40, 0x82, 0x28, 0x87, 0x85, 0xa2, 0xa4, 0xc9, 0x80, 0x34, 0x23, 0x76, 0xea, 0x69, 0x62,
+	0x59, 0xd7, 0x15, 0xcb, 0xb4, 0x59, 0x4b, 0xea, 0x0f, 0x35, 0x10, 0x50, 0x30, 0x92, 0x52, 0xc0,
+	0x81, 0x0d, 0x09, 0xb8, 0x79, 0x6e, 0xf1, 0x7c, 0xe2, 0xe2, 0x6e, 0x90, 0xd8, 0x7c, 0x9a, 0x84,
+	0xe6, 0x4c, 0x4f, 0x87, 0x7a, 0x5d, 0xdc, 0x50, 0xda, 0x75, 0xb9, 0xb0, 0xfc, 0x7a, 0x08, 0x80,
+	0xf8, 0x57, 0xd0, 0xce, 0x54, 0xd0, 0x0f, 0xca, 0xbe, 0x4f, 0x28, 0x3b, 0x4f, 0x01, 0x24, 0x1f,
+	0x0e, 0xb8, 0x67, 0xba, 0x9d, 0x78, 0x30, 0x11, 0xbb, 0x9b, 0x65, 0xd6, 0xcf, 0x69, 0xcc, 0xa9,
+	0x64, 0xc7, 0x91, 0x4b, 0x35, 0xd0, 0xb7, 0x54, 0x9b, 0x67, 0xcd, 0x79, 0x74, 0x1f, 0x61, 0x7b,
+	0x3e, 0x08, 0x9d, 0x96, 0x19, 0xda, 0x33, 0x4e, 0x18, 0x6d, 0x3d, 0xea, 0xf6, 0x6d, 0xd3, 0x6f,
+	0x16, 0xb7, 0xa9, 0x8f, 0x74, 0x15, 0x99, 0x77, 0xc4, 0xb2, 0x0e, 0xba, 0xbf, 0xd7, 0x53, 0xdc,
+	0x4a, 0x76, 0x7e, 0x85, 0xb9, 0xcf, 0xfa, 0xab, 0x4a, 0xd6, 0x5f, 0xe9, 0xbf, 0xac, 0xa1, 0x07,
+	0x72, 0xc6, 0x02, 0x11, 0x97, 0xd1, 0x3e, 0xc9, 0x46, 0x14, 0x84, 0x3d, 0x96, 0xb3, 0x84, 0x39,
+	0xa2, 0x20, 0xf5, 0xdd, 0xb6, 0xe8, 0xa5, 0xde, 0x06, 0xf1, 0x53, 0x7e, 0x44, 0x20, 0xfe, 0x66,
+	0xcd, 0xf0, 0xbf, 0x66, 0x3a, 0x90, 0x0f, 0x58, 0x44, 0x07, 0x03, 0x9b, 0xa8, 0x83, 0xcd, 0x5b,
+	0x06, 0xb3, 0xe0, 0x94, 0x17, 0x3c, 0x6b, 0xc6, 0x0c, 0xad, 0x65, 0x3b, 0xb8, 0xe0, 0xf9, 0x37,
+	0xc2, 0x44, 0x15, 0x3d, 0x71, 0x85, 0xd6, 0x1b, 0x57, 0x74, 0xd1, 0xbd, 0x52, 0x22, 0xa0, 0x9a,
+	0x3a, 0x1a, 0x8a, 0x76, 0x29, 0x24, 0xeb, 0x00, 0xca, 0xa8, 0x89, 0xbf, 0xbf, 0xde, 0x2c, 0xd0,
+	0x78, 0xc1, 0x09, 0x97, 0xb9, 0xaf, 0x31, 0xd3, 0xc8, 0x60, 0x07, 0x46, 0xd1, 0xbf, 0xa0, 0xa1,
+	0xaa, 0xbc, 0x79, 0x81, 0xe9, 0xbf, 0x0f, 0x6d, 0xef, 0x74, 0x1b, 0x46, 0x14, 0xb5, 0x54, 0xe2,
+	0xa8, 0xe5, 0x59, 0x7b, 0x15, 0x4f, 0xa0, 0x1d, 0xcb, 0xf6, 0x1d, 0x83, 0xbd, 0xa4, 0x11, 0xca,
+	0xd0, 0xb2, 0x7d, 0x67, 0x81, 0xbe, 0x7f, 0x9a, 0x97, 0x66, 0x0b, 0x91, 0xe6, 0x1e, 0xa5, 0x34,
+	0x3d, 0xbc, 0x5f, 0x04, 0xbf, 0xb1, 0xe0, 0x59, 0x9c, 0x5d, 0xfb, 0xd0, 0xfd, 0x87, 0x35, 0x74,
+	0x58, 0x49, 0x09, 0x0c, 0xf0, 0x1e, 0x34, 0x92, 0xde, 0xdf, 0x82, 0x15, 0x1e, 0x93, 0xf1, 0xcd,
+	0x11, 0x93, 0x58, 0x62, 0x67, 0x87, 0x1f, 0x52, 0xff, 0x0b, 0x0d, 0x4d, 0xa8, 0xfb, 0xbd, 0x93,
+	0x26, 0x79, 0xae, 0x47, 0x3e, 0x6a, 0x17, 0x3d, 0x5f, 0x3e, 0xb1, 0x38, 0x97, 0xc1, 0xcd, 0x44,
+	0x7a, 0x9d, 0xda, 0x98, 0x8d, 0x3e, 0xc2, 0x3c, 0x88, 0x9c, 0x16, 0x58, 0xa9, 0x21, 0xb1, 0xd2,
+	0x89, 0x3e, 0xac, 0x74, 0x6b, 0x4a, 0x2c, 0xd8, 0x4f, 0x34, 0x74, 0x28, 0xaf, 0xe7, 0x3b, 0x69,
+	0xa9, 0xeb, 0x12, 0x4b, 0xdd, 0x9f, 0x2f, 0xa3, 0x44, 0xa4, 0x54, 0x58, 0xbd, 0x35, 0x1d, 0x56,
+	0xff, 0x36, 0x8b, 0x4f, 0x22, 0x42, 0x53, 0x37, 0x42, 0xcf, 0xb7, 0x67, 0xbd, 0x56, 0xcb, 0x89,
+	0x03, 0xa1, 0x73, 0xe8, 0x60, 0xc4, 0x4e, 0x10, 0xd9, 0x21, 0xfa, 0xd7, 0x0f, 0x0d, 0x81, 0x3d,
+	0xc7, 0x3b, 0x9e, 0x45, 0x4c, 0x75, 0x23, 0x6a, 0x31, 0x93, 0x18, 0x17, 0xd7, 0xd0, 0x6e, 0x4e,
+	0x2d, 0x06, 0xdb, 0x40, 0x51, 0x9d, 0x60, 0xee, 0x15, 0x6c, 0x99, 0x52, 0xcc, 0x0e, 0xa4, 0x99,
+	0x5d, 0x86, 0x60, 0xbc, 0x97, 0x57, 0x98, 0x1f, 0x7b, 0xd0, 0x56, 0x2b, 0x0e, 0x20, 0x76, 0xd6,
+	0xe9, 0x0f, 0x7c, 0x00, 0x0d, 0xf9, 0x9e, 0x17, 0x1a, 0xcb, 0x66, 0xb0, 0x4c, 0x06, 0x1e, 0xae,
+	0x0f, 0x46, 0x0f, 0x2e, 0x99, 0xc1, 0x72, 0xd4, 0x65, 0xd1, 0xeb, 0xb6, 0xe9, 0x58, 0x83, 0x75,
+	0xfa, 0x43, 0xff, 0xac, 0x06, 0xd3, 0xfb, 0xea, 0x95, 0x6b, 0x5e, 0xd3, 0x7e, 0x81, 0xc8, 0x32,
+	0xe7, 0x04, 0xa1, 0xef, 0x34, 0xba, 0x91, 0x4e, 0xff, 0x27, 0xaa, 0xe7, 0x7d, 0xb0, 0x8c, 0xe4,
+	0x3c, 0x83, 0x9a, 0x4e, 0xa3, 0xed, 0xb7, 0xc9, 0xdb, 0x40, 0x19, 0x6d, 0xf2, 0x74, 0xea, 0xac,
+	0x47, 0xa2, 0xb0, 0x0a, 0xaf, 0xb0, 0xf7, 0xa2, 0x23, 0x71, 0x42, 0x20, 0x63, 0x9d, 0x1e, 0x97,
+	0xb0, 0x41, 0x9d, 0xe9, 0xb7, 0xd1, 0xd1, 0x02, 0x63, 0x81, 0xac, 0xcf, 0xa0, 0xed, 0x16, 0x7d,
+	0x05, 0xb2, 0x3e, 0x2a, 0x5d, 0x47, 0x3c, 0xa1, 0x68, 0xcd, 0xb3, 0x4d, 0x3c, 0x23, 0xa0, 0xbf,
+	0xa9, 0xa1, 0x03, 0x8a, 0x86, 0x32, 0x63, 0x6a, 0x52, 0x63, 0xc6, 0xf3, 0xb5, 0x22, 0x9d, 0xaf,
+	0x03, 0x99, 0xf9, 0x9a, 0x71, 0x1f, 0x5b, 0xb2, 0xee, 0x43, 0xb1, 0xd6, 0x7d, 0xf4, 0x28, 0xd3,
+	0x9b, 0x6c, 0x8a, 0x6c, 0xba, 0xad, 0x3e, 0xa6, 0xa1, 0xe3, 0x25, 0x06, 0x05, 0xa3, 0xbd, 0x8a,
+	0x76, 0x36, 0xf9, 0x06, 0x60, 0xba, 0x27, 0x73, 0xa7, 0x29, 0x4f, 0x96, 0x37, 0x61, 0x9a, 0x9c,
+	0xfe, 0xbb, 0x1a, 0x3a, 0x5c, 0xa0, 0x5b, 0x79, 0x83, 0x72, 0x2b, 0xab, 0x52, 0x7a, 0x65, 0x29,
+	0x96, 0xf6, 0x3d, 0xc9, 0xe6, 0x7a, 0xb6, 0xeb, 0xfb, 0x76, 0x9b, 0x6e, 0x37, 0x58, 0x2e, 0xfa,
+	0xf1, 0x64, 0xeb, 0x9c, 0x7e, 0x9d, 0xf8, 0x45, 0x12, 0x28, 0x43, 0xca, 0x85, 0xfe, 0xd0, 0xef,
+	0x4d, 0xf2, 0x35, 0x37, 0xe3, 0xd3, 0x2c, 0x2e, 0xb7, 0xa1, 0x87, 0x49, 0xce, 0x25, 0xdb, 0x20,
+	0x8e, 0x5b, 0x47, 0x33, 0x07, 0x61, 0xca, 0x94, 0x4b, 0x9a, 0x0a, 0xcb, 0x48, 0x84, 0xa9, 0xa7,
+	0xfa, 0x55, 0x58, 0xde, 0x17, 0xed, 0xf0, 0xf9, 0xb6, 0x13, 0x3e, 0xb7, 0x38, 0x4b, 0xcf, 0xcd,
+	0x16, 0x7c, 0xc7, 0xb2, 0x17, 0x7c, 0xaf, 0xe3, 0x05, 0xa6, 0x5b, 0x7c, 0x0b, 0xfa, 0x31, 0x0d,
+	0x1d, 0x2b, 0x42, 0x0f, 0x24, 0x7a, 0x16, 0x0d, 0x76, 0xe0, 0x19, 0x88, 0x22, 0x0e, 0xc4, 0x15,
+	0xa4, 0x62, 0x02, 0x78, 0x1c, 0x6d, 0x6f, 0xda, 0x8b, 0x66, 0xd7, 0x0d, 0x61, 0xf3, 0xc8, 0x7e,
+	0xea, 0x87, 0x61, 0x7f, 0xcd, 0x9b, 0x2b, 0x9b, 0x5b, 0xd2, 0x57, 0x21, 0x0a, 0x96, 0x34, 0x7a,
+	0x27, 0xf3, 0x5e, 0xf7, 0xb3, 0x00, 0xdc, 0xb7, 0x57, 0x1c, 0xaf, 0x1b, 0x88, 0x19, 0x7c, 0x1f,
+	0x0b, 0xae, 0x25, 0xad, 0xde, 0x49, 0x0e, 0x0d, 0x74, 0x37, 0xfd, 0xda, 0x45, 0x4b, 0x24, 0x98,
+	0x76, 0xdd, 0xcd, 0xde, 0xd8, 0xfe, 0xaa, 0x86, 0xf6, 0x66, 0x47, 0x00, 0x81, 0x4e, 0x26, 0x59,
+	0xd6, 0x68, 0x91, 0x57, 0xc5, 0x8b, 0x3c, 0x6a, 0x01, 0xcc, 0xd3, 0xe6, 0x9b, 0xb7, 0x2f, 0xf5,
+	0x60, 0x4b, 0xc9, 0x9f, 0xf9, 0xdc, 0xa4, 0x07, 0xbe, 0x4c, 0x0d, 0xc7, 0xd0, 0x98, 0x7d, 0xa7,
+	0xe3, 0xf8, 0xa4, 0xc3, 0xa5, 0xc4, 0x5b, 0x6f, 0xa9, 0xf7, 0x3c, 0x8f, 0x56, 0x51, 0xcc, 0xf7,
+	0x65, 0x96, 0x7a, 0xe5, 0x1f, 0xe9, 0xff, 0x1b, 0x1d, 0x92, 0x0f, 0x08, 0x5a, 0x79, 0x11, 0xed,
+	0xea, 0x39, 0x7e, 0x06, 0xfd, 0x3f, 0xa0, 0x3e, 0xad, 0x01, 0x4a, 0xa0, 0xac, 0x31, 0x27, 0xf3,
+	0x5c, 0x77, 0x40, 0x5c, 0xfe, 0x70, 0x28, 0x23, 0xee, 0x66, 0x59, 0xfd, 0x4b, 0x1a, 0x48, 0x2a,
+	0x1c, 0x4b, 0x2d, 0xe9, 0xc0, 0x86, 0x25, 0xdd, 0xbc, 0x19, 0xb2, 0x94, 0x78, 0xd1, 0x78, 0xf0,
+	0x64, 0x4b, 0x30, 0x47, 0x0f, 0xf9, 0xb9, 0x93, 0x0d, 0x9a, 0xd5, 0x6a, 0xc2, 0x14, 0x61, 0x3f,
+	0x0b, 0xcc, 0x8c, 0xdf, 0xe0, 0xfc, 0xab, 0x6a, 0x24, 0x50, 0x5d, 0x17, 0x55, 0x1d, 0x69, 0x2b,
+	0xa5, 0xc7, 0x95, 0x13, 0x07, 0x6d, 0x2a, 0x08, 0xeb, 0x41, 0x12, 0x33, 0xe6, 0xab, 0x63, 0xb3,
+	0xe6, 0xd2, 0x3f, 0x32, 0xd5, 0xe4, 0x8c, 0x5a, 0x50, 0x35, 0x03, 0xef, 0x88, 0x6a, 0x36, 0x6f,
+	0xca, 0xbd, 0x8a, 0x1e, 0x56, 0x4c, 0x04, 0x72, 0xe4, 0x6d, 0x87, 0xb6, 0x1f, 0xab, 0x79, 0x0c,
+	0x0d, 0x38, 0x4d, 0x2a, 0xd8, 0x50, 0x3d, 0xfa, 0x2f, 0x3e, 0x88, 0x86, 0x7c, 0xfa, 0xd2, 0xf6,
+	0x61, 0xae, 0x25, 0x0f, 0xf4, 0xdf, 0xab, 0xa0, 0x47, 0x0a, 0x0e, 0x00, 0x1a, 0xbd, 0x86, 0xc6,
+	0x60, 0x1f, 0xed, 0xf9, 0x46, 0xc7, 0xbb, 0x6d, 0xfb, 0x81, 0xf2, 0xc4, 0xe4, 0x16, 0x6b, 0xbc,
+	0x10, 0xb5, 0xad, 0x8f, 0xae, 0xa4, 0x7e, 0x07, 0xf8, 0x01, 0x34, 0x62, 0xd1, 0x6f, 0x31, 0x8b,
+	0x7f, 0xe9, 0x67, 0x7d, 0x27, 0x3c, 0x05, 0x77, 0x7a, 0x39, 0xfa, 0xec, 0x53, 0xab, 0x0d, 0xf4,
+	0x65, 0xb5, 0x3a, 0xeb, 0x8f, 0xe7, 0x23, 0xe3, 0x30, 0xb9, 0x48, 0xb4, 0x2f, 0x73, 0x31, 0x19,
+	0x45, 0x04, 0x75, 0xae, 0xa3, 0x7e, 0x11, 0x8d, 0xa4, 0x65, 0x8b, 0x42, 0x42, 0xa2, 0x10, 0x16,
+	0x12, 0x92, 0x1f, 0xf9, 0x19, 0xef, 0xab, 0x30, 0xa3, 0xc9, 0x27, 0x7a, 0x21, 0xa9, 0x00, 0xba,
+	0x41, 0x0b, 0x80, 0x66, 0x56, 0xf9, 0xb8, 0x34, 0xf7, 0xc0, 0x4f, 0xff, 0x84, 0x86, 0x1e, 0x2a,
+	0x44, 0x0f, 0x0c, 0xea, 0x42, 0x0a, 0xb9, 0xb7, 0x25, 0xd8, 0xf5, 0x61, 0x79, 0x40, 0x21, 0xa0,
+	0x4e, 0x17, 0x87, 0x8c, 0xa4, 0xbe, 0x0a, 0x1b, 0x26, 0x29, 0x73, 0x82, 0x23, 0xf6, 0xdc, 0x33,
+	0xce, 0xfb, 0xd1, 0x4e, 0x2e, 0x3c, 0x8d, 0x7d, 0x6a, 0xfa, 0xa1, 0xfe, 0x49, 0xb6, 0x6f, 0x2a,
+	0x36, 0x76, 0x11, 0xf5, 0x68, 0x9b, 0xad, 0x9e, 0x0e, 0x7a, 0x57, 0x2a, 0xf1, 0xdf, 0xdb, 0x64,
+	0xb3, 0x1d, 0xea, 0xf7, 0x35, 0xf4, 0x60, 0xee, 0x90, 0xff, 0x1d, 0x53, 0x65, 0xf3, 0x9c, 0xe8,
+	0x59, 0xa8, 0x83, 0xb9, 0x04, 0xe5, 0x72, 0xd1, 0x46, 0xb1, 0xf8, 0x91, 0x95, 0x7e, 0x0b, 0xea,
+	0x3f, 0x32, 0xdd, 0x41, 0x27, 0x4f, 0xa2, 0xad, 0xa4, 0x6c, 0x0a, 0x4c, 0x20, 0x4e, 0xfe, 0xa6,
+	0xbb, 0xd2, 0x0e, 0xfa, 0x04, 0xec, 0x30, 0x53, 0x2f, 0x93, 0xa0, 0x5b, 0x7f, 0x09, 0xf6, 0x92,
+	0xbd, 0xef, 0x7b, 0x87, 0x1e, 0x28, 0x37, 0xf4, 0x35, 0x98, 0x66, 0xe9, 0xda, 0x19, 0xd8, 0x13,
+	0xdd, 0x08, 0xcd, 0x30, 0x56, 0x4f, 0xcf, 0xd2, 0xd2, 0x44, 0x4b, 0xcb, 0x84, 0x39, 0xa4, 0xa2,
+	0x97, 0x94, 0x6d, 0xdc, 0xe6, 0x23, 0x67, 0xf8, 0x85, 0x27, 0x10, 0xf2, 0xed, 0x4e, 0x37, 0x4c,
+	0xac, 0xbd, 0xb5, 0xce, 0x3d, 0xd1, 0x1f, 0x4a, 0x82, 0xaf, 0x74, 0x85, 0x8c, 0x80, 0x6b, 0xfd,
+	0x5b, 0x5c, 0x00, 0xa5, 0x6a, 0x1d, 0x9f, 0xa2, 0xed, 0xe7, 0x73, 0x12, 0xec, 0x7b, 0x44, 0x0a,
+	0x1d, 0x95, 0x33, 0x5b, 0x46, 0x78, 0x5f, 0x47, 0xfc, 0xa2, 0x27, 0x75, 0x5f, 0xe9, 0x49, 0xdd,
+	0xe3, 0xfd, 0x68, 0x10, 0xbc, 0x5d, 0x13, 0x2a, 0x6a, 0x58, 0xe4, 0xa8, 0x7f, 0x45, 0x43, 0xfb,
+	0x24, 0x43, 0x46, 0xdf, 0x51, 0x5e, 0x06, 0x47, 0x6c, 0x29, 0x4e, 0xfd, 0x95, 0x94, 0xfa, 0x8f,
+	0xa2, 0x31, 0x7b, 0x71, 0xd1, 0xb6, 0x42, 0x67, 0xc5, 0x36, 0xa0, 0xc5, 0x16, 0xd2, 0x62, 0x34,
+	0x7e, 0x4e, 0x93, 0x2b, 0xf8, 0x30, 0xda, 0x69, 0x99, 0x9d, 0x8e, 0xdd, 0x64, 0xed, 0xb6, 0x92,
+	0x76, 0xc3, 0xf4, 0xe1, 0x0b, 0x22, 0x73, 0x0e, 0xf4, 0x98, 0xf3, 0x33, 0x15, 0xb4, 0x87, 0x13,
+	0xe5, 0x42, 0xd7, 0x75, 0xa9, 0x1c, 0x0f, 0xa2, 0x51, 0x93, 0x96, 0xfc, 0x64, 0x72, 0x43, 0x23,
+	0xf0, 0x98, 0xe5, 0x85, 0x8e, 0xa2, 0x31, 0xaf, 0x63, 0xfb, 0x24, 0x0e, 0x49, 0xe7, 0x78, 0x47,
+	0xd9, 0x73, 0xd6, 0x34, 0x87, 0x19, 0x7c, 0x1a, 0x55, 0x6d, 0xd3, 0x6f, 0xdb, 0x4d, 0xc3, 0xf2,
+	0x9c, 0x76, 0x10, 0x4f, 0x00, 0x9a, 0xe0, 0xa1, 0x6a, 0xd8, 0x47, 0x5b, 0xcc, 0x46, 0x0d, 0xf8,
+	0xe4, 0x01, 0x3e, 0x8b, 0x0e, 0xf8, 0xe4, 0xec, 0x3d, 0xee, 0xee, 0x9a, 0xa1, 0x1d, 0xb0, 0xde,
+	0x54, 0x39, 0xe3, 0xac, 0x09, 0xe9, 0x7f, 0x85, 0x34, 0xa0, 0xdd, 0x8f, 0xc2, 0x46, 0x3e, 0x20,
+	0xb5, 0xcc, 0xae, 0x1d, 0xda, 0xcd, 0xf1, 0x6d, 0x24, 0x75, 0x39, 0x4a, 0x9f, 0xcf, 0xb2, 0xc7,
+	0x71, 0x82, 0x83, 0x3f, 0x38, 0x89, 0x15, 0xc7, 0xa6, 0xfe, 0xfb, 0x59, 0x96, 0x41, 0xdc, 0x28,
+	0xde, 0x6d, 0xf1, 0xa9, 0xb6, 0x20, 0x35, 0xd5, 0x8f, 0xe6, 0x4d, 0xf5, 0x84, 0xdc, 0x2e, 0x9e,
+	0x08, 0x79, 0xa4, 0xbf, 0x1f, 0xb2, 0xd6, 0xe4, 0xd7, 0xcc, 0x6a, 0xb4, 0x09, 0x5b, 0xb0, 0x7d,
+	0xc7, 0x6b, 0xce, 0xac, 0xce, 0xb1, 0x92, 0x61, 0xe6, 0x5c, 0x0e, 0xa2, 0xa1, 0xb8, 0x8c, 0x18,
+	0xac, 0x9c, 0x3c, 0xc0, 0x07, 0xd0, 0x50, 0xb4, 0x0f, 0x34, 0x16, 0x7d, 0xaf, 0x05, 0x0b, 0x65,
+	0x30, 0x7a, 0x70, 0xc1, 0xf7, 0x5a, 0x78, 0x1f, 0xda, 0x4e, 0x5e, 0x86, 0x1e, 0x2c, 0x92, 0x6d,
+	0xd1, 0xcf, 0x9b, 0x9e, 0xee, 0x82, 0x9f, 0x50, 0x8f, 0x0f, 0x6a, 0x38, 0x8f, 0xb6, 0xe6, 0x4b,
+	0x1e, 0x77, 0xe3, 0x48, 0xd6, 0x69, 0x3f, 0x7d, 0x19, 0xc2, 0x67, 0x78, 0x15, 0x37, 0x9d, 0x6e,
+	0x37, 0x89, 0x79, 0x67, 0x4c, 0xeb, 0xb5, 0xc8, 0xf0, 0x41, 0x31, 0x91, 0xd9, 0xda, 0x0f, 0x0c,
+	0xe6, 0x02, 0xe9, 0xda, 0x0f, 0xae, 0xe9, 0x75, 0x74, 0x82, 0x8c, 0x14, 0x47, 0xb8, 0xc1, 0x74,
+	0xbb, 0x49, 0x92, 0x7f, 0x01, 0x0c, 0x4e, 0x06, 0x0c, 0x7a, 0x46, 0xe4, 0x69, 0x6a, 0x69, 0x9a,
+	0xcb, 0x10, 0x8c, 0xc9, 0x69, 0x26, 0xea, 0x63, 0xe4, 0xfa, 0xb3, 0x4a, 0x13, 0xf6, 0x31, 0xf2,
+	0x91, 0x68, 0x46, 0x68, 0x63, 0xa3, 0x18, 0x08, 0x11, 0x32, 0xd4, 0x93, 0x08, 0xeb, 0xf6, 0x22,
+	0xca, 0xa6, 0x63, 0x90, 0xfc, 0x68, 0xc0, 0x28, 0x9b, 0x0e, 0x65, 0x25, 0x72, 0x14, 0xb1, 0xdd,
+	0x03, 0xe6, 0x28, 0x92, 0x27, 0x7a, 0x00, 0xe6, 0xce, 0x17, 0x23, 0xae, 0x01, 0x1c, 0xa6, 0xe5,
+	0xf2, 0x64, 0x70, 0x36, 0xcf, 0xee, 0x95, 0x27, 0xb7, 0xe8, 0xba, 0xda, 0x41, 0x3a, 0x51, 0x5a,
+	0xfa, 0xc7, 0xd9, 0x59, 0xae, 0x6c, 0xd4, 0x78, 0xb4, 0x94, 0x6c, 0x9a, 0x52, 0xb6, 0x4a, 0x56,
+	0x36, 0xfc, 0x38, 0xda, 0x6b, 0x5a, 0x61, 0xd7, 0x74, 0x8d, 0xe4, 0xa1, 0x61, 0x79, 0x01, 0xab,
+	0xeb, 0xdc, 0x43, 0xdf, 0x26, 0x4c, 0xcc, 0x7a, 0x41, 0xa8, 0xeb, 0x90, 0xda, 0x99, 0x25, 0xae,
+	0x39, 0xf5, 0xa9, 0x8d, 0x5d, 0xd2, 0x29, 0x96, 0x98, 0x15, 0xb6, 0x49, 0xf2, 0xe9, 0xa1, 0x17,
+	0x42, 0x86, 0x78, 0xa0, 0x4e, 0x7f, 0xe8, 0xe3, 0x90, 0x2f, 0x9c, 0xb3, 0x1b, 0xdd, 0xa5, 0x94,
+	0x9f, 0xfb, 0xfa, 0x00, 0xda, 0xd7, 0xf3, 0x2a, 0x3e, 0xd3, 0xde, 0x49, 0xb5, 0xde, 0x58, 0x25,
+	0xa9, 0x24, 0x50, 0xfb, 0x39, 0xa1, 0xda, 0x25, 0x44, 0x26, 0x6f, 0xda, 0xad, 0x8e, 0xe7, 0x9b,
+	0x3e, 0x59, 0x03, 0xd1, 0x2b, 0xb0, 0x0a, 0x5d, 0x14, 0xd8, 0x46, 0x23, 0xf1, 0x18, 0xd4, 0xd3,
+	0xd3, 0xd3, 0x89, 0xf3, 0xfd, 0x0d, 0x42, 0x16, 0x2f, 0x19, 0x65, 0x38, 0xe0, 0x96, 0x73, 0xd5,
+	0x47, 0xbb, 0x7a, 0x18, 0xc9, 0x71, 0x22, 0xb1, 0x53, 0xab, 0xf4, 0xe7, 0xd4, 0xaa, 0x21, 0xc2,
+	0xbd, 0x7c, 0xe5, 0x0c, 0xfa, 0x74, 0x7a, 0xd0, 0x63, 0x85, 0x06, 0xa5, 0x1b, 0x51, 0x70, 0xa5,
+	0x47, 0x93, 0x18, 0xf2, 0xaa, 0xd3, 0x76, 0x5a, 0xdd, 0x56, 0xb2, 0xfd, 0x9e, 0x5e, 0xb1, 0xfd,
+	0x64, 0xff, 0xa2, 0x7f, 0x5a, 0x83, 0x8f, 0x8c, 0xb2, 0x2d, 0x4c, 0x86, 0xc3, 0x68, 0x67, 0xe8,
+	0x9b, 0x8b, 0x8b, 0x8e, 0x65, 0x34, 0xcc, 0xc0, 0x09, 0x20, 0xee, 0x1c, 0x86, 0x87, 0x33, 0xd1,
+	0x33, 0x7c, 0x06, 0x55, 0x5b, 0x94, 0x10, 0x7f, 0x1f, 0xc3, 0xa4, 0xa4, 0x20, 0xac, 0x18, 0x6f,
+	0x49, 0x86, 0x12, 0x16, 0x42, 0x6f, 0x49, 0x17, 0x64, 0x3c, 0x91, 0x1c, 0x0c, 0x2d, 0xd0, 0xcb,
+	0x38, 0xcf, 0xd3, 0xbb, 0x38, 0xcc, 0xe3, 0xed, 0x45, 0xdb, 0x96, 0x53, 0x71, 0x31, 0xfd, 0xa5,
+	0x07, 0xc9, 0x81, 0x51, 0xb6, 0x23, 0x08, 0x78, 0x1d, 0x22, 0xbf, 0xf8, 0x8d, 0xf2, 0x20, 0x20,
+	0x4d, 0x84, 0x1d, 0x04, 0xa4, 0x09, 0xf0, 0x25, 0xba, 0x62, 0x6e, 0x37, 0x6b, 0xf7, 0xf9, 0x26,
+	0x57, 0xa2, 0x5b, 0x42, 0xbc, 0x81, 0x0d, 0x89, 0xb7, 0x79, 0x3b, 0xcb, 0xff, 0xaf, 0x25, 0x39,
+	0xfc, 0x19, 0x72, 0x71, 0xea, 0xa6, 0x6f, 0xb6, 0x03, 0xd3, 0xe2, 0xeb, 0x19, 0xee, 0x43, 0xc3,
+	0x9e, 0xef, 0x2c, 0x39, 0x6d, 0xc3, 0x5a, 0x36, 0x9d, 0x36, 0xdb, 0x62, 0xd2, 0x67, 0xb3, 0xd1,
+	0xa3, 0x64, 0x02, 0xb5, 0xbb, 0xad, 0x46, 0x9c, 0xa7, 0xa3, 0x13, 0xe8, 0x1a, 0x79, 0x14, 0x4d,
+	0x63, 0xdf, 0xb6, 0x6c, 0xa7, 0x13, 0x42, 0x1a, 0x84, 0x1e, 0x67, 0x0e, 0xc3, 0x43, 0x9a, 0xfb,
+	0xf9, 0xa0, 0x06, 0xae, 0x56, 0xcc, 0x0f, 0x68, 0xf4, 0xdd, 0x08, 0x37, 0xb2, 0x2f, 0xd9, 0xa7,
+	0xe9, 0x5d, 0x42, 0xad, 0xf6, 0xd0, 0x02, 0xc5, 0x0a, 0xe8, 0xe8, 0xaf, 0x01, 0x0b, 0xd3, 0xae,
+	0xdb, 0xd3, 0x6d, 0xd3, 0xd3, 0xc1, 0x5f, 0xd3, 0x20, 0xdc, 0x95, 0x8c, 0xf6, 0x8b, 0x90, 0x78,
+	0xf3, 0xa6, 0xd3, 0xf7, 0x35, 0xb4, 0xfb, 0x05, 0x9f, 0x6c, 0xa3, 0xc8, 0x47, 0x7b, 0x06, 0x2e,
+	0x2e, 0x5c, 0x43, 0x88, 0x7c, 0xd4, 0xa3, 0x2f, 0xb3, 0xa7, 0x4c, 0xe8, 0x53, 0xb6, 0x79, 0x1a,
+	0xb3, 0x5e, 0x3b, 0xf4, 0x4d, 0x2b, 0xac, 0x0f, 0x11, 0x12, 0x97, 0xdb, 0x8b, 0x5e, 0xe4, 0x6b,
+	0x82, 0xd5, 0x56, 0xc3, 0x73, 0x59, 0x1d, 0x15, 0xfd, 0xc5, 0x5f, 0x9d, 0x80, 0xc3, 0x72, 0x76,
+	0x75, 0xa2, 0x8a, 0x06, 0x9b, 0xb6, 0xe5, 0xb4, 0x4c, 0x37, 0x80, 0xfa, 0x88, 0xf8, 0x37, 0x7e,
+	0x08, 0xed, 0x22, 0xa9, 0x9b, 0x30, 0xb4, 0x9b, 0x06, 0xeb, 0x4f, 0xeb, 0x24, 0xc6, 0xe2, 0x17,
+	0x20, 0x8a, 0x7e, 0x06, 0x16, 0x8c, 0x40, 0xcc, 0x02, 0x97, 0x42, 0x1c, 0x98, 0x5b, 0xe2, 0xde,
+	0x60, 0xec, 0x39, 0x34, 0x08, 0x5c, 0x30, 0x13, 0x1f, 0x11, 0xea, 0x4a, 0x40, 0xa4, 0x1e, 0xf7,
+	0xd4, 0xcf, 0xc3, 0xc4, 0xa2, 0x1a, 0x85, 0x9d, 0xa4, 0x1d, 0xcc, 0xac, 0x92, 0x15, 0xcb, 0x05,
+	0xd7, 0x64, 0x51, 0x27, 0xfb, 0xed, 0xed, 0xe4, 0x37, 0xb9, 0x5d, 0x71, 0x58, 0x49, 0x20, 0xce,
+	0xa7, 0x0f, 0x99, 0xec, 0x9d, 0xb2, 0x66, 0x97, 0xd2, 0x61, 0xe6, 0x04, 0x7a, 0xec, 0x4e, 0x56,
+	0x4c, 0x42, 0x7f, 0x1e, 0x3e, 0x8d, 0xf0, 0x95, 0x4a, 0xcd, 0x85, 0x0b, 0x9e, 0x7f, 0x93, 0xf7,
+	0xe2, 0x47, 0xd1, 0x98, 0x05, 0xf4, 0x32, 0x9b, 0xed, 0x51, 0x2b, 0x3d, 0x8e, 0x7e, 0x01, 0xb6,
+	0x55, 0x6a, 0xb2, 0x20, 0xd3, 0x7e, 0x34, 0xe8, 0x04, 0xf4, 0x43, 0x4a, 0xe8, 0x0d, 0xd6, 0xb7,
+	0x3b, 0x01, 0xe9, 0xa9, 0xcf, 0x42, 0x11, 0x18, 0xa3, 0x73, 0xb9, 0x61, 0x09, 0x59, 0x3b, 0x80,
+	0x86, 0x9c, 0x86, 0x65, 0xd0, 0xfb, 0x3a, 0x94, 0xa7, 0x41, 0xa7, 0x61, 0xcd, 0x91, 0x2b, 0x3b,
+	0xaf, 0x42, 0x40, 0x2c, 0x27, 0x92, 0xcb, 0x48, 0x6a, 0x46, 0xd3, 0x52, 0xa1, 0xf8, 0xb7, 0x7e,
+	0x00, 0x12, 0x86, 0x57, 0xd8, 0x8d, 0xd0, 0x05, 0xcf, 0x8b, 0xd3, 0x72, 0xaf, 0x43, 0x3a, 0x30,
+	0xf3, 0x12, 0x46, 0x94, 0xce, 0xdd, 0x68, 0xd1, 0x59, 0x5e, 0x93, 0x9d, 0xf8, 0x6d, 0xa9, 0xc3,
+	0xaf, 0x22, 0xc1, 0xc3, 0x3e, 0x38, 0x97, 0x9f, 0xa7, 0x29, 0xef, 0x45, 0x8f, 0xf1, 0xf2, 0xc3,
+	0x0a, 0xc4, 0xc7, 0xdc, 0x1b, 0x60, 0x24, 0xbf, 0x48, 0x14, 0x9f, 0x8a, 0xef, 0x55, 0x56, 0xf2,
+	0xef, 0x55, 0xd2, 0x89, 0x06, 0x1d, 0xf0, 0x2c, 0x1a, 0x4e, 0x65, 0x39, 0x06, 0x08, 0x81, 0xaa,
+	0x3c, 0xfd, 0xcb, 0x2e, 0xa2, 0xb9, 0x5c, 0xea, 0xe3, 0x34, 0xaa, 0x3a, 0xd1, 0x16, 0x23, 0x73,
+	0x51, 0xd7, 0x24, 0xc9, 0x26, 0xe2, 0x66, 0x06, 0xeb, 0xfb, 0x9c, 0x60, 0x96, 0x6b, 0xb0, 0xe0,
+	0x59, 0xd3, 0xe4, 0x35, 0x76, 0xd1, 0x3d, 0xb4, 0xa1, 0x21, 0xbe, 0xe9, 0x4b, 0x3c, 0x90, 0x2c,
+	0xfa, 0x4d, 0x93, 0x9c, 0x9d, 0x8f, 0x3a, 0xd4, 0xab, 0x94, 0x5e, 0x66, 0x38, 0xf2, 0x4e, 0xbf,
+	0x08, 0x8b, 0x99, 0x6c, 0x61, 0x16, 0xbc, 0xd9, 0x06, 0xad, 0x00, 0x9f, 0x86, 0xe3, 0x29, 0x2e,
+	0x99, 0xcc, 0x29, 0x18, 0xb6, 0xdb, 0x29, 0x53, 0x9e, 0x81, 0xf9, 0x2f, 0x25, 0x24, 0x2a, 0xbb,
+	0xdc, 0x02, 0x65, 0x6c, 0xfa, 0xb3, 0x10, 0x23, 0xb3, 0xde, 0x5c, 0xbd, 0x7f, 0x79, 0x56, 0x9e,
+	0x06, 0x4f, 0xa1, 0x24, 0xa6, 0x64, 0x87, 0x55, 0xb4, 0x4c, 0x77, 0x3a, 0xbe, 0xb7, 0x02, 0xde,
+	0x20, 0xc8, 0x2c, 0x65, 0xfd, 0x03, 0xa0, 0x3b, 0x59, 0xab, 0x38, 0x25, 0x35, 0x6a, 0x42, 0x8b,
+	0x64, 0x0b, 0x2b, 0xdf, 0xc0, 0xc0, 0x07, 0x3a, 0x6a, 0x58, 0xb7, 0xd3, 0x37, 0x54, 0x47, 0xcc,
+	0xd4, 0x48, 0xfa, 0xb9, 0x24, 0x28, 0x22, 0x5b, 0xea, 0x05, 0xdb, 0x27, 0x6f, 0x48, 0x89, 0x11,
+	0xe7, 0xc9, 0xe3, 0x4a, 0x31, 0x2d, 0x5d, 0x29, 0xb6, 0x00, 0x62, 0x4a, 0xfa, 0x27, 0x2a, 0xea,
+	0x44, 0x0f, 0xe2, 0xd3, 0xbf, 0xe8, 0x87, 0xa4, 0xb4, 0xf3, 0xc1, 0xe4, 0x8e, 0xcb, 0xb4, 0xeb,
+	0xf6, 0x12, 0x8d, 0x77, 0xb9, 0x67, 0x21, 0xa3, 0x41, 0x9e, 0x2a, 0x78, 0x4c, 0x46, 0xaf, 0x70,
+	0xa3, 0xeb, 0x7e, 0x92, 0xe7, 0x97, 0x8d, 0x13, 0x5f, 0x2f, 0x1d, 0xa6, 0xa4, 0x49, 0xc7, 0x02,
+	0x89, 0x0a, 0xd2, 0x9f, 0xad, 0xea, 0x56, 0xfc, 0x24, 0xd0, 0x4f, 0x25, 0x85, 0x73, 0xa4, 0xe1,
+	0xac, 0xd9, 0x31, 0x2d, 0x27, 0x5c, 0x2d, 0xa0, 0xe8, 0xeb, 0xc9, 0x26, 0x29, 0xd3, 0x15, 0xb8,
+	0xac, 0xa2, 0x41, 0x0b, 0x9e, 0x81, 0x9a, 0xe3, 0xdf, 0x12, 0x4d, 0x1f, 0x4e, 0x6c, 0xcf, 0x34,
+	0x00, 0x54, 0x9d, 0x44, 0xcb, 0xab, 0x89, 0x81, 0x45, 0x8d, 0x92, 0x92, 0x2b, 0xca, 0xb8, 0x15,
+	0xbf, 0x53, 0x9e, 0xbc, 0xa4, 0x44, 0x00, 0x4d, 0x8d, 0xb6, 0xd2, 0xc4, 0xf5, 0x0b, 0x68, 0x67,
+	0xaa, 0x9d, 0xca, 0xc6, 0xbc, 0xf4, 0x95, 0xb4, 0xf4, 0xfa, 0x0a, 0x93, 0xd3, 0x37, 0xdb, 0xa1,
+	0x1d, 0x85, 0x19, 0x57, 0xed, 0x20, 0x30, 0x97, 0xec, 0x9b, 0xab, 0x9d, 0x78, 0x8e, 0x3f, 0x88,
+	0x46, 0x97, 0xc8, 0x7b, 0x3f, 0x9b, 0x5b, 0x87, 0xc7, 0x2c, 0x61, 0x7e, 0x04, 0x8d, 0xb5, 0x68,
+	0x77, 0x23, 0x5c, 0xed, 0xd8, 0x46, 0xd7, 0x67, 0xa1, 0xe2, 0x48, 0x2b, 0x21, 0xfb, 0xbc, 0xef,
+	0xea, 0x67, 0xd0, 0x76, 0x18, 0x52, 0xf1, 0xe9, 0x93, 0x15, 0xee, 0xeb, 0xaf, 0x32, 0xc5, 0x8b,
+	0xb9, 0x8e, 0xcf, 0xb9, 0x06, 0x97, 0xa0, 0x01, 0x28, 0xfc, 0xa0, 0x50, 0xe1, 0x40, 0xa5, 0x1e,
+	0xb7, 0x8e, 0xb3, 0x53, 0x5c, 0xc6, 0x69, 0xda, 0x75, 0xbd, 0xdb, 0x57, 0x9c, 0x80, 0x39, 0x4a,
+	0x7d, 0xba, 0x37, 0xab, 0xce, 0xb5, 0x01, 0x16, 0x0e, 0x66, 0xa3, 0xb4, 0x21, 0x3e, 0xe6, 0x9a,
+	0xe0, 0xa6, 0x3c, 0x29, 0x43, 0xbd, 0x45, 0xf1, 0x2c, 0xd8, 0x10, 0x1d, 0x6e, 0x5e, 0xa7, 0xdf,
+	0x03, 0xf9, 0xe7, 0xd0, 0x48, 0x1a, 0x09, 0x43, 0x79, 0x9a, 0x98, 0xa2, 0xc1, 0xae, 0x27, 0xd0,
+	0xfe, 0xf0, 0x30, 0x16, 0xfc, 0xa2, 0x1d, 0x5e, 0x31, 0x83, 0x10, 0x36, 0xbe, 0xa9, 0x2f, 0x44,
+	0x1c, 0x4c, 0x8b, 0xdb, 0x00, 0x67, 0x93, 0x68, 0xb7, 0x6b, 0x06, 0x21, 0x43, 0x0e, 0x49, 0x47,
+	0x13, 0xbb, 0xdc, 0x6c, 0x3f, 0xc9, 0x2a, 0x9c, 0x05, 0x76, 0xe6, 0x01, 0xc4, 0x43, 0x90, 0x25,
+	0xcc, 0x2f, 0x6c, 0xb0, 0xd8, 0xfd, 0x49, 0x21, 0x91, 0x18, 0x2b, 0x62, 0xab, 0x13, 0xda, 0x2d,
+	0x75, 0xe4, 0x2f, 0xa0, 0x50, 0xa7, 0xdd, 0xf4, 0x23, 0xec, 0x00, 0x5e, 0x10, 0x0b, 0x40, 0x9c,
+	0x00, 0xea, 0xfb, 0x70, 0x7c, 0x70, 0xae, 0x68, 0x9a, 0x24, 0x66, 0x9d, 0x80, 0x05, 0x36, 0x34,
+	0x10, 0x1d, 0x74, 0x02, 0x88, 0x64, 0xce, 0xa3, 0xad, 0x34, 0x62, 0xa9, 0x94, 0x8d, 0x58, 0x68,
+	0x3f, 0x7d, 0x2e, 0xce, 0xaf, 0xf6, 0xb6, 0x29, 0xae, 0xde, 0x25, 0x56, 0x19, 0x2b, 0xa6, 0x02,
+	0x92, 0x4c, 0xa3, 0x6d, 0x64, 0x50, 0xf5, 0xc7, 0x59, 0xc8, 0x2d, 0x74, 0xd4, 0x7f, 0x5d, 0x43,
+	0x7b, 0x39, 0xcd, 0xbf, 0xe0, 0x84, 0xcb, 0x6c, 0xa3, 0xbb, 0x69, 0xa0, 0x0d, 0xf8, 0x34, 0xb7,
+	0x09, 0xa4, 0x29, 0xc9, 0xfd, 0xa9, 0x1d, 0x39, 0xdb, 0x8b, 0xcf, 0x7a, 0x0e, 0x5b, 0x42, 0xc9,
+	0xde, 0x8f, 0xdd, 0xf7, 0xe4, 0x67, 0x18, 0xc7, 0xe6, 0xa6, 0x67, 0x31, 0x7e, 0x1c, 0xdf, 0xd6,
+	0x92, 0x0e, 0x08, 0xea, 0x7f, 0x1e, 0x0d, 0xf3, 0x47, 0x6e, 0x60, 0x84, 0x87, 0xf2, 0x34, 0xc4,
+	0xd1, 0x62, 0xf7, 0x7b, 0x79, 0x32, 0xbf, 0x50, 0x48, 0x88, 0xa7, 0x20, 0x6f, 0x4f, 0x51, 0x13,
+	0x6e, 0xd8, 0x76, 0xb3, 0xf8, 0x1c, 0xbd, 0x0e, 0xb0, 0x29, 0xa9, 0xbe, 0xa0, 0x9a, 0x13, 0x68,
+	0x6b, 0x10, 0x3d, 0x50, 0x86, 0x2e, 0x49, 0xc7, 0x3a, 0x6d, 0xad, 0xbf, 0xc8, 0xdc, 0x3f, 0x7f,
+	0xeb, 0xeb, 0x06, 0x40, 0xe0, 0x30, 0xc6, 0x1e, 0x43, 0x7b, 0xb3, 0x57, 0x36, 0x52, 0x8e, 0x70,
+	0x77, 0xea, 0xb2, 0x06, 0x08, 0xfa, 0x86, 0x16, 0xdf, 0xb8, 0x14, 0x92, 0x06, 0xbe, 0x2f, 0xa0,
+	0x41, 0x86, 0xb8, 0xa3, 0xbc, 0xb7, 0x2c, 0xa6, 0x12, 0xf7, 0x95, 0x78, 0x5e, 0xae, 0xe8, 0x9c,
+	0x82, 0xfc, 0x90, 0x3a, 0x90, 0x8c, 0x7c, 0xfa, 0x87, 0xb4, 0xa4, 0xea, 0x5c, 0xd8, 0x0c, 0x78,
+	0xbd, 0xd8, 0xc3, 0xab, 0x64, 0xea, 0x89, 0xc9, 0xe4, 0x31, 0x5b, 0x4b, 0xbe, 0x93, 0x73, 0x00,
+	0x73, 0x34, 0x4f, 0x50, 0x8e, 0x98, 0x1d, 0x46, 0x50, 0xc5, 0x61, 0xf5, 0xb4, 0x15, 0xa7, 0xc9,
+	0x27, 0xc7, 0xb3, 0x1d, 0xe2, 0x7b, 0x59, 0xdb, 0x28, 0x50, 0x92, 0x32, 0x29, 0x9e, 0xe9, 0x0c,
+	0x5d, 0xa4, 0xf7, 0xb2, 0x1e, 0xc8, 0x0e, 0x7a, 0xc9, 0x83, 0x3d, 0x6d, 0xaa, 0x76, 0x26, 0xb7,
+	0x6e, 0x2d, 0x53, 0x7b, 0x54, 0xe9, 0xad, 0x3d, 0xfa, 0xa0, 0x96, 0x44, 0xf0, 0xb2, 0xc1, 0x62,
+	0xcf, 0x1c, 0x9f, 0x65, 0xcb, 0x0d, 0x23, 0xa1, 0x41, 0x7b, 0x4a, 0xe4, 0x9d, 0x06, 0xab, 0x5c,
+	0x4d, 0xe0, 0xa4, 0x66, 0x7d, 0xbb, 0xe9, 0x94, 0xc0, 0xa1, 0x78, 0x05, 0xec, 0x24, 0x20, 0x91,
+	0x9c, 0xd2, 0x58, 0xe4, 0x09, 0xbd, 0x0b, 0x15, 0x9f, 0xd2, 0xd0, 0x87, 0xe4, 0xfa, 0x93, 0x8c,
+	0xbf, 0x39, 0x08, 0x2e, 0x38, 0xe2, 0x37, 0xac, 0x65, 0xbb, 0xd9, 0x75, 0xed, 0x12, 0xb0, 0x0a,
+	0xff, 0x97, 0xa5, 0xce, 0xc5, 0x64, 0x80, 0xcd, 0xab, 0x68, 0x07, 0x9d, 0xda, 0xbc, 0xcb, 0x17,
+	0xab, 0x9a, 0xa3, 0x53, 0x4f, 0xba, 0xd4, 0xf9, 0xfe, 0x12, 0x81, 0xee, 0xed, 0x55, 0x38, 0x0d,
+	0x15, 0x92, 0x14, 0xd4, 0x84, 0xac, 0x41, 0x1c, 0x50, 0x0e, 0x73, 0xe3, 0xa8, 0xbf, 0x13, 0x12,
+	0x46, 0x53, 0x04, 0x44, 0x93, 0x20, 0x9a, 0x3a, 0xdd, 0x12, 0x75, 0x74, 0x9f, 0xa9, 0xf4, 0xb2,
+	0xcd, 0x68, 0xc4, 0xab, 0x95, 0xcc, 0x44, 0x5b, 0x79, 0xc5, 0x21, 0xd3, 0x1d, 0x8e, 0x2d, 0x6d,
+	0xfc, 0x32, 0xc2, 0x90, 0x11, 0xe2, 0x4d, 0x54, 0x29, 0x6f, 0xa2, 0x5d, 0x26, 0x53, 0x66, 0x6c,
+	0xa8, 0xf7, 0xa0, 0xbb, 0x03, 0x36, 0x19, 0x52, 0xe4, 0x07, 0xca, 0x93, 0xdf, 0x13, 0x70, 0xd3,
+	0xaa, 0x77, 0x2a, 0x6c, 0xe1, 0xa7, 0xc2, 0x19, 0x70, 0xdf, 0xfc, 0xc2, 0xf1, 0xda, 0xb4, 0x3e,
+	0xc9, 0x5a, 0x15, 0x9f, 0x1d, 0x0e, 0xc4, 0x67, 0x87, 0x6f, 0x30, 0xb7, 0x2e, 0xeb, 0x0e, 0x6a,
+	0xa7, 0x79, 0x60, 0x56, 0xf5, 0xc4, 0x5f, 0xf7, 0x1d, 0x4d, 0x9e, 0x93, 0x34, 0x11, 0x7e, 0x14,
+	0xed, 0xe1, 0x9a, 0x92, 0x0a, 0x67, 0xa3, 0xd1, 0x61, 0x95, 0x14, 0x38, 0x79, 0x47, 0x4a, 0xa2,
+	0x67, 0x3a, 0x81, 0xfe, 0x2b, 0x2c, 0xb8, 0xe9, 0x5d, 0x58, 0x66, 0xc3, 0x71, 0xb9, 0xcc, 0x40,
+	0xfe, 0x0d, 0xf0, 0xfb, 0x48, 0x39, 0x85, 0x1f, 0x66, 0xca, 0xe7, 0x82, 0xe4, 0xab, 0x1b, 0xed,
+	0x71, 0x9b, 0x5d, 0x7a, 0x13, 0x87, 0xb9, 0x12, 0x9a, 0x51, 0x1d, 0x61, 0x8f, 0xa9, 0x33, 0xd1,
+	0xbb, 0xe0, 0x59, 0x15, 0x6c, 0x81, 0x7a, 0x0e, 0xa1, 0x1d, 0x01, 0x7b, 0xe3, 0xb2, 0xf8, 0x9d,
+	0x7f, 0x14, 0x29, 0xd0, 0xb7, 0xdf, 0x6b, 0x93, 0xf3, 0x20, 0xc3, 0xb7, 0xcd, 0x00, 0x26, 0xde,
+	0x50, 0x7d, 0x34, 0x7e, 0x5e, 0x27, 0x8f, 0xf5, 0x59, 0xb8, 0x77, 0x13, 0x6d, 0x2f, 0x67, 0x5d,
+	0xd3, 0x69, 0xd5, 0x19, 0x34, 0x5e, 0x50, 0x06, 0xd7, 0xe7, 0x90, 0x9c, 0x48, 0x9c, 0xd1, 0xd9,
+	0x6e, 0xb7, 0x43, 0xdf, 0xc9, 0x39, 0x05, 0x49, 0x77, 0x9f, 0x6f, 0x87, 0x71, 0x61, 0x2e, 0xeb,
+	0x3e, 0xf5, 0xd3, 0x8f, 0x6a, 0x68, 0x2b, 0x19, 0x0f, 0x7f, 0x54, 0x43, 0xdb, 0x68, 0x42, 0x18,
+	0x3f, 0x28, 0x2f, 0x74, 0x48, 0xa1, 0xfa, 0x55, 0x8f, 0xe4, 0x37, 0xa4, 0x2c, 0xeb, 0x53, 0x6f,
+	0xbc, 0xf5, 0xf7, 0x1f, 0xab, 0x3c, 0x8c, 0x8f, 0xd5, 0x3a, 0xbe, 0xd7, 0xec, 0x5a, 0x61, 0x60,
+	0x39, 0x32, 0x7c, 0x4d, 0xc0, 0x51, 0xc5, 0xbf, 0xa5, 0xa1, 0xa1, 0xb8, 0x26, 0x05, 0x3f, 0x22,
+	0x1f, 0x4b, 0x80, 0xfe, 0x57, 0x9d, 0x2c, 0xda, 0x1c, 0x18, 0x3c, 0x4b, 0x18, 0x7c, 0x02, 0x9f,
+	0x28, 0xc2, 0x60, 0xf2, 0xbf, 0x35, 0x12, 0x00, 0xac, 0xe3, 0xdf, 0xd4, 0xd0, 0x70, 0x4c, 0x74,
+	0xda, 0x75, 0x55, 0xec, 0x0a, 0x90, 0x01, 0x55, 0xec, 0x8a, 0x30, 0xfe, 0xf4, 0x13, 0x84, 0xdd,
+	0x1a, 0x7e, 0xa4, 0x14, 0xbb, 0xf8, 0x33, 0x1a, 0xda, 0xc1, 0x6d, 0x1e, 0x70, 0x4d, 0xa9, 0xa5,
+	0xde, 0x82, 0xfd, 0xea, 0xa3, 0xc5, 0x3b, 0x00, 0xa7, 0xe7, 0x09, 0xa7, 0xa7, 0xf0, 0x13, 0x05,
+	0x2d, 0xcf, 0x08, 0xc4, 0xaa, 0xfd, 0x1d, 0x0d, 0x8d, 0xa4, 0x33, 0x38, 0x2a, 0xb6, 0x85, 0x50,
+	0x7e, 0x2a, 0xb6, 0xc5, 0xa0, 0x7c, 0xfa, 0x13, 0x84, 0xed, 0xe3, 0xb8, 0x56, 0x92, 0x6d, 0xfc,
+	0x65, 0x0d, 0x8d, 0x65, 0x91, 0xed, 0xf0, 0x71, 0xc5, 0xf8, 0x62, 0xfc, 0xbc, 0xea, 0x54, 0x99,
+	0x2e, 0xc0, 0xf4, 0xb3, 0x84, 0xe9, 0x79, 0x3c, 0x5b, 0x6a, 0x56, 0x18, 0x29, 0xad, 0x43, 0xee,
+	0x6b, 0x1d, 0xff, 0x81, 0x86, 0x76, 0xf5, 0x40, 0xe0, 0xe1, 0x29, 0xe5, 0x04, 0x10, 0xc2, 0xec,
+	0x55, 0x1f, 0x2b, 0xd5, 0xa7, 0x9f, 0x79, 0xb3, 0x64, 0x87, 0x06, 0x00, 0xb3, 0x32, 0x80, 0x3d,
+	0xfc, 0x25, 0x0d, 0x8d, 0xa4, 0xef, 0xc6, 0xe6, 0x30, 0x2f, 0xbc, 0xb5, 0x9b, 0xc3, 0xbc, 0xf8,
+	0x0e, 0xaf, 0xfe, 0x0c, 0x61, 0x7e, 0x0e, 0xcf, 0x14, 0x61, 0x3e, 0x7b, 0xdb, 0xb7, 0xb6, 0xc6,
+	0xed, 0x2d, 0xd6, 0xf1, 0x17, 0x35, 0xb4, 0x2b, 0x3d, 0x4c, 0xb4, 0x04, 0xa6, 0x94, 0x33, 0xba,
+	0xb4, 0x28, 0x52, 0x1c, 0x3d, 0xfd, 0x0c, 0x11, 0xe5, 0x24, 0x7e, 0xbc, 0x1f, 0x51, 0xf0, 0x9b,
+	0x1a, 0x1a, 0xe6, 0x31, 0xc8, 0xb0, 0xda, 0x81, 0x08, 0xc0, 0xe5, 0xaa, 0xc7, 0x4b, 0xf4, 0x00,
+	0x9e, 0x2f, 0x12, 0x9e, 0xa7, 0xf1, 0xf9, 0x22, 0x3c, 0xa7, 0xc0, 0xd4, 0x6a, 0x6b, 0xdc, 0x62,
+	0x58, 0x8f, 0xfc, 0xe5, 0x28, 0x3f, 0x42, 0xa4, 0x79, 0xb5, 0x2f, 0x29, 0x29, 0x81, 0x04, 0xe8,
+	0x4e, 0x3f, 0x45, 0x24, 0x78, 0x0c, 0x1f, 0x2f, 0x2d, 0x01, 0xfe, 0x1b, 0x0d, 0xdd, 0x2d, 0x44,
+	0x90, 0xc3, 0x27, 0xe5, 0x7c, 0xa8, 0x90, 0xeb, 0xaa, 0x4f, 0x94, 0xee, 0x07, 0x52, 0x5c, 0x27,
+	0x52, 0x3c, 0x8b, 0x2f, 0x17, 0x9a, 0x3b, 0x40, 0xca, 0x68, 0x50, 0x5a, 0x06, 0x2d, 0xac, 0xcf,
+	0x58, 0xe4, 0x67, 0x91, 0x74, 0x42, 0x18, 0xb3, 0x53, 0x05, 0x17, 0x6a, 0x2f, 0xba, 0x5b, 0xf5,
+	0xa9, 0x7e, 0xba, 0x82, 0x8c, 0x06, 0x91, 0xf1, 0x25, 0xfc, 0x42, 0xd9, 0xf5, 0xc1, 0x1d, 0xca,
+	0xa6, 0x65, 0xcc, 0xac, 0xff, 0x6f, 0x6b, 0x68, 0x5c, 0xc8, 0x42, 0x34, 0x19, 0x4f, 0x15, 0x5c,
+	0xd2, 0xe5, 0x84, 0xce, 0x03, 0xa7, 0xd3, 0x67, 0x89, 0xd0, 0x67, 0xf1, 0xe9, 0x0d, 0x08, 0x8d,
+	0xbf, 0xa9, 0x21, 0xdc, 0x8b, 0xf2, 0x86, 0x15, 0x5e, 0x4a, 0x0a, 0x2c, 0x57, 0x7d, 0xbc, 0x5c,
+	0x27, 0x10, 0x63, 0x81, 0x88, 0xf1, 0x0c, 0xbe, 0x54, 0xe8, 0x23, 0xcf, 0x40, 0xda, 0xec, 0xc0,
+	0x58, 0xf4, 0x7c, 0x9a, 0x32, 0xac, 0xad, 0xf1, 0x49, 0xd1, 0x75, 0xfc, 0x77, 0x1a, 0xda, 0x2b,
+	0x06, 0x4f, 0xc3, 0x4f, 0x28, 0x59, 0x94, 0x83, 0x82, 0x55, 0x9f, 0x2c, 0xdf, 0x11, 0xe4, 0xbb,
+	0x49, 0xe4, 0xbb, 0x86, 0xaf, 0x14, 0x95, 0x8f, 0x33, 0x8f, 0x5c, 0xc6, 0x1f, 0x6b, 0x68, 0x5c,
+	0x06, 0x3e, 0xa6, 0x9a, 0x90, 0x39, 0xe0, 0x67, 0xaa, 0x09, 0x99, 0x87, 0x75, 0xa6, 0xbf, 0x40,
+	0x24, 0xbd, 0x8e, 0x9f, 0x2b, 0x2c, 0xe9, 0x54, 0x31, 0x61, 0xff, 0x5d, 0x43, 0x63, 0x59, 0x14,
+	0x23, 0x55, 0x38, 0x27, 0x41, 0x06, 0x53, 0x85, 0x73, 0x32, 0x80, 0x2e, 0xfd, 0x03, 0x44, 0xa8,
+	0x55, 0x7c, 0xbb, 0x84, 0x50, 0x41, 0x44, 0xc7, 0xa0, 0x18, 0x4c, 0xb5, 0x35, 0x15, 0x1a, 0xd1,
+	0x7a, 0xca, 0xeb, 0xb0, 0x63, 0xe3, 0xf5, 0xda, 0x1a, 0x3b, 0xa4, 0x5e, 0xc7, 0x9f, 0xa8, 0xa0,
+	0x71, 0x19, 0xf2, 0x8f, 0xca, 0xd2, 0x39, 0x38, 0x60, 0x2a, 0x4b, 0xe7, 0xc1, 0x71, 0xe9, 0x1f,
+	0xd6, 0x88, 0x56, 0xfe, 0x8f, 0x86, 0xdf, 0x5f, 0x44, 0x2d, 0x70, 0xf8, 0x4a, 0xef, 0xb3, 0x19,
+	0x3c, 0xb0, 0xd1, 0x86, 0xb5, 0xf3, 0x46, 0x05, 0x1d, 0x54, 0xa1, 0x6a, 0xe1, 0xb3, 0xea, 0x5d,
+	0x47, 0x0e, 0xf2, 0x57, 0xf5, 0x5c, 0xbf, 0xdd, 0x41, 0x53, 0x16, 0x51, 0xd4, 0xff, 0xc2, 0xaf,
+	0x14, 0xd1, 0x93, 0xe9, 0xba, 0x86, 0x60, 0x0a, 0x05, 0x39, 0x5a, 0xc2, 0x9f, 0xac, 0xa0, 0xfb,
+	0x8b, 0xa0, 0x55, 0xe1, 0x79, 0xa5, 0x34, 0x45, 0x21, 0xb6, 0xaa, 0x17, 0x36, 0x4a, 0x06, 0x94,
+	0xf3, 0x5e, 0xa2, 0x9c, 0x26, 0x6e, 0x14, 0x55, 0x8e, 0x7c, 0x22, 0xe5, 0xea, 0xe8, 0x73, 0x1a,
+	0x1a, 0xcd, 0x80, 0x4d, 0xe5, 0xc4, 0xc1, 0x02, 0xd8, 0xaa, 0x9c, 0x38, 0x58, 0x84, 0x64, 0x55,
+	0x2e, 0xa9, 0x11, 0xed, 0xa1, 0x52, 0xd7, 0x23, 0xf1, 0xe7, 0x35, 0x34, 0x92, 0x06, 0xa1, 0xca,
+	0xd9, 0x41, 0x09, 0x81, 0xb1, 0x72, 0x76, 0x50, 0x62, 0xac, 0x2c, 0xfd, 0x34, 0x61, 0xfd, 0x04,
+	0x7e, 0xac, 0x08, 0xeb, 0x19, 0x54, 0x2d, 0xfc, 0x73, 0x0d, 0xdd, 0xa3, 0x04, 0xb0, 0xc2, 0xe7,
+	0x94, 0x3c, 0xe5, 0x22, 0x69, 0x55, 0xcf, 0xf7, 0xdd, 0x1f, 0xe4, 0xbb, 0x46, 0xe4, 0xbb, 0x84,
+	0x2f, 0x14, 0x35, 0x4d, 0xe6, 0xef, 0xe2, 0xd0, 0x6a, 0x2e, 0x23, 0x06, 0xcf, 0xfa, 0xba, 0x86,
+	0xee, 0x16, 0x22, 0x5f, 0xa9, 0xa2, 0x7e, 0x15, 0x9e, 0x96, 0x2a, 0xea, 0x57, 0x42, 0x6c, 0xe9,
+	0x73, 0x44, 0xb4, 0x73, 0xf8, 0x4c, 0x11, 0xd1, 0x52, 0x33, 0x8e, 0xdf, 0x39, 0xfe, 0x9a, 0x86,
+	0x86, 0x62, 0x2c, 0x29, 0x7c, 0x4c, 0xf1, 0xc5, 0xc8, 0x40, 0x5a, 0x55, 0x1f, 0x2a, 0xd4, 0x16,
+	0x98, 0x3d, 0x49, 0x98, 0x7d, 0x14, 0x4f, 0x16, 0xfa, 0x98, 0x90, 0xee, 0x86, 0xe9, 0xba, 0xf8,
+	0x7b, 0x1a, 0x1a, 0xcb, 0xe2, 0x14, 0xe1, 0xc7, 0x8b, 0x25, 0x1d, 0xd3, 0x60, 0x4c, 0xd5, 0x13,
+	0x25, 0x7b, 0x01, 0xe7, 0xaf, 0x12, 0xce, 0x5f, 0xc4, 0xb7, 0xca, 0x25, 0x7b, 0x00, 0x80, 0xa9,
+	0xb6, 0x96, 0xc5, 0xb5, 0x5a, 0xaf, 0xad, 0x71, 0x48, 0x45, 0xeb, 0xf8, 0x4f, 0x34, 0xb4, 0x3b,
+	0x3b, 0x78, 0x64, 0x8a, 0xc7, 0x8b, 0xa5, 0x2a, 0x8b, 0x0b, 0xa9, 0xc0, 0x8e, 0xea, 0x33, 0x2d,
+	0xcb, 0x84, 0xc4, 0xff, 0xa9, 0xa1, 0xaa, 0x1c, 0x38, 0x26, 0xc7, 0x0b, 0xe4, 0x42, 0x1f, 0xe5,
+	0x78, 0x81, 0x7c, 0x10, 0x23, 0xfd, 0x3d, 0x44, 0xbc, 0x97, 0xf1, 0x8b, 0xe5, 0xc4, 0xeb, 0xfd,
+	0x03, 0x54, 0xb0, 0x67, 0xbc, 0xdc, 0xcc, 0x5a, 0xf1, 0xc7, 0x1a, 0xba, 0x47, 0xce, 0x48, 0x64,
+	0xcf, 0x73, 0xc5, 0x2c, 0xd3, 0x8f, 0x12, 0x0a, 0x21, 0x39, 0xe9, 0x97, 0x88, 0x12, 0x66, 0xf0,
+	0xd3, 0x1b, 0x55, 0x02, 0xfe, 0x7f, 0x15, 0x74, 0x28, 0x0f, 0xee, 0x08, 0x4f, 0x97, 0x35, 0x5a,
+	0x0f, 0x16, 0x53, 0x75, 0x66, 0x23, 0x24, 0x40, 0x6a, 0x93, 0x48, 0xfd, 0x0a, 0x7e, 0xa9, 0xe8,
+	0x07, 0x40, 0x28, 0x79, 0x82, 0x5a, 0x54, 0x5b, 0x73, 0x9a, 0x51, 0x7c, 0x1a, 0x23, 0x40, 0xad,
+	0xe3, 0x7f, 0xd2, 0xd0, 0x3e, 0x09, 0x42, 0x0b, 0x56, 0x58, 0xad, 0x10, 0x5a, 0x51, 0xf5, 0xe9,
+	0xfe, 0x09, 0x80, 0x06, 0x6e, 0x10, 0x0d, 0x5c, 0xc5, 0xcf, 0x16, 0x4f, 0x22, 0x08, 0xfe, 0x8a,
+	0x5a, 0x26, 0x5b, 0xf2, 0xf1, 0x0a, 0xba, 0xbf, 0x08, 0x0a, 0x90, 0x2a, 0x1e, 0x2d, 0x81, 0x60,
+	0xa4, 0x8a, 0x47, 0xcb, 0x80, 0x11, 0x95, 0x0b, 0xd6, 0x0b, 0x2a, 0x23, 0xb5, 0x85, 0x89, 0x9c,
+	0xc1, 0x77, 0x35, 0x54, 0x95, 0x70, 0x15, 0x79, 0x82, 0xd3, 0xf9, 0x19, 0x21, 0x29, 0x6a, 0x51,
+	0xf5, 0x4c, 0x7f, 0x9d, 0x41, 0xfc, 0x79, 0x22, 0xfe, 0x79, 0x7c, 0x76, 0x43, 0xe2, 0xe3, 0x2f,
+	0x6a, 0x68, 0x67, 0x0a, 0x16, 0x07, 0x2b, 0x0e, 0xd6, 0x44, 0xa0, 0x41, 0xd5, 0x5a, 0xe1, 0xf6,
+	0xfd, 0x78, 0xaf, 0xd4, 0x9f, 0xf5, 0xcb, 0xa4, 0xfd, 0xf0, 0x17, 0x34, 0x34, 0x96, 0x45, 0x04,
+	0x52, 0xa5, 0x1a, 0x24, 0xe8, 0x42, 0xaa, 0x54, 0x83, 0x0c, 0x70, 0x48, 0x3f, 0x47, 0xa4, 0x78,
+	0x12, 0x9f, 0x2c, 0x2f, 0x05, 0x09, 0x87, 0xfe, 0x59, 0x43, 0x55, 0x39, 0x44, 0x90, 0x6a, 0x66,
+	0xe5, 0x02, 0x15, 0xa9, 0x66, 0x56, 0x3e, 0x2a, 0x91, 0xfe, 0x12, 0x91, 0xec, 0x06, 0xbe, 0x5e,
+	0xd4, 0xcf, 0x4a, 0xf1, 0x82, 0x7a, 0x96, 0xd3, 0xcf, 0xe8, 0x36, 0x43, 0x0e, 0x43, 0x94, 0x13,
+	0x60, 0xe4, 0xa2, 0x1d, 0xe5, 0x04, 0x18, 0xf9, 0xf8, 0x47, 0xfa, 0x55, 0x22, 0xfd, 0x45, 0x3c,
+	0x5f, 0x54, 0x7a, 0x92, 0x07, 0x90, 0x69, 0x00, 0x7f, 0x4d, 0x43, 0xe3, 0x69, 0x9d, 0x27, 0x08,
+	0x34, 0xaa, 0x8d, 0x86, 0x0a, 0xd7, 0x46, 0xb5, 0xd1, 0x50, 0x42, 0xdd, 0x94, 0x9b, 0xb4, 0xbd,
+	0xa0, 0x38, 0xf8, 0xa7, 0x1a, 0x3a, 0xa8, 0x02, 0x93, 0x51, 0x25, 0x70, 0x0a, 0x80, 0xe0, 0xa8,
+	0x12, 0x38, 0x45, 0x30, 0x6c, 0xf4, 0xe7, 0x88, 0x7c, 0x97, 0xf1, 0xc5, 0x22, 0xf2, 0xc5, 0x80,
+	0x0d, 0xb5, 0xb5, 0xf8, 0xbf, 0xeb, 0xb5, 0x14, 0x58, 0x06, 0xfe, 0x60, 0x05, 0xe9, 0x32, 0x3c,
+	0x9b, 0x04, 0x5e, 0x06, 0xcf, 0xe4, 0xf2, 0x9d, 0x8b, 0x86, 0xa3, 0x4a, 0xf1, 0xe5, 0x81, 0x9d,
+	0xe8, 0xaf, 0x10, 0xb9, 0x9f, 0xc7, 0x37, 0x36, 0x41, 0x6e, 0x00, 0xc8, 0x69, 0xc4, 0xc2, 0xfd,
+	0xa9, 0x86, 0x76, 0xd1, 0x7b, 0x71, 0x7c, 0x99, 0xb4, 0x62, 0x7b, 0xa2, 0xc0, 0x3f, 0xa9, 0x9e,
+	0x2c, 0xdb, 0x6d, 0xa3, 0x33, 0xb7, 0x46, 0x41, 0xef, 0xdf, 0xd4, 0xd0, 0x78, 0x82, 0x39, 0x92,
+	0x06, 0xdf, 0xc0, 0x0f, 0x15, 0xc3, 0x29, 0xa1, 0x12, 0x3c, 0x5c, 0x06, 0xd4, 0xa4, 0xdc, 0x67,
+	0xba, 0x19, 0xf5, 0xe7, 0xec, 0x13, 0xb9, 0x16, 0xba, 0xf0, 0x3e, 0x54, 0x41, 0x47, 0x0b, 0xa3,
+	0x1d, 0xe1, 0x67, 0xca, 0x4f, 0x25, 0x19, 0x64, 0xd2, 0x86, 0xa6, 0x65, 0x9f, 0xcb, 0x51, 0x3e,
+	0x15, 0xff, 0x41, 0x43, 0xf7, 0x17, 0x01, 0x68, 0x52, 0xc5, 0xaa, 0x25, 0x00, 0x9e, 0x36, 0x24,
+	0x7c, 0xa9, 0x8d, 0x78, 0x6c, 0xe9, 0xd8, 0xf3, 0xfc, 0x44, 0x43, 0x87, 0xf2, 0xa0, 0x95, 0x54,
+	0x3b, 0xb3, 0x82, 0xe8, 0x52, 0xaa, 0x9d, 0x59, 0x51, 0x64, 0x27, 0xfd, 0x69, 0x22, 0xea, 0x53,
+	0xf8, 0xc9, 0x12, 0x29, 0xa1, 0xb4, 0xb4, 0x3f, 0xd4, 0xd0, 0x01, 0x05, 0x80, 0x0d, 0x56, 0x47,
+	0x34, 0x39, 0x18, 0x39, 0xd5, 0xb3, 0x7d, 0xf6, 0xee, 0xa7, 0x36, 0x25, 0x0a, 0x09, 0xe4, 0xf0,
+	0x39, 0xf8, 0x8f, 0x58, 0x6d, 0x56, 0x82, 0xc0, 0x32, 0x95, 0x1f, 0xad, 0x65, 0x31, 0x67, 0x72,
+	0x32, 0xc4, 0x62, 0xf4, 0x98, 0x72, 0x69, 0xc6, 0xcc, 0x9f, 0xc9, 0xae, 0xad, 0xb1, 0xdc, 0xfc,
+	0x17, 0x34, 0xb4, 0x2b, 0x3d, 0x40, 0x7e, 0x75, 0x4d, 0x69, 0x21, 0xa4, 0x10, 0x38, 0xe5, 0xd2,
+	0xdc, 0x19, 0x21, 0xf0, 0xcf, 0x35, 0xb4, 0xab, 0x07, 0xcd, 0x04, 0xab, 0xd3, 0x89, 0x32, 0x2c,
+	0x1b, 0xd5, 0xa7, 0x4c, 0x05, 0x39, 0xa3, 0xbb, 0x44, 0x82, 0x45, 0xdc, 0x2c, 0x22, 0x01, 0x85,
+	0x58, 0x31, 0xc2, 0x84, 0x4e, 0x6d, 0x8d, 0x47, 0xd0, 0x59, 0x67, 0xc7, 0xaf, 0x14, 0x2d, 0x87,
+	0xa4, 0x33, 0x38, 0x64, 0x9c, 0x75, 0xfc, 0x65, 0x0d, 0xe1, 0x5e, 0x34, 0x18, 0x55, 0xe8, 0xa9,
+	0x02, 0xab, 0x51, 0x85, 0x9e, 0x4a, 0xd8, 0x99, 0x72, 0xd5, 0x69, 0xbd, 0x52, 0x07, 0xf8, 0x5b,
+	0x1a, 0xda, 0x2b, 0xc6, 0x0f, 0x51, 0x15, 0x0a, 0x28, 0x21, 0x4b, 0x54, 0x85, 0x02, 0x6a, 0xa8,
+	0x92, 0x72, 0x05, 0x53, 0x20, 0x4e, 0x7c, 0x49, 0xb6, 0xb6, 0xc6, 0x80, 0x52, 0x48, 0xb1, 0xe6,
+	0xce, 0x14, 0x7c, 0x86, 0x6a, 0x03, 0x2e, 0x02, 0xe1, 0x50, 0x6d, 0xc0, 0x85, 0xb8, 0x1c, 0xfa,
+	0x53, 0x84, 0xf7, 0xc7, 0xf1, 0x54, 0x11, 0xde, 0xd3, 0x7f, 0x09, 0x1e, 0xbf, 0xa5, 0xa1, 0x3d,
+	0x22, 0xc4, 0x19, 0xd5, 0x22, 0x52, 0xe0, 0xdb, 0xa8, 0x16, 0x91, 0x0a, 0xd8, 0x46, 0xbf, 0x42,
+	0x64, 0xb8, 0x80, 0xe7, 0x8a, 0xc8, 0x70, 0x9b, 0x52, 0xa2, 0x50, 0x0a, 0x0c, 0x96, 0x27, 0xe0,
+	0x2a, 0x37, 0xff, 0x43, 0x43, 0x07, 0x55, 0x68, 0x2e, 0xaa, 0x7d, 0x4d, 0x01, 0x70, 0x19, 0xd5,
+	0xbe, 0xa6, 0x08, 0x88, 0x4c, 0xb9, 0x92, 0x29, 0xf8, 0xea, 0xd8, 0x46, 0x5a, 0xec, 0x45, 0xcf,
+	0x8f, 0x16, 0x54, 0xe4, 0xca, 0xb3, 0x40, 0x37, 0xeb, 0xf8, 0x47, 0x1a, 0x1a, 0x97, 0x21, 0xc8,
+	0xa8, 0xea, 0x16, 0x72, 0xa0, 0x6b, 0x54, 0x01, 0x54, 0x1e, 0x60, 0x4d, 0xb9, 0x5a, 0x9c, 0x58,
+	0x68, 0xa7, 0x61, 0xf5, 0x0a, 0x1c, 0xc3, 0xe7, 0xac, 0xe3, 0xbf, 0xd4, 0xd0, 0x5e, 0x31, 0xfa,
+	0x86, 0xca, 0x8d, 0x28, 0x51, 0x3d, 0x54, 0x6e, 0x44, 0x0d, 0xf4, 0x51, 0x6e, 0x7b, 0x90, 0x81,
+	0x04, 0x49, 0x04, 0x24, 0x47, 0x7f, 0x31, 0xec, 0x8d, 0xea, 0xe8, 0x2f, 0x8b, 0x9a, 0xa3, 0x3a,
+	0xfa, 0xeb, 0xc1, 0xd1, 0x29, 0x77, 0xf4, 0xc7, 0xf2, 0xaa, 0x8b, 0x5e, 0x14, 0xdd, 0xed, 0x93,
+	0x80, 0xbc, 0xe0, 0x27, 0x73, 0x36, 0x84, 0x52, 0x80, 0x99, 0xea, 0xa9, 0x3e, 0x7a, 0x82, 0x20,
+	0xb7, 0x88, 0x20, 0x0b, 0xf8, 0x5a, 0xa1, 0x03, 0x57, 0x02, 0xc0, 0xdc, 0xf1, 0x8c, 0xa4, 0x9a,
+	0xcd, 0x64, 0xb7, 0x6e, 0xe0, 0xeb, 0x0b, 0xe7, 0x81, 0xf8, 0xdf, 0x34, 0x74, 0x40, 0x01, 0x21,
+	0xa3, 0x0a, 0x63, 0xf3, 0x61, 0x6c, 0x54, 0x61, 0x6c, 0x01, 0xdc, 0x1a, 0xfd, 0x65, 0x22, 0xf4,
+	0x4d, 0x5c, 0x2f, 0x29, 0x34, 0x5f, 0xf5, 0x25, 0x13, 0xfc, 0xdb, 0x1a, 0xba, 0x5b, 0x08, 0x09,
+	0x83, 0xd5, 0x51, 0x92, 0x14, 0x83, 0x46, 0x15, 0x68, 0x28, 0xb1, 0x67, 0xca, 0x7d, 0x19, 0x00,
+	0xe7, 0xc5, 0xf6, 0xc1, 0x67, 0x90, 0x1a, 0x01, 0xbe, 0x64, 0xe9, 0x6f, 0x35, 0xb4, 0x5f, 0x8a,
+	0x18, 0x83, 0x9f, 0xca, 0xcb, 0x36, 0xca, 0xe1, 0x6c, 0xaa, 0xa7, 0xfb, 0xea, 0x0b, 0x42, 0x5e,
+	0x20, 0x42, 0x3e, 0x8d, 0xcf, 0x15, 0x2e, 0xc6, 0x11, 0x09, 0x1a, 0xe0, 0x3f, 0xd6, 0xd0, 0x58,
+	0x16, 0x61, 0x06, 0x1f, 0xcf, 0x57, 0x7d, 0x06, 0xc8, 0xa6, 0x3a, 0x55, 0xa6, 0x4b, 0x3f, 0xbe,
+	0x2f, 0x85, 0x36, 0xb3, 0xca, 0x5b, 0xe8, 0xab, 0x74, 0xea, 0xf5, 0x82, 0xd5, 0xe4, 0x4c, 0x3d,
+	0x29, 0x04, 0x4e, 0xce, 0xd4, 0x93, 0xa3, 0xe2, 0x94, 0xdb, 0x07, 0x27, 0x56, 0x49, 0x30, 0x74,
+	0xf0, 0xbf, 0x44, 0xc2, 0x88, 0x00, 0x60, 0x94, 0xc2, 0x28, 0x70, 0x6e, 0x94, 0xc2, 0xa8, 0x90,
+	0x66, 0x74, 0x87, 0x08, 0x63, 0x61, 0xb3, 0xd0, 0xae, 0x17, 0x48, 0x45, 0x1b, 0x7a, 0x1e, 0x2d,
+	0xa7, 0xb6, 0x96, 0x01, 0xd9, 0x59, 0xaf, 0xad, 0x65, 0xd1, 0x74, 0xd6, 0xf1, 0x67, 0x35, 0xb4,
+	0x33, 0x05, 0xe4, 0x92, 0x37, 0x05, 0x05, 0xc0, 0x32, 0x79, 0x53, 0x50, 0x84, 0x35, 0x53, 0x2e,
+	0x12, 0x4e, 0xa3, 0xd2, 0xe0, 0x3f, 0xd3, 0xd0, 0xae, 0x1e, 0xac, 0x98, 0x9c, 0xbd, 0xa4, 0x0c,
+	0x7f, 0x26, 0x67, 0x2f, 0x29, 0x85, 0xa4, 0x29, 0xb7, 0xab, 0x12, 0x80, 0xd7, 0xe0, 0x3f, 0xd7,
+	0x52, 0x7f, 0x7b, 0x20, 0x46, 0xfb, 0x51, 0x09, 0xa2, 0x40, 0x10, 0xaa, 0x9e, 0x2c, 0xdb, 0x0d,
+	0x04, 0x99, 0x21, 0x82, 0x9c, 0xc1, 0x4f, 0x95, 0xcc, 0xef, 0x1a, 0x66, 0x44, 0xca, 0x70, 0x23,
+	0x96, 0xbf, 0xad, 0xa1, 0x3d, 0x22, 0x40, 0x1c, 0x95, 0x2c, 0x0a, 0x14, 0x1e, 0x95, 0x2c, 0x2a,
+	0xdc, 0x9d, 0x72, 0x69, 0x4f, 0x1b, 0x28, 0x19, 0xa9, 0xa4, 0x75, 0xfa, 0x88, 0xfe, 0x6d, 0x0d,
+	0x55, 0xe5, 0xc8, 0x3a, 0xca, 0x53, 0xe8, 0x3c, 0xe8, 0x1e, 0xe5, 0x29, 0x74, 0x2e, 0x98, 0x8f,
+	0x7e, 0x99, 0x88, 0x3a, 0x8b, 0xa7, 0x0b, 0x79, 0x3c, 0x15, 0x46, 0x21, 0xfe, 0x9e, 0x86, 0xf6,
+	0x93, 0x3b, 0xbc, 0x22, 0xcc, 0x1d, 0x65, 0x4d, 0x9e, 0x02, 0xea, 0x47, 0x59, 0x93, 0xa7, 0x02,
+	0xf7, 0x29, 0x77, 0x13, 0x47, 0x2c, 0x52, 0xd6, 0x8c, 0x9f, 0xd7, 0xd0, 0x28, 0x99, 0xf4, 0x09,
+	0x62, 0x0b, 0x56, 0x9c, 0x26, 0xf4, 0x82, 0xc2, 0x54, 0x1f, 0x29, 0xd8, 0xba, 0x9f, 0x28, 0x01,
+	0x6e, 0x03, 0x12, 0x24, 0x98, 0x0c, 0xe3, 0xdf, 0xd1, 0xd0, 0xb8, 0x0c, 0x8e, 0x47, 0x79, 0x7f,
+	0x41, 0x8d, 0x19, 0xa4, 0xbc, 0xbf, 0x90, 0x83, 0xfe, 0x53, 0x4e, 0xb6, 0xd4, 0x51, 0xe6, 0x6d,
+	0x27, 0x5c, 0x8e, 0x93, 0x00, 0xd1, 0xde, 0xe4, 0x6e, 0x21, 0x9c, 0x8c, 0xf2, 0x74, 0x56, 0x01,
+	0x90, 0xa3, 0x3c, 0x9d, 0x55, 0xa1, 0xdf, 0xe8, 0xef, 0x26, 0x22, 0xdd, 0xc2, 0x37, 0xcb, 0x5f,
+	0x3e, 0x31, 0x18, 0x9a, 0x4c, 0x6f, 0x65, 0x35, 0xcb, 0xdb, 0xfe, 0xbe, 0x86, 0x46, 0xd2, 0xd8,
+	0x2e, 0x39, 0x99, 0x67, 0x21, 0xec, 0x4c, 0x4e, 0xe6, 0x59, 0x8c, 0x3c, 0x53, 0x2e, 0x30, 0x6a,
+	0x02, 0x0d, 0x83, 0x22, 0xcf, 0xd4, 0xd6, 0xa2, 0x28, 0xef, 0x9b, 0x1a, 0xda, 0x2b, 0x46, 0xd2,
+	0x51, 0x5e, 0x13, 0x52, 0x21, 0xfd, 0x28, 0xaf, 0x09, 0x29, 0xb1, 0x7f, 0x4a, 0x66, 0xd2, 0x19,
+	0x2d, 0xa8, 0xfe, 0x88, 0x81, 0x7f, 0xfe, 0x55, 0x43, 0x7b, 0xc5, 0x20, 0x34, 0x39, 0x1b, 0x0b,
+	0x25, 0xd4, 0x4e, 0xce, 0xc6, 0x42, 0x8d, 0x9c, 0x53, 0xae, 0xc8, 0x2e, 0xb6, 0xd4, 0xb2, 0xc7,
+	0xd0, 0x6f, 0x59, 0xe1, 0x87, 0xb4, 0xaa, 0x8a, 0x5c, 0xcf, 0xdd, 0xb9, 0xe0, 0xcd, 0xce, 0xd9,
+	0xae, 0xbd, 0x44, 0xf1, 0x3e, 0x26, 0x95, 0x2b, 0x26, 0x69, 0x58, 0x20, 0xe3, 0x99, 0x69, 0xdf,
+	0x4f, 0xc9, 0x51, 0xb4, 0x80, 0x9a, 0x31, 0x8d, 0x0c, 0xf3, 0x5f, 0xd5, 0xd0, 0xae, 0x1e, 0xe4,
+	0x1e, 0xd5, 0x42, 0x92, 0x21, 0x05, 0xa9, 0x16, 0x92, 0x14, 0x1a, 0xa8, 0xe4, 0xe6, 0x36, 0x21,
+	0x63, 0x50, 0xec, 0xa0, 0x8c, 0x30, 0x51, 0xc0, 0x24, 0x82, 0xf8, 0x51, 0x05, 0x4c, 0x0a, 0x64,
+	0x21, 0x55, 0xc0, 0xa4, 0x42, 0x12, 0x2a, 0x17, 0x30, 0xf1, 0x52, 0xc5, 0xe8, 0x31, 0x19, 0xc1,
+	0xde, 0x4c, 0x5b, 0x09, 0xc0, 0x05, 0x8b, 0x59, 0x29, 0x05, 0x2f, 0x54, 0xd0, 0x4a, 0x69, 0xc4,
+	0xa1, 0x72, 0xc5, 0x0a, 0xbc, 0x3c, 0x34, 0x42, 0xca, 0x4e, 0x32, 0x0a, 0x0c, 0x54, 0x90, 0xfd,
+	0x14, 0x12, 0x51, 0x41, 0xf6, 0xd3, 0xc8, 0x43, 0xfd, 0x4f, 0xb2, 0x80, 0xd0, 0xc9, 0xd8, 0xe2,
+	0x3b, 0x1a, 0xda, 0x2b, 0xc6, 0xdc, 0x51, 0x79, 0x6e, 0x25, 0xc8, 0x8f, 0xca, 0x73, 0xab, 0xe1,
+	0x7d, 0x36, 0xb0, 0x80, 0x12, 0x62, 0xc9, 0x59, 0xe8, 0x47, 0x2a, 0x68, 0xbf, 0x14, 0x33, 0x47,
+	0xe5, 0xc4, 0xf3, 0xf0, 0x7f, 0x54, 0x4e, 0x3c, 0x17, 0xa4, 0x47, 0xef, 0x12, 0x21, 0x3d, 0xdc,
+	0xea, 0x73, 0x3d, 0x01, 0xbd, 0xec, 0x25, 0xeb, 0x54, 0x3c, 0x51, 0x5b, 0xcb, 0x40, 0x0b, 0xad,
+	0xe3, 0xb7, 0x34, 0xb4, 0x5b, 0x80, 0xc2, 0xa3, 0xba, 0xff, 0x20, 0x47, 0xfe, 0x51, 0xdd, 0x7f,
+	0x50, 0x40, 0xfd, 0x94, 0xf3, 0x25, 0xd1, 0xb6, 0xd1, 0xb0, 0x22, 0x4a, 0x86, 0x1f, 0x93, 0x4a,
+	0x8b, 0x3d, 0xf3, 0xdc, 0x57, 0xde, 0x9e, 0xd0, 0xbe, 0xf1, 0xf6, 0x84, 0xf6, 0xfd, 0xb7, 0x27,
+	0xb4, 0x5f, 0xfa, 0xc1, 0xc4, 0x5d, 0xdf, 0xf8, 0xc1, 0xc4, 0x5d, 0x7f, 0xf5, 0x83, 0x89, 0xbb,
+	0x5e, 0x3e, 0xb1, 0xe4, 0x84, 0xcb, 0xdd, 0xc6, 0xa4, 0xe5, 0x29, 0x14, 0x7d, 0x87, 0xbf, 0x75,
+	0xb5, 0xda, 0xb1, 0x83, 0xc6, 0xb6, 0x8e, 0xef, 0x85, 0xde, 0x63, 0xff, 0x15, 0x00, 0x00, 0xff,
+	0xff, 0x92, 0xbc, 0xd2, 0x69, 0xbb, 0x9d, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// QueryClient is the client API for Query service.
+//
+// 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 {
+	// Parameters queries the parameters of the module.
+	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+	// Queries a list of Inference items.
+	Inference(ctx context.Context, in *QueryGetInferenceRequest, opts ...grpc.CallOption) (*QueryGetInferenceResponse, error)
+	InferenceAll(ctx context.Context, in *QueryAllInferenceRequest, opts ...grpc.CallOption) (*QueryAllInferenceResponse, error)
+	// Queries a list of Participant items.
+	Participant(ctx context.Context, in *QueryGetParticipantRequest, opts ...grpc.CallOption) (*QueryGetParticipantResponse, error)
+	ParticipantAll(ctx context.Context, in *QueryAllParticipantRequest, opts ...grpc.CallOption) (*QueryAllParticipantResponse, error)
+	// Queries account public key and balance by address.
+	AccountByAddress(ctx context.Context, in *QueryAccountByAddressRequest, opts ...grpc.CallOption) (*QueryAccountByAddressResponse, error)
+	// Queries a list of GetRandomExecutor items.
+	GetRandomExecutor(ctx context.Context, in *QueryGetRandomExecutorRequest, opts ...grpc.CallOption) (*QueryGetRandomExecutorResponse, error)
+	// Queries a list of EpochGroupData items.
+	EpochGroupData(ctx context.Context, in *QueryGetEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupDataResponse, error)
+	EpochGroupDataAll(ctx context.Context, in *QueryAllEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupDataResponse, error)
+	// Queries a list of SettleAmount items.
+	SettleAmount(ctx context.Context, in *QueryGetSettleAmountRequest, opts ...grpc.CallOption) (*QueryGetSettleAmountResponse, error)
+	SettleAmountAll(ctx context.Context, in *QueryAllSettleAmountRequest, opts ...grpc.CallOption) (*QueryAllSettleAmountResponse, error)
+	EstimateBitcoinReward(ctx context.Context, in *QueryEstimateBitcoinRewardRequest, opts ...grpc.CallOption) (*QueryEstimateBitcoinRewardResponse, error)
+	// Queries a list of EpochGroupValidations items.
+	EpochGroupValidations(ctx context.Context, in *QueryGetEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupValidationsResponse, error)
+	EpochGroupValidationsAll(ctx context.Context, in *QueryAllEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupValidationsResponse, error)
+	// Queries a list of PocBatchesForStage items.
+	PocBatchesForStage(ctx context.Context, in *QueryPocBatchesForStageRequest, opts ...grpc.CallOption) (*QueryPocBatchesForStageResponse, error)
+	// Queries a list of PocValidationsForStage items.
+	PocValidationsForStage(ctx context.Context, in *QueryPocValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocValidationsForStageResponse, error)
+	// PoC v2 validation queries
+	PocV2ValidationsForStage(ctx context.Context, in *QueryPocV2ValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocV2ValidationsForStageResponse, error)
+	// PoC v2 off-chain commit queries
+	PoCV2StoreCommit(ctx context.Context, in *QueryPoCV2StoreCommitRequest, opts ...grpc.CallOption) (*QueryPoCV2StoreCommitResponse, error)
+	MLNodeWeightDistribution(ctx context.Context, in *QueryMLNodeWeightDistributionRequest, opts ...grpc.CallOption) (*QueryMLNodeWeightDistributionResponse, error)
+	AllPoCV2StoreCommitsForStage(ctx context.Context, in *QueryAllPoCV2StoreCommitsForStageRequest, opts ...grpc.CallOption) (*QueryAllPoCV2StoreCommitsForStageResponse, error)
+	AllMLNodeWeightDistributionsForStage(ctx context.Context, in *QueryAllMLNodeWeightDistributionsForStageRequest, opts ...grpc.CallOption) (*QueryAllMLNodeWeightDistributionsForStageResponse, error)
+	// Queries a list of GetCurrentEpoch items.
+	GetCurrentEpoch(ctx context.Context, in *QueryGetCurrentEpochRequest, opts ...grpc.CallOption) (*QueryGetCurrentEpochResponse, error)
+	// Queries a TokenomicsData by index.
+	TokenomicsData(ctx context.Context, in *QueryGetTokenomicsDataRequest, opts ...grpc.CallOption) (*QueryGetTokenomicsDataResponse, error)
+	// Queries a list of GetUnitOfComputePriceProposal items.
+	GetUnitOfComputePriceProposal(ctx context.Context, in *QueryGetUnitOfComputePriceProposalRequest, opts ...grpc.CallOption) (*QueryGetUnitOfComputePriceProposalResponse, error)
+	// Queries a list of CurrentEpochGroupData items.
+	CurrentEpochGroupData(ctx context.Context, in *QueryCurrentEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryCurrentEpochGroupDataResponse, error)
+	// Queries a list of ModelsAll items.
+	ModelsAll(ctx context.Context, in *QueryModelsAllRequest, opts ...grpc.CallOption) (*QueryModelsAllResponse, error)
+	// Queries a list of InferenceTimeout items.
+	InferenceTimeout(ctx context.Context, in *QueryGetInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryGetInferenceTimeoutResponse, error)
+	InferenceTimeoutAll(ctx context.Context, in *QueryAllInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryAllInferenceTimeoutResponse, error)
+	// BE CAREFUL, epoch_id in the request body meand epoch_group_id!!
+	InferenceValidationDetails(ctx context.Context, in *QueryGetInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationDetailsResponse, error)
+	// Queries a list of InferenceValidationDetails items.
+	InferenceValidationDetailsAll(ctx context.Context, in *QueryAllInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryAllInferenceValidationDetailsResponse, error)
+	// Queries a list of GetInferenceValidationParameters items.
+	GetInferenceValidationParameters(ctx context.Context, in *QueryGetInferenceValidationParametersRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationParametersResponse, error)
+	// Queries a list of EpochPerformanceSummary items.
+	// Returns all EpochPerformanceSummary records for a specific epoch index.
+	EpochPerformanceSummary(ctx context.Context, in *QueryEpochPerformanceSummaryByEpochRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByEpochResponse, error)
+	// Returns a single EpochPerformanceSummary record for a specific epoch index and participant.
+	EpochPerformanceSummaryByParticipant(ctx context.Context, in *QueryEpochPerformanceSummaryByParticipantRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByParticipantResponse, error)
+	EpochPerformanceSummaryAll(ctx context.Context, in *QueryAllEpochPerformanceSummaryRequest, opts ...grpc.CallOption) (*QueryAllEpochPerformanceSummaryResponse, error)
+	// Queries a list of HardwareNodes items.
+	HardwareNodes(ctx context.Context, in *QueryHardwareNodesRequest, opts ...grpc.CallOption) (*QueryHardwareNodesResponse, error)
+	// Queries a list of HardwareNodesAll items.
+	HardwareNodesAll(ctx context.Context, in *QueryHardwareNodesAllRequest, opts ...grpc.CallOption) (*QueryHardwareNodesAllResponse, error)
+	// Queries a list of GetParticipantCurrentStats items.
+	GetParticipantCurrentStats(ctx context.Context, in *QueryGetParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetParticipantCurrentStatsResponse, error)
+	// Queries a list of GetAllParticipantCurrentStats items.
+	GetAllParticipantCurrentStats(ctx context.Context, in *QueryGetAllParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetAllParticipantCurrentStatsResponse, error)
+	GetParticipantsFullStats(ctx context.Context, in *QueryParticipantsFullStatsRequest, opts ...grpc.CallOption) (*QueryParticipantsFullStatsResponse, error)
+	StatsByTimePeriodByDeveloper(ctx context.Context, in *QueryStatsByTimePeriodByDeveloperRequest, opts ...grpc.CallOption) (*QueryStatsByTimePeriodByDeveloperResponse, error)
+	StatsByDeveloperAndEpochsBackwards(ctx context.Context, in *QueryStatsByDeveloperAndEpochBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error)
+	CountParticipants(ctx context.Context, in *QueryCountAllParticipantsRequest, opts ...grpc.CallOption) (*QueryCountAllParticipantsResponse, error)
+	DebugStatsDeveloperStats(ctx context.Context, in *QueryDebugStatsRequest, opts ...grpc.CallOption) (*QueryDebugStatsResponse, error)
+	InferencesAndTokensStatsByEpochsBackwards(ctx context.Context, in *QueryInferencesAndTokensStatsByEpochsBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error)
+	InferencesAndTokensStatsByTimePeriod(ctx context.Context, in *QueryInferencesAndTokensStatsByTimePeriodRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error)
+	InferencesAndTokensStatsByModels(ctx context.Context, in *QueryInferencesAndTokensStatsByModelsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsByModelsResponse, error)
+	// Queries a list of GetMinimumValidationAverage items.
+	GetMinimumValidationAverage(ctx context.Context, in *QueryGetMinimumValidationAverageRequest, opts ...grpc.CallOption) (*QueryGetMinimumValidationAverageResponse, error)
+	// Queries a list of PartialUpgrade items.
+	PartialUpgrade(ctx context.Context, in *QueryGetPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryGetPartialUpgradeResponse, error)
+	PartialUpgradeAll(ctx context.Context, in *QueryAllPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryAllPartialUpgradeResponse, error)
+	// Queries a bridge transaction by its composite key
+	BridgeTransaction(ctx context.Context, in *QueryGetBridgeTransactionRequest, opts ...grpc.CallOption) (*QueryGetBridgeTransactionResponse, error)
+	// Queries all bridge transactions
+	BridgeTransactions(ctx context.Context, in *QueryAllBridgeTransactionsRequest, opts ...grpc.CallOption) (*QueryAllBridgeTransactionsResponse, error)
+	// Queries bridge addresses by chain
+	BridgeAddressesByChain(ctx context.Context, in *QueryBridgeAddressesByChainRequest, opts ...grpc.CallOption) (*QueryBridgeAddressesByChainResponse, error)
+	// Queries the singleton liquidity pool
+	LiquidityPool(ctx context.Context, in *QueryLiquidityPoolRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error)
+	// Queries all wrapped token balances for a specific address
+	WrappedTokenBalances(ctx context.Context, in *QueryWrappedTokenBalancesRequest, opts ...grpc.CallOption) (*QueryWrappedTokenBalancesResponse, error)
+	// Validates a wrapped token for trading through liquidity pools
+	ValidateWrappedTokenForTrade(ctx context.Context, in *QueryValidateWrappedTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateWrappedTokenForTradeResponse, error)
+	// Validates an IBC token for trading through liquidity pools
+	ValidateIbcTokenForTrade(ctx context.Context, in *QueryValidateIbcTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateIbcTokenForTradeResponse, error)
+	// Queries all approved bridge tokens for trading
+	ApprovedTokensForTrade(ctx context.Context, in *QueryApprovedTokensForTradeRequest, opts ...grpc.CallOption) (*QueryApprovedTokensForTradeResponse, error)
+	// Queries a list of EpochInfo items.
+	EpochInfo(ctx context.Context, in *QueryEpochInfoRequest, opts ...grpc.CallOption) (*QueryEpochInfoResponse, error)
+	// Queries a list of CountPoCbatchesAtHeight items.
+	CountPoCbatchesAtHeight(ctx context.Context, in *QueryCountPoCbatchesAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCbatchesAtHeightResponse, error)
+	// Queries a list of CountPoCvalidationsAtHeight items.
+	CountPoCvalidationsAtHeight(ctx context.Context, in *QueryCountPoCvalidationsAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCvalidationsAtHeightResponse, error)
+	// Dynamic pricing queries (Task 7.1)
+	GetModelPerTokenPrice(ctx context.Context, in *QueryGetModelPerTokenPriceRequest, opts ...grpc.CallOption) (*QueryGetModelPerTokenPriceResponse, error)
+	GetAllModelPerTokenPrices(ctx context.Context, in *QueryGetAllModelPerTokenPricesRequest, opts ...grpc.CallOption) (*QueryGetAllModelPerTokenPricesResponse, error)
+	GetModelCapacity(ctx context.Context, in *QueryGetModelCapacityRequest, opts ...grpc.CallOption) (*QueryGetModelCapacityResponse, error)
+	GetAllModelCapacities(ctx context.Context, in *QueryGetAllModelCapacitiesRequest, opts ...grpc.CallOption) (*QueryGetAllModelCapacitiesResponse, error)
+	// Queries all authz grantees with specific message type for an account
+	GranteesByMessageType(ctx context.Context, in *QueryGranteesByMessageTypeRequest, opts ...grpc.CallOption) (*QueryGranteesByMessageTypeResponse, error)
+	// Queries the current MLNode version.
+	MLNodeVersion(ctx context.Context, in *QueryGetMLNodeVersionRequest, opts ...grpc.CallOption) (*QueryGetMLNodeVersionResponse, error)
+	// Queries the most recent applied upgrade height.
+	LastUpgradeHeight(ctx context.Context, in *QueryGetLastUpgradeHeightRequest, opts ...grpc.CallOption) (*QueryGetLastUpgradeHeightResponse, error)
+	// Queries the participant allowlist.
+	ParticipantAllowList(ctx context.Context, in *QueryParticipantAllowListRequest, opts ...grpc.CallOption) (*QueryParticipantAllowListResponse, error)
+	// Queries the list of excluded participants for an epoch (0 = current epoch).
+	ExcludedParticipants(ctx context.Context, in *QueryExcludedParticipantsRequest, opts ...grpc.CallOption) (*QueryExcludedParticipantsResponse, error)
+	// Queries the currently active confirmation PoC event.
+	ActiveConfirmationPoCEvent(ctx context.Context, in *QueryActiveConfirmationPoCEventRequest, opts ...grpc.CallOption) (*QueryActiveConfirmationPoCEventResponse, error)
+	// Queries confirmation PoC events for a specific epoch.
+	ListConfirmationPoCEvents(ctx context.Context, in *QueryConfirmationPoCEventsRequest, opts ...grpc.CallOption) (*QueryConfirmationPoCEventsResponse, error)
+	// Queries random seeds for a specific epoch.
+	ListRandomSeeds(ctx context.Context, in *QueryRandomSeedsRequest, opts ...grpc.CallOption) (*QueryRandomSeedsResponse, error)
+	ParticipantsWithBalances(ctx context.Context, in *QueryParticipantsWithBalancesRequest, opts ...grpc.CallOption) (*QueryParticipantsWithBalancesResponse, error)
+	// Queries PoC validation snapshot for deterministic sampling synchronization.
+	PoCValidationSnapshot(ctx context.Context, in *QueryPoCValidationSnapshotRequest, opts ...grpc.CallOption) (*QueryPoCValidationSnapshotResponse, error)
+	DevshardEscrow(ctx context.Context, in *QueryGetDevshardEscrowRequest, opts ...grpc.CallOption) (*QueryGetDevshardEscrowResponse, error)
+	// Queries preserved nodes snapshot for the active PoC episode.
+	PreservedNodesSnapshot(ctx context.Context, in *QueryPreservedNodesSnapshotRequest, opts ...grpc.CallOption) (*QueryPreservedNodesSnapshotResponse, error)
+	DevshardHostEpochStats(ctx context.Context, in *QueryGetDevshardHostEpochStatsRequest, opts ...grpc.CallOption) (*QueryGetDevshardHostEpochStatsResponse, error)
+	PoCDelegation(ctx context.Context, in *QueryPoCDelegationRequest, opts ...grpc.CallOption) (*QueryPoCDelegationResponse, error)
+	// Queries the maintenance credit balance for a participant.
+	MaintenanceCredit(ctx context.Context, in *QueryMaintenanceCreditRequest, opts ...grpc.CallOption) (*QueryMaintenanceCreditResponse, error)
+	// Queries scheduled maintenance windows for a participant.
+	MaintenanceScheduled(ctx context.Context, in *QueryMaintenanceScheduledRequest, opts ...grpc.CallOption) (*QueryMaintenanceScheduledResponse, error)
+	// Queries all currently active maintenance windows.
+	MaintenanceActive(ctx context.Context, in *QueryMaintenanceActiveRequest, opts ...grpc.CallOption) (*QueryMaintenanceActiveResponse, error)
+	// Queries the full maintenance status for a participant at the current height.
+	MaintenanceStatus(ctx context.Context, in *QueryMaintenanceStatusRequest, opts ...grpc.CallOption) (*QueryMaintenanceStatusResponse, error)
+	// Queries the concurrent reserved participant count and power at a given height.
+	MaintenanceConcurrency(ctx context.Context, in *QueryMaintenanceConcurrencyRequest, opts ...grpc.CallOption) (*QueryMaintenanceConcurrencyResponse, error)
+	// Queries whether a proposed maintenance window is schedulable.
+	MaintenanceSchedulability(ctx context.Context, in *QueryMaintenanceSchedulabilityRequest, opts ...grpc.CallOption) (*QueryMaintenanceSchedulabilityResponse, error)
+	// Lists the scheduled per-epoch claim recipient overrides for a participant.
+	ListClaimRecipients(ctx context.Context, in *QueryListClaimRecipientsRequest, opts ...grpc.CallOption) (*QueryListClaimRecipientsResponse, error)
+}
+
+type queryClient struct {
+	cc grpc1.ClientConn
+}
+
+func NewQueryClient(cc grpc1.ClientConn) QueryClient {
+	return &queryClient{cc}
+}
+
+func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
+	out := new(QueryParamsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/Params", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
 	return out, nil
 }
 
-func (c *queryClient) PartialUpgradeAll(ctx context.Context, in *QueryAllPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryAllPartialUpgradeResponse, error) {
-	out := new(QueryAllPartialUpgradeResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PartialUpgradeAll", in, out, opts...)
+func (c *queryClient) Inference(ctx context.Context, in *QueryGetInferenceRequest, opts ...grpc.CallOption) (*QueryGetInferenceResponse, error) {
+	out := new(QueryGetInferenceResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/Inference", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) BridgeTransaction(ctx context.Context, in *QueryGetBridgeTransactionRequest, opts ...grpc.CallOption) (*QueryGetBridgeTransactionResponse, error) {
-	out := new(QueryGetBridgeTransactionResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/BridgeTransaction", in, out, opts...)
+func (c *queryClient) InferenceAll(ctx context.Context, in *QueryAllInferenceRequest, opts ...grpc.CallOption) (*QueryAllInferenceResponse, error) {
+	out := new(QueryAllInferenceResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) BridgeTransactions(ctx context.Context, in *QueryAllBridgeTransactionsRequest, opts ...grpc.CallOption) (*QueryAllBridgeTransactionsResponse, error) {
-	out := new(QueryAllBridgeTransactionsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/BridgeTransactions", in, out, opts...)
+func (c *queryClient) Participant(ctx context.Context, in *QueryGetParticipantRequest, opts ...grpc.CallOption) (*QueryGetParticipantResponse, error) {
+	out := new(QueryGetParticipantResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/Participant", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) BridgeAddressesByChain(ctx context.Context, in *QueryBridgeAddressesByChainRequest, opts ...grpc.CallOption) (*QueryBridgeAddressesByChainResponse, error) {
-	out := new(QueryBridgeAddressesByChainResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/BridgeAddressesByChain", in, out, opts...)
+func (c *queryClient) ParticipantAll(ctx context.Context, in *QueryAllParticipantRequest, opts ...grpc.CallOption) (*QueryAllParticipantResponse, error) {
+	out := new(QueryAllParticipantResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ParticipantAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) LiquidityPool(ctx context.Context, in *QueryLiquidityPoolRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error) {
-	out := new(QueryLiquidityPoolResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/LiquidityPool", in, out, opts...)
+func (c *queryClient) AccountByAddress(ctx context.Context, in *QueryAccountByAddressRequest, opts ...grpc.CallOption) (*QueryAccountByAddressResponse, error) {
+	out := new(QueryAccountByAddressResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/AccountByAddress", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) WrappedTokenBalances(ctx context.Context, in *QueryWrappedTokenBalancesRequest, opts ...grpc.CallOption) (*QueryWrappedTokenBalancesResponse, error) {
-	out := new(QueryWrappedTokenBalancesResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/WrappedTokenBalances", in, out, opts...)
+func (c *queryClient) GetRandomExecutor(ctx context.Context, in *QueryGetRandomExecutorRequest, opts ...grpc.CallOption) (*QueryGetRandomExecutorResponse, error) {
+	out := new(QueryGetRandomExecutorResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetRandomExecutor", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ValidateWrappedTokenForTrade(ctx context.Context, in *QueryValidateWrappedTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateWrappedTokenForTradeResponse, error) {
-	out := new(QueryValidateWrappedTokenForTradeResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ValidateWrappedTokenForTrade", in, out, opts...)
+func (c *queryClient) EpochGroupData(ctx context.Context, in *QueryGetEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupDataResponse, error) {
+	out := new(QueryGetEpochGroupDataResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupData", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ValidateIbcTokenForTrade(ctx context.Context, in *QueryValidateIbcTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateIbcTokenForTradeResponse, error) {
-	out := new(QueryValidateIbcTokenForTradeResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ValidateIbcTokenForTrade", in, out, opts...)
+func (c *queryClient) EpochGroupDataAll(ctx context.Context, in *QueryAllEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupDataResponse, error) {
+	out := new(QueryAllEpochGroupDataResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupDataAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ApprovedTokensForTrade(ctx context.Context, in *QueryApprovedTokensForTradeRequest, opts ...grpc.CallOption) (*QueryApprovedTokensForTradeResponse, error) {
-	out := new(QueryApprovedTokensForTradeResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ApprovedTokensForTrade", in, out, opts...)
+func (c *queryClient) SettleAmount(ctx context.Context, in *QueryGetSettleAmountRequest, opts ...grpc.CallOption) (*QueryGetSettleAmountResponse, error) {
+	out := new(QueryGetSettleAmountResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/SettleAmount", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) EpochInfo(ctx context.Context, in *QueryEpochInfoRequest, opts ...grpc.CallOption) (*QueryEpochInfoResponse, error) {
-	out := new(QueryEpochInfoResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochInfo", in, out, opts...)
+func (c *queryClient) SettleAmountAll(ctx context.Context, in *QueryAllSettleAmountRequest, opts ...grpc.CallOption) (*QueryAllSettleAmountResponse, error) {
+	out := new(QueryAllSettleAmountResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/SettleAmountAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) CountPoCbatchesAtHeight(ctx context.Context, in *QueryCountPoCbatchesAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCbatchesAtHeightResponse, error) {
-	out := new(QueryCountPoCbatchesAtHeightResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/CountPoCbatchesAtHeight", in, out, opts...)
+func (c *queryClient) EstimateBitcoinReward(ctx context.Context, in *QueryEstimateBitcoinRewardRequest, opts ...grpc.CallOption) (*QueryEstimateBitcoinRewardResponse, error) {
+	out := new(QueryEstimateBitcoinRewardResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EstimateBitcoinReward", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) CountPoCvalidationsAtHeight(ctx context.Context, in *QueryCountPoCvalidationsAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCvalidationsAtHeightResponse, error) {
-	out := new(QueryCountPoCvalidationsAtHeightResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/CountPoCvalidationsAtHeight", in, out, opts...)
+func (c *queryClient) EpochGroupValidations(ctx context.Context, in *QueryGetEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryGetEpochGroupValidationsResponse, error) {
+	out := new(QueryGetEpochGroupValidationsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupValidations", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) GetModelPerTokenPrice(ctx context.Context, in *QueryGetModelPerTokenPriceRequest, opts ...grpc.CallOption) (*QueryGetModelPerTokenPriceResponse, error) {
-	out := new(QueryGetModelPerTokenPriceResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetModelPerTokenPrice", in, out, opts...)
+func (c *queryClient) EpochGroupValidationsAll(ctx context.Context, in *QueryAllEpochGroupValidationsRequest, opts ...grpc.CallOption) (*QueryAllEpochGroupValidationsResponse, error) {
+	out := new(QueryAllEpochGroupValidationsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochGroupValidationsAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) GetAllModelPerTokenPrices(ctx context.Context, in *QueryGetAllModelPerTokenPricesRequest, opts ...grpc.CallOption) (*QueryGetAllModelPerTokenPricesResponse, error) {
-	out := new(QueryGetAllModelPerTokenPricesResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetAllModelPerTokenPrices", in, out, opts...)
+func (c *queryClient) PocBatchesForStage(ctx context.Context, in *QueryPocBatchesForStageRequest, opts ...grpc.CallOption) (*QueryPocBatchesForStageResponse, error) {
+	out := new(QueryPocBatchesForStageResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PocBatchesForStage", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) GetModelCapacity(ctx context.Context, in *QueryGetModelCapacityRequest, opts ...grpc.CallOption) (*QueryGetModelCapacityResponse, error) {
-	out := new(QueryGetModelCapacityResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetModelCapacity", in, out, opts...)
+func (c *queryClient) PocValidationsForStage(ctx context.Context, in *QueryPocValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocValidationsForStageResponse, error) {
+	out := new(QueryPocValidationsForStageResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PocValidationsForStage", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) GetAllModelCapacities(ctx context.Context, in *QueryGetAllModelCapacitiesRequest, opts ...grpc.CallOption) (*QueryGetAllModelCapacitiesResponse, error) {
-	out := new(QueryGetAllModelCapacitiesResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetAllModelCapacities", in, out, opts...)
+func (c *queryClient) PocV2ValidationsForStage(ctx context.Context, in *QueryPocV2ValidationsForStageRequest, opts ...grpc.CallOption) (*QueryPocV2ValidationsForStageResponse, error) {
+	out := new(QueryPocV2ValidationsForStageResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PocV2ValidationsForStage", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) GranteesByMessageType(ctx context.Context, in *QueryGranteesByMessageTypeRequest, opts ...grpc.CallOption) (*QueryGranteesByMessageTypeResponse, error) {
-	out := new(QueryGranteesByMessageTypeResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/GranteesByMessageType", in, out, opts...)
+func (c *queryClient) PoCV2StoreCommit(ctx context.Context, in *QueryPoCV2StoreCommitRequest, opts ...grpc.CallOption) (*QueryPoCV2StoreCommitResponse, error) {
+	out := new(QueryPoCV2StoreCommitResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PoCV2StoreCommit", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) MLNodeVersion(ctx context.Context, in *QueryGetMLNodeVersionRequest, opts ...grpc.CallOption) (*QueryGetMLNodeVersionResponse, error) {
-	out := new(QueryGetMLNodeVersionResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/MLNodeVersion", in, out, opts...)
+func (c *queryClient) MLNodeWeightDistribution(ctx context.Context, in *QueryMLNodeWeightDistributionRequest, opts ...grpc.CallOption) (*QueryMLNodeWeightDistributionResponse, error) {
+	out := new(QueryMLNodeWeightDistributionResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MLNodeWeightDistribution", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ParticipantAllowList(ctx context.Context, in *QueryParticipantAllowListRequest, opts ...grpc.CallOption) (*QueryParticipantAllowListResponse, error) {
-	out := new(QueryParticipantAllowListResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ParticipantAllowList", in, out, opts...)
+func (c *queryClient) AllPoCV2StoreCommitsForStage(ctx context.Context, in *QueryAllPoCV2StoreCommitsForStageRequest, opts ...grpc.CallOption) (*QueryAllPoCV2StoreCommitsForStageResponse, error) {
+	out := new(QueryAllPoCV2StoreCommitsForStageResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/AllPoCV2StoreCommitsForStage", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ExcludedParticipants(ctx context.Context, in *QueryExcludedParticipantsRequest, opts ...grpc.CallOption) (*QueryExcludedParticipantsResponse, error) {
-	out := new(QueryExcludedParticipantsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ExcludedParticipants", in, out, opts...)
+func (c *queryClient) AllMLNodeWeightDistributionsForStage(ctx context.Context, in *QueryAllMLNodeWeightDistributionsForStageRequest, opts ...grpc.CallOption) (*QueryAllMLNodeWeightDistributionsForStageResponse, error) {
+	out := new(QueryAllMLNodeWeightDistributionsForStageResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/AllMLNodeWeightDistributionsForStage", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ActiveConfirmationPoCEvent(ctx context.Context, in *QueryActiveConfirmationPoCEventRequest, opts ...grpc.CallOption) (*QueryActiveConfirmationPoCEventResponse, error) {
-	out := new(QueryActiveConfirmationPoCEventResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ActiveConfirmationPoCEvent", in, out, opts...)
+func (c *queryClient) GetCurrentEpoch(ctx context.Context, in *QueryGetCurrentEpochRequest, opts ...grpc.CallOption) (*QueryGetCurrentEpochResponse, error) {
+	out := new(QueryGetCurrentEpochResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetCurrentEpoch", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ListConfirmationPoCEvents(ctx context.Context, in *QueryConfirmationPoCEventsRequest, opts ...grpc.CallOption) (*QueryConfirmationPoCEventsResponse, error) {
-	out := new(QueryConfirmationPoCEventsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ListConfirmationPoCEvents", in, out, opts...)
+func (c *queryClient) TokenomicsData(ctx context.Context, in *QueryGetTokenomicsDataRequest, opts ...grpc.CallOption) (*QueryGetTokenomicsDataResponse, error) {
+	out := new(QueryGetTokenomicsDataResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/TokenomicsData", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ListRandomSeeds(ctx context.Context, in *QueryRandomSeedsRequest, opts ...grpc.CallOption) (*QueryRandomSeedsResponse, error) {
-	out := new(QueryRandomSeedsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ListRandomSeeds", in, out, opts...)
+func (c *queryClient) GetUnitOfComputePriceProposal(ctx context.Context, in *QueryGetUnitOfComputePriceProposalRequest, opts ...grpc.CallOption) (*QueryGetUnitOfComputePriceProposalResponse, error) {
+	out := new(QueryGetUnitOfComputePriceProposalResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetUnitOfComputePriceProposal", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) ParticipantsWithBalances(ctx context.Context, in *QueryParticipantsWithBalancesRequest, opts ...grpc.CallOption) (*QueryParticipantsWithBalancesResponse, error) {
-	out := new(QueryParticipantsWithBalancesResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/ParticipantsWithBalances", in, out, opts...)
+func (c *queryClient) CurrentEpochGroupData(ctx context.Context, in *QueryCurrentEpochGroupDataRequest, opts ...grpc.CallOption) (*QueryCurrentEpochGroupDataResponse, error) {
+	out := new(QueryCurrentEpochGroupDataResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/CurrentEpochGroupData", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) PoCValidationSnapshot(ctx context.Context, in *QueryPoCValidationSnapshotRequest, opts ...grpc.CallOption) (*QueryPoCValidationSnapshotResponse, error) {
-	out := new(QueryPoCValidationSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PoCValidationSnapshot", in, out, opts...)
+func (c *queryClient) ModelsAll(ctx context.Context, in *QueryModelsAllRequest, opts ...grpc.CallOption) (*QueryModelsAllResponse, error) {
+	out := new(QueryModelsAllResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ModelsAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) DevshardEscrow(ctx context.Context, in *QueryGetDevshardEscrowRequest, opts ...grpc.CallOption) (*QueryGetDevshardEscrowResponse, error) {
-	out := new(QueryGetDevshardEscrowResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/DevshardEscrow", in, out, opts...)
+func (c *queryClient) InferenceTimeout(ctx context.Context, in *QueryGetInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryGetInferenceTimeoutResponse, error) {
+	out := new(QueryGetInferenceTimeoutResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceTimeout", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) PreservedNodesSnapshot(ctx context.Context, in *QueryPreservedNodesSnapshotRequest, opts ...grpc.CallOption) (*QueryPreservedNodesSnapshotResponse, error) {
-	out := new(QueryPreservedNodesSnapshotResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PreservedNodesSnapshot", in, out, opts...)
+func (c *queryClient) InferenceTimeoutAll(ctx context.Context, in *QueryAllInferenceTimeoutRequest, opts ...grpc.CallOption) (*QueryAllInferenceTimeoutResponse, error) {
+	out := new(QueryAllInferenceTimeoutResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceTimeoutAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) DevshardHostEpochStats(ctx context.Context, in *QueryGetDevshardHostEpochStatsRequest, opts ...grpc.CallOption) (*QueryGetDevshardHostEpochStatsResponse, error) {
-	out := new(QueryGetDevshardHostEpochStatsResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/DevshardHostEpochStats", in, out, opts...)
+func (c *queryClient) InferenceValidationDetails(ctx context.Context, in *QueryGetInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationDetailsResponse, error) {
+	out := new(QueryGetInferenceValidationDetailsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceValidationDetails", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *queryClient) PoCDelegation(ctx context.Context, in *QueryPoCDelegationRequest, opts ...grpc.CallOption) (*QueryPoCDelegationResponse, error) {
-	out := new(QueryPoCDelegationResponse)
-	err := c.cc.Invoke(ctx, "/inference.inference.Query/PoCDelegation", in, out, opts...)
+func (c *queryClient) InferenceValidationDetailsAll(ctx context.Context, in *QueryAllInferenceValidationDetailsRequest, opts ...grpc.CallOption) (*QueryAllInferenceValidationDetailsResponse, error) {
+	out := new(QueryAllInferenceValidationDetailsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferenceValidationDetailsAll", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-// QueryServer is the server API for Query service.
-type QueryServer interface {
-	// Parameters queries the parameters of the module.
-	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
-	// Queries a list of Inference items.
-	Inference(context.Context, *QueryGetInferenceRequest) (*QueryGetInferenceResponse, error)
-	InferenceAll(context.Context, *QueryAllInferenceRequest) (*QueryAllInferenceResponse, error)
-	// Queries a list of Participant items.
-	Participant(context.Context, *QueryGetParticipantRequest) (*QueryGetParticipantResponse, error)
-	ParticipantAll(context.Context, *QueryAllParticipantRequest) (*QueryAllParticipantResponse, error)
-	// Queries account public key and balance by address.
-	AccountByAddress(context.Context, *QueryAccountByAddressRequest) (*QueryAccountByAddressResponse, error)
+func (c *queryClient) GetInferenceValidationParameters(ctx context.Context, in *QueryGetInferenceValidationParametersRequest, opts ...grpc.CallOption) (*QueryGetInferenceValidationParametersResponse, error) {
+	out := new(QueryGetInferenceValidationParametersResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetInferenceValidationParameters", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) EpochPerformanceSummary(ctx context.Context, in *QueryEpochPerformanceSummaryByEpochRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByEpochResponse, error) {
+	out := new(QueryEpochPerformanceSummaryByEpochResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochPerformanceSummary", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) EpochPerformanceSummaryByParticipant(ctx context.Context, in *QueryEpochPerformanceSummaryByParticipantRequest, opts ...grpc.CallOption) (*QueryEpochPerformanceSummaryByParticipantResponse, error) {
+	out := new(QueryEpochPerformanceSummaryByParticipantResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochPerformanceSummaryByParticipant", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) EpochPerformanceSummaryAll(ctx context.Context, in *QueryAllEpochPerformanceSummaryRequest, opts ...grpc.CallOption) (*QueryAllEpochPerformanceSummaryResponse, error) {
+	out := new(QueryAllEpochPerformanceSummaryResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochPerformanceSummaryAll", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) HardwareNodes(ctx context.Context, in *QueryHardwareNodesRequest, opts ...grpc.CallOption) (*QueryHardwareNodesResponse, error) {
+	out := new(QueryHardwareNodesResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/HardwareNodes", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) HardwareNodesAll(ctx context.Context, in *QueryHardwareNodesAllRequest, opts ...grpc.CallOption) (*QueryHardwareNodesAllResponse, error) {
+	out := new(QueryHardwareNodesAllResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/HardwareNodesAll", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetParticipantCurrentStats(ctx context.Context, in *QueryGetParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetParticipantCurrentStatsResponse, error) {
+	out := new(QueryGetParticipantCurrentStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetParticipantCurrentStats", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetAllParticipantCurrentStats(ctx context.Context, in *QueryGetAllParticipantCurrentStatsRequest, opts ...grpc.CallOption) (*QueryGetAllParticipantCurrentStatsResponse, error) {
+	out := new(QueryGetAllParticipantCurrentStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetAllParticipantCurrentStats", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetParticipantsFullStats(ctx context.Context, in *QueryParticipantsFullStatsRequest, opts ...grpc.CallOption) (*QueryParticipantsFullStatsResponse, error) {
+	out := new(QueryParticipantsFullStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetParticipantsFullStats", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) StatsByTimePeriodByDeveloper(ctx context.Context, in *QueryStatsByTimePeriodByDeveloperRequest, opts ...grpc.CallOption) (*QueryStatsByTimePeriodByDeveloperResponse, error) {
+	out := new(QueryStatsByTimePeriodByDeveloperResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/StatsByTimePeriodByDeveloper", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) StatsByDeveloperAndEpochsBackwards(ctx context.Context, in *QueryStatsByDeveloperAndEpochBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error) {
+	out := new(QueryInferencesAndTokensStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/StatsByDeveloperAndEpochsBackwards", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) CountParticipants(ctx context.Context, in *QueryCountAllParticipantsRequest, opts ...grpc.CallOption) (*QueryCountAllParticipantsResponse, error) {
+	out := new(QueryCountAllParticipantsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/CountParticipants", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DebugStatsDeveloperStats(ctx context.Context, in *QueryDebugStatsRequest, opts ...grpc.CallOption) (*QueryDebugStatsResponse, error) {
+	out := new(QueryDebugStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/DebugStatsDeveloperStats", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) InferencesAndTokensStatsByEpochsBackwards(ctx context.Context, in *QueryInferencesAndTokensStatsByEpochsBackwardsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error) {
+	out := new(QueryInferencesAndTokensStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferencesAndTokensStatsByEpochsBackwards", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) InferencesAndTokensStatsByTimePeriod(ctx context.Context, in *QueryInferencesAndTokensStatsByTimePeriodRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsResponse, error) {
+	out := new(QueryInferencesAndTokensStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferencesAndTokensStatsByTimePeriod", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) InferencesAndTokensStatsByModels(ctx context.Context, in *QueryInferencesAndTokensStatsByModelsRequest, opts ...grpc.CallOption) (*QueryInferencesAndTokensStatsByModelsResponse, error) {
+	out := new(QueryInferencesAndTokensStatsByModelsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/InferencesAndTokensStatsByModels", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetMinimumValidationAverage(ctx context.Context, in *QueryGetMinimumValidationAverageRequest, opts ...grpc.CallOption) (*QueryGetMinimumValidationAverageResponse, error) {
+	out := new(QueryGetMinimumValidationAverageResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetMinimumValidationAverage", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) PartialUpgrade(ctx context.Context, in *QueryGetPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryGetPartialUpgradeResponse, error) {
+	out := new(QueryGetPartialUpgradeResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PartialUpgrade", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) PartialUpgradeAll(ctx context.Context, in *QueryAllPartialUpgradeRequest, opts ...grpc.CallOption) (*QueryAllPartialUpgradeResponse, error) {
+	out := new(QueryAllPartialUpgradeResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PartialUpgradeAll", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) BridgeTransaction(ctx context.Context, in *QueryGetBridgeTransactionRequest, opts ...grpc.CallOption) (*QueryGetBridgeTransactionResponse, error) {
+	out := new(QueryGetBridgeTransactionResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/BridgeTransaction", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) BridgeTransactions(ctx context.Context, in *QueryAllBridgeTransactionsRequest, opts ...grpc.CallOption) (*QueryAllBridgeTransactionsResponse, error) {
+	out := new(QueryAllBridgeTransactionsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/BridgeTransactions", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) BridgeAddressesByChain(ctx context.Context, in *QueryBridgeAddressesByChainRequest, opts ...grpc.CallOption) (*QueryBridgeAddressesByChainResponse, error) {
+	out := new(QueryBridgeAddressesByChainResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/BridgeAddressesByChain", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) LiquidityPool(ctx context.Context, in *QueryLiquidityPoolRequest, opts ...grpc.CallOption) (*QueryLiquidityPoolResponse, error) {
+	out := new(QueryLiquidityPoolResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/LiquidityPool", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) WrappedTokenBalances(ctx context.Context, in *QueryWrappedTokenBalancesRequest, opts ...grpc.CallOption) (*QueryWrappedTokenBalancesResponse, error) {
+	out := new(QueryWrappedTokenBalancesResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/WrappedTokenBalances", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ValidateWrappedTokenForTrade(ctx context.Context, in *QueryValidateWrappedTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateWrappedTokenForTradeResponse, error) {
+	out := new(QueryValidateWrappedTokenForTradeResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ValidateWrappedTokenForTrade", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ValidateIbcTokenForTrade(ctx context.Context, in *QueryValidateIbcTokenForTradeRequest, opts ...grpc.CallOption) (*QueryValidateIbcTokenForTradeResponse, error) {
+	out := new(QueryValidateIbcTokenForTradeResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ValidateIbcTokenForTrade", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ApprovedTokensForTrade(ctx context.Context, in *QueryApprovedTokensForTradeRequest, opts ...grpc.CallOption) (*QueryApprovedTokensForTradeResponse, error) {
+	out := new(QueryApprovedTokensForTradeResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ApprovedTokensForTrade", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) EpochInfo(ctx context.Context, in *QueryEpochInfoRequest, opts ...grpc.CallOption) (*QueryEpochInfoResponse, error) {
+	out := new(QueryEpochInfoResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/EpochInfo", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) CountPoCbatchesAtHeight(ctx context.Context, in *QueryCountPoCbatchesAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCbatchesAtHeightResponse, error) {
+	out := new(QueryCountPoCbatchesAtHeightResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/CountPoCbatchesAtHeight", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) CountPoCvalidationsAtHeight(ctx context.Context, in *QueryCountPoCvalidationsAtHeightRequest, opts ...grpc.CallOption) (*QueryCountPoCvalidationsAtHeightResponse, error) {
+	out := new(QueryCountPoCvalidationsAtHeightResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/CountPoCvalidationsAtHeight", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetModelPerTokenPrice(ctx context.Context, in *QueryGetModelPerTokenPriceRequest, opts ...grpc.CallOption) (*QueryGetModelPerTokenPriceResponse, error) {
+	out := new(QueryGetModelPerTokenPriceResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetModelPerTokenPrice", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetAllModelPerTokenPrices(ctx context.Context, in *QueryGetAllModelPerTokenPricesRequest, opts ...grpc.CallOption) (*QueryGetAllModelPerTokenPricesResponse, error) {
+	out := new(QueryGetAllModelPerTokenPricesResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetAllModelPerTokenPrices", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetModelCapacity(ctx context.Context, in *QueryGetModelCapacityRequest, opts ...grpc.CallOption) (*QueryGetModelCapacityResponse, error) {
+	out := new(QueryGetModelCapacityResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetModelCapacity", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GetAllModelCapacities(ctx context.Context, in *QueryGetAllModelCapacitiesRequest, opts ...grpc.CallOption) (*QueryGetAllModelCapacitiesResponse, error) {
+	out := new(QueryGetAllModelCapacitiesResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GetAllModelCapacities", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) GranteesByMessageType(ctx context.Context, in *QueryGranteesByMessageTypeRequest, opts ...grpc.CallOption) (*QueryGranteesByMessageTypeResponse, error) {
+	out := new(QueryGranteesByMessageTypeResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/GranteesByMessageType", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MLNodeVersion(ctx context.Context, in *QueryGetMLNodeVersionRequest, opts ...grpc.CallOption) (*QueryGetMLNodeVersionResponse, error) {
+	out := new(QueryGetMLNodeVersionResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MLNodeVersion", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) LastUpgradeHeight(ctx context.Context, in *QueryGetLastUpgradeHeightRequest, opts ...grpc.CallOption) (*QueryGetLastUpgradeHeightResponse, error) {
+	out := new(QueryGetLastUpgradeHeightResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/LastUpgradeHeight", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ParticipantAllowList(ctx context.Context, in *QueryParticipantAllowListRequest, opts ...grpc.CallOption) (*QueryParticipantAllowListResponse, error) {
+	out := new(QueryParticipantAllowListResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ParticipantAllowList", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ExcludedParticipants(ctx context.Context, in *QueryExcludedParticipantsRequest, opts ...grpc.CallOption) (*QueryExcludedParticipantsResponse, error) {
+	out := new(QueryExcludedParticipantsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ExcludedParticipants", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ActiveConfirmationPoCEvent(ctx context.Context, in *QueryActiveConfirmationPoCEventRequest, opts ...grpc.CallOption) (*QueryActiveConfirmationPoCEventResponse, error) {
+	out := new(QueryActiveConfirmationPoCEventResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ActiveConfirmationPoCEvent", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ListConfirmationPoCEvents(ctx context.Context, in *QueryConfirmationPoCEventsRequest, opts ...grpc.CallOption) (*QueryConfirmationPoCEventsResponse, error) {
+	out := new(QueryConfirmationPoCEventsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ListConfirmationPoCEvents", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ListRandomSeeds(ctx context.Context, in *QueryRandomSeedsRequest, opts ...grpc.CallOption) (*QueryRandomSeedsResponse, error) {
+	out := new(QueryRandomSeedsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ListRandomSeeds", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ParticipantsWithBalances(ctx context.Context, in *QueryParticipantsWithBalancesRequest, opts ...grpc.CallOption) (*QueryParticipantsWithBalancesResponse, error) {
+	out := new(QueryParticipantsWithBalancesResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ParticipantsWithBalances", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) PoCValidationSnapshot(ctx context.Context, in *QueryPoCValidationSnapshotRequest, opts ...grpc.CallOption) (*QueryPoCValidationSnapshotResponse, error) {
+	out := new(QueryPoCValidationSnapshotResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PoCValidationSnapshot", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DevshardEscrow(ctx context.Context, in *QueryGetDevshardEscrowRequest, opts ...grpc.CallOption) (*QueryGetDevshardEscrowResponse, error) {
+	out := new(QueryGetDevshardEscrowResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/DevshardEscrow", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) PreservedNodesSnapshot(ctx context.Context, in *QueryPreservedNodesSnapshotRequest, opts ...grpc.CallOption) (*QueryPreservedNodesSnapshotResponse, error) {
+	out := new(QueryPreservedNodesSnapshotResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PreservedNodesSnapshot", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) DevshardHostEpochStats(ctx context.Context, in *QueryGetDevshardHostEpochStatsRequest, opts ...grpc.CallOption) (*QueryGetDevshardHostEpochStatsResponse, error) {
+	out := new(QueryGetDevshardHostEpochStatsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/DevshardHostEpochStats", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) PoCDelegation(ctx context.Context, in *QueryPoCDelegationRequest, opts ...grpc.CallOption) (*QueryPoCDelegationResponse, error) {
+	out := new(QueryPoCDelegationResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/PoCDelegation", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceCredit(ctx context.Context, in *QueryMaintenanceCreditRequest, opts ...grpc.CallOption) (*QueryMaintenanceCreditResponse, error) {
+	out := new(QueryMaintenanceCreditResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MaintenanceCredit", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceScheduled(ctx context.Context, in *QueryMaintenanceScheduledRequest, opts ...grpc.CallOption) (*QueryMaintenanceScheduledResponse, error) {
+	out := new(QueryMaintenanceScheduledResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MaintenanceScheduled", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceActive(ctx context.Context, in *QueryMaintenanceActiveRequest, opts ...grpc.CallOption) (*QueryMaintenanceActiveResponse, error) {
+	out := new(QueryMaintenanceActiveResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MaintenanceActive", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceStatus(ctx context.Context, in *QueryMaintenanceStatusRequest, opts ...grpc.CallOption) (*QueryMaintenanceStatusResponse, error) {
+	out := new(QueryMaintenanceStatusResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MaintenanceStatus", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceConcurrency(ctx context.Context, in *QueryMaintenanceConcurrencyRequest, opts ...grpc.CallOption) (*QueryMaintenanceConcurrencyResponse, error) {
+	out := new(QueryMaintenanceConcurrencyResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MaintenanceConcurrency", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) MaintenanceSchedulability(ctx context.Context, in *QueryMaintenanceSchedulabilityRequest, opts ...grpc.CallOption) (*QueryMaintenanceSchedulabilityResponse, error) {
+	out := new(QueryMaintenanceSchedulabilityResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/MaintenanceSchedulability", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *queryClient) ListClaimRecipients(ctx context.Context, in *QueryListClaimRecipientsRequest, opts ...grpc.CallOption) (*QueryListClaimRecipientsResponse, error) {
+	out := new(QueryListClaimRecipientsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Query/ListClaimRecipients", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// QueryServer is the server API for Query service.
+type QueryServer interface {
+	// Parameters queries the parameters of the module.
+	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+	// Queries a list of Inference items.
+	Inference(context.Context, *QueryGetInferenceRequest) (*QueryGetInferenceResponse, error)
+	InferenceAll(context.Context, *QueryAllInferenceRequest) (*QueryAllInferenceResponse, error)
+	// Queries a list of Participant items.
+	Participant(context.Context, *QueryGetParticipantRequest) (*QueryGetParticipantResponse, error)
+	ParticipantAll(context.Context, *QueryAllParticipantRequest) (*QueryAllParticipantResponse, error)
+	// Queries account public key and balance by address.
+	AccountByAddress(context.Context, *QueryAccountByAddressRequest) (*QueryAccountByAddressResponse, error)
 	// Queries a list of GetRandomExecutor items.
 	GetRandomExecutor(context.Context, *QueryGetRandomExecutorRequest) (*QueryGetRandomExecutorResponse, error)
 	// Queries a list of EpochGroupData items.
@@ -9615,6 +10633,7 @@ type QueryServer interface {
 	// Queries a list of SettleAmount items.
 	SettleAmount(context.Context, *QueryGetSettleAmountRequest) (*QueryGetSettleAmountResponse, error)
 	SettleAmountAll(context.Context, *QueryAllSettleAmountRequest) (*QueryAllSettleAmountResponse, error)
+	EstimateBitcoinReward(context.Context, *QueryEstimateBitcoinRewardRequest) (*QueryEstimateBitcoinRewardResponse, error)
 	// Queries a list of EpochGroupValidations items.
 	EpochGroupValidations(context.Context, *QueryGetEpochGroupValidationsRequest) (*QueryGetEpochGroupValidationsResponse, error)
 	EpochGroupValidationsAll(context.Context, *QueryAllEpochGroupValidationsRequest) (*QueryAllEpochGroupValidationsResponse, error)
@@ -9706,6 +10725,8 @@ type QueryServer interface {
 	GranteesByMessageType(context.Context, *QueryGranteesByMessageTypeRequest) (*QueryGranteesByMessageTypeResponse, error)
 	// Queries the current MLNode version.
 	MLNodeVersion(context.Context, *QueryGetMLNodeVersionRequest) (*QueryGetMLNodeVersionResponse, error)
+	// Queries the most recent applied upgrade height.
+	LastUpgradeHeight(context.Context, *QueryGetLastUpgradeHeightRequest) (*QueryGetLastUpgradeHeightResponse, error)
 	// Queries the participant allowlist.
 	ParticipantAllowList(context.Context, *QueryParticipantAllowListRequest) (*QueryParticipantAllowListResponse, error)
 	// Queries the list of excluded participants for an epoch (0 = current epoch).
@@ -9724,6 +10745,20 @@ type QueryServer interface {
 	PreservedNodesSnapshot(context.Context, *QueryPreservedNodesSnapshotRequest) (*QueryPreservedNodesSnapshotResponse, error)
 	DevshardHostEpochStats(context.Context, *QueryGetDevshardHostEpochStatsRequest) (*QueryGetDevshardHostEpochStatsResponse, error)
 	PoCDelegation(context.Context, *QueryPoCDelegationRequest) (*QueryPoCDelegationResponse, error)
+	// Queries the maintenance credit balance for a participant.
+	MaintenanceCredit(context.Context, *QueryMaintenanceCreditRequest) (*QueryMaintenanceCreditResponse, error)
+	// Queries scheduled maintenance windows for a participant.
+	MaintenanceScheduled(context.Context, *QueryMaintenanceScheduledRequest) (*QueryMaintenanceScheduledResponse, error)
+	// Queries all currently active maintenance windows.
+	MaintenanceActive(context.Context, *QueryMaintenanceActiveRequest) (*QueryMaintenanceActiveResponse, error)
+	// Queries the full maintenance status for a participant at the current height.
+	MaintenanceStatus(context.Context, *QueryMaintenanceStatusRequest) (*QueryMaintenanceStatusResponse, error)
+	// Queries the concurrent reserved participant count and power at a given height.
+	MaintenanceConcurrency(context.Context, *QueryMaintenanceConcurrencyRequest) (*QueryMaintenanceConcurrencyResponse, error)
+	// Queries whether a proposed maintenance window is schedulable.
+	MaintenanceSchedulability(context.Context, *QueryMaintenanceSchedulabilityRequest) (*QueryMaintenanceSchedulabilityResponse, error)
+	// Lists the scheduled per-epoch claim recipient overrides for a participant.
+	ListClaimRecipients(context.Context, *QueryListClaimRecipientsRequest) (*QueryListClaimRecipientsResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -9763,6 +10798,9 @@ func (*UnimplementedQueryServer) SettleAmount(ctx context.Context, req *QueryGet
 func (*UnimplementedQueryServer) SettleAmountAll(ctx context.Context, req *QueryAllSettleAmountRequest) (*QueryAllSettleAmountResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SettleAmountAll not implemented")
 }
+func (*UnimplementedQueryServer) EstimateBitcoinReward(ctx context.Context, req *QueryEstimateBitcoinRewardRequest) (*QueryEstimateBitcoinRewardResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method EstimateBitcoinReward not implemented")
+}
 func (*UnimplementedQueryServer) EpochGroupValidations(ctx context.Context, req *QueryGetEpochGroupValidationsRequest) (*QueryGetEpochGroupValidationsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method EpochGroupValidations not implemented")
 }
@@ -9925,6 +10963,9 @@ func (*UnimplementedQueryServer) GranteesByMessageType(ctx context.Context, req
 func (*UnimplementedQueryServer) MLNodeVersion(ctx context.Context, req *QueryGetMLNodeVersionRequest) (*QueryGetMLNodeVersionResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MLNodeVersion not implemented")
 }
+func (*UnimplementedQueryServer) LastUpgradeHeight(ctx context.Context, req *QueryGetLastUpgradeHeightRequest) (*QueryGetLastUpgradeHeightResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method LastUpgradeHeight not implemented")
+}
 func (*UnimplementedQueryServer) ParticipantAllowList(ctx context.Context, req *QueryParticipantAllowListRequest) (*QueryParticipantAllowListResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ParticipantAllowList not implemented")
 }
@@ -9958,6 +10999,27 @@ func (*UnimplementedQueryServer) DevshardHostEpochStats(ctx context.Context, req
 func (*UnimplementedQueryServer) PoCDelegation(ctx context.Context, req *QueryPoCDelegationRequest) (*QueryPoCDelegationResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method PoCDelegation not implemented")
 }
+func (*UnimplementedQueryServer) MaintenanceCredit(ctx context.Context, req *QueryMaintenanceCreditRequest) (*QueryMaintenanceCreditResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceCredit not implemented")
+}
+func (*UnimplementedQueryServer) MaintenanceScheduled(ctx context.Context, req *QueryMaintenanceScheduledRequest) (*QueryMaintenanceScheduledResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceScheduled not implemented")
+}
+func (*UnimplementedQueryServer) MaintenanceActive(ctx context.Context, req *QueryMaintenanceActiveRequest) (*QueryMaintenanceActiveResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceActive not implemented")
+}
+func (*UnimplementedQueryServer) MaintenanceStatus(ctx context.Context, req *QueryMaintenanceStatusRequest) (*QueryMaintenanceStatusResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceStatus not implemented")
+}
+func (*UnimplementedQueryServer) MaintenanceConcurrency(ctx context.Context, req *QueryMaintenanceConcurrencyRequest) (*QueryMaintenanceConcurrencyResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceConcurrency not implemented")
+}
+func (*UnimplementedQueryServer) MaintenanceSchedulability(ctx context.Context, req *QueryMaintenanceSchedulabilityRequest) (*QueryMaintenanceSchedulabilityResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MaintenanceSchedulability not implemented")
+}
+func (*UnimplementedQueryServer) ListClaimRecipients(ctx context.Context, req *QueryListClaimRecipientsRequest) (*QueryListClaimRecipientsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListClaimRecipients not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -10161,6 +11223,24 @@ func _Query_SettleAmountAll_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_EstimateBitcoinReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryEstimateBitcoinRewardRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).EstimateBitcoinReward(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/EstimateBitcoinReward",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).EstimateBitcoinReward(ctx, req.(*QueryEstimateBitcoinRewardRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_EpochGroupValidations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryGetEpochGroupValidationsRequest)
 	if err := dec(in); err != nil {
@@ -11133,6 +12213,24 @@ func _Query_MLNodeVersion_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_LastUpgradeHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryGetLastUpgradeHeightRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).LastUpgradeHeight(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/LastUpgradeHeight",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).LastUpgradeHeight(ctx, req.(*QueryGetLastUpgradeHeightRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_ParticipantAllowList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryParticipantAllowListRequest)
 	if err := dec(in); err != nil {
@@ -11331,6 +12429,132 @@ func _Query_PoCDelegation_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_MaintenanceCredit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceCreditRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceCredit(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/MaintenanceCredit",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceCredit(ctx, req.(*QueryMaintenanceCreditRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceScheduled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceScheduledRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceScheduled(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/MaintenanceScheduled",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceScheduled(ctx, req.(*QueryMaintenanceScheduledRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceActive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceActiveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceActive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/MaintenanceActive",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceActive(ctx, req.(*QueryMaintenanceActiveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceStatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceStatus(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/MaintenanceStatus",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceStatus(ctx, req.(*QueryMaintenanceStatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceConcurrency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceConcurrencyRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceConcurrency(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/MaintenanceConcurrency",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceConcurrency(ctx, req.(*QueryMaintenanceConcurrencyRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_MaintenanceSchedulability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMaintenanceSchedulabilityRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).MaintenanceSchedulability(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/MaintenanceSchedulability",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).MaintenanceSchedulability(ctx, req.(*QueryMaintenanceSchedulabilityRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Query_ListClaimRecipients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryListClaimRecipientsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).ListClaimRecipients(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Query/ListClaimRecipients",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).ListClaimRecipients(ctx, req.(*QueryListClaimRecipientsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var Query_serviceDesc = _Query_serviceDesc
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "inference.inference.Query",
@@ -11380,6 +12604,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "SettleAmountAll",
 			Handler:    _Query_SettleAmountAll_Handler,
 		},
+		{
+			MethodName: "EstimateBitcoinReward",
+			Handler:    _Query_EstimateBitcoinReward_Handler,
+		},
 		{
 			MethodName: "EpochGroupValidations",
 			Handler:    _Query_EpochGroupValidations_Handler,
@@ -11596,6 +12824,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "MLNodeVersion",
 			Handler:    _Query_MLNodeVersion_Handler,
 		},
+		{
+			MethodName: "LastUpgradeHeight",
+			Handler:    _Query_LastUpgradeHeight_Handler,
+		},
 		{
 			MethodName: "ParticipantAllowList",
 			Handler:    _Query_ParticipantAllowList_Handler,
@@ -11640,6 +12872,34 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "PoCDelegation",
 			Handler:    _Query_PoCDelegation_Handler,
 		},
+		{
+			MethodName: "MaintenanceCredit",
+			Handler:    _Query_MaintenanceCredit_Handler,
+		},
+		{
+			MethodName: "MaintenanceScheduled",
+			Handler:    _Query_MaintenanceScheduled_Handler,
+		},
+		{
+			MethodName: "MaintenanceActive",
+			Handler:    _Query_MaintenanceActive_Handler,
+		},
+		{
+			MethodName: "MaintenanceStatus",
+			Handler:    _Query_MaintenanceStatus_Handler,
+		},
+		{
+			MethodName: "MaintenanceConcurrency",
+			Handler:    _Query_MaintenanceConcurrency_Handler,
+		},
+		{
+			MethodName: "MaintenanceSchedulability",
+			Handler:    _Query_MaintenanceSchedulability_Handler,
+		},
+		{
+			MethodName: "ListClaimRecipients",
+			Handler:    _Query_ListClaimRecipients_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "inference/inference/query.proto",
@@ -12434,6 +13694,69 @@ func (m *QueryAllSettleAmountResponse) MarshalToSizedBuffer(dAtA []byte) (int, e
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryEstimateBitcoinRewardRequest) 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 *QueryEstimateBitcoinRewardRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryEstimateBitcoinRewardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryEstimateBitcoinRewardResponse) 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 *QueryEstimateBitcoinRewardResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryEstimateBitcoinRewardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.SettleAmount.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintQuery(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
 func (m *QueryGetEpochGroupValidationsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -16945,6 +18268,67 @@ func (m *QueryGetMLNodeVersionResponse) MarshalToSizedBuffer(dAtA []byte) (int,
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryGetLastUpgradeHeightRequest) 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 *QueryGetLastUpgradeHeightRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryGetLastUpgradeHeightRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryGetLastUpgradeHeightResponse) 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 *QueryGetLastUpgradeHeightResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryGetLastUpgradeHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Found {
+		i--
+		if m.Found {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.LastUpgradeHeight != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.LastUpgradeHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *QueryExcludedParticipantsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -17638,293 +19022,572 @@ func (m *QueryGetDevshardHostEpochStatsResponse) MarshalToSizedBuffer(dAtA []byt
 	return len(dAtA) - i, nil
 }
 
-func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
-	offset -= sovQuery(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *QueryParamsRequest) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *QueryMaintenanceCreditRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	var l int
-	_ = l
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *QueryParamsResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Params.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
+func (m *QueryMaintenanceCreditRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *QueryGetInferenceRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *QueryMaintenanceCreditRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *QueryGetInferenceResponse) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *QueryMaintenanceCreditResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	var l int
-	_ = l
-	l = m.Inference.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *QueryAllInferenceRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
+func (m *QueryMaintenanceCreditResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *QueryAllInferenceResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *QueryMaintenanceCreditResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if len(m.Inference) > 0 {
-		for _, e := range m.Inference {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
+	if m.Found {
+		i--
+		if m.Found {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
 		}
+		i--
+		dAtA[i] = 0x10
 	}
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
+	if m.CreditBlocks != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.CreditBlocks))
+		i--
+		dAtA[i] = 0x8
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *QueryGetParticipantRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Index)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
+func (m *QueryMaintenanceScheduledRequest) 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 n
+	return dAtA[:n], nil
 }
 
-func (m *QueryGetParticipantResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Participant.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
+func (m *QueryMaintenanceScheduledRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *QueryAllParticipantRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *QueryMaintenanceScheduledRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *QueryAllParticipantResponse) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *QueryMaintenanceScheduledResponse) 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 *QueryMaintenanceScheduledResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceScheduledResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if len(m.Participant) > 0 {
-		for _, e := range m.Participant {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
+	if m.Found {
+		i--
+		if m.Found {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
 		}
+		i--
+		dAtA[i] = 0x10
 	}
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	if m.BlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.BlockHeight))
+	if m.Reservation != nil {
+		{
+			size, err := m.Reservation.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *QueryAccountByAddressRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Address)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
+func (m *QueryMaintenanceActiveRequest) 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 n
+	return dAtA[:n], nil
 }
 
-func (m *QueryAccountByAddressResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Pubkey)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	if m.Balance != 0 {
-		n += 1 + sovQuery(uint64(m.Balance))
-	}
-	l = len(m.Denom)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
+func (m *QueryMaintenanceActiveRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *QueryGetRandomExecutorRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *QueryMaintenanceActiveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = len(m.Model)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *QueryGetRandomExecutorResponse) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *QueryMaintenanceActiveResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	var l int
-	_ = l
-	l = m.Executor.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
+	return dAtA[:n], nil
 }
 
-func (m *QueryGetEpochGroupDataRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.EpochIndex != 0 {
-		n += 1 + sovQuery(uint64(m.EpochIndex))
-	}
-	l = len(m.ModelId)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	return n
+func (m *QueryMaintenanceActiveResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *QueryGetEpochGroupDataResponse) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *QueryMaintenanceActiveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = m.EpochGroupData.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
+	if len(m.Reservations) > 0 {
+		for iNdEx := len(m.Reservations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Reservations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
 }
 
-func (m *QueryAllEpochGroupDataRequest) Size() (n int) {
+func (m *QueryMaintenanceStatusRequest) 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 *QueryMaintenanceStatusRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryMaintenanceStatusResponse) 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 *QueryMaintenanceStatusResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Found {
+		i--
+		if m.Found {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.ScheduledReservation != nil {
+		{
+			size, err := m.ScheduledReservation.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.ActiveReservation != nil {
+		{
+			size, err := m.ActiveReservation.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.State != nil {
+		{
+			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryMaintenanceConcurrencyRequest) 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 *QueryMaintenanceConcurrencyRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceConcurrencyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Height != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.Height))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryMaintenanceConcurrencyResponse) 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 *QueryMaintenanceConcurrencyResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceConcurrencyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.ConcurrentPowerBps != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.ConcurrentPowerBps))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.ConcurrentCount != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.ConcurrentCount))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryMaintenanceSchedulabilityRequest) 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 *QueryMaintenanceSchedulabilityRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceSchedulabilityRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.DurationBlocks != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.DurationBlocks))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.StartHeight != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.StartHeight))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryMaintenanceSchedulabilityResponse) 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 *QueryMaintenanceSchedulabilityResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryMaintenanceSchedulabilityResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.RejectionReason) > 0 {
+		i -= len(m.RejectionReason)
+		copy(dAtA[i:], m.RejectionReason)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.RejectionReason)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Schedulable {
+		i--
+		if m.Schedulable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryListClaimRecipientsRequest) 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 *QueryListClaimRecipientsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryListClaimRecipientsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryListClaimRecipientsResponse) 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 *QueryListClaimRecipientsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryListClaimRecipientsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
+	offset -= sovQuery(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *QueryParamsRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
-	}
 	return n
 }
 
-func (m *QueryAllEpochGroupDataResponse) Size() (n int) {
+func (m *QueryParamsResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.EpochGroupData) > 0 {
-		for _, e := range m.EpochGroupData {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
-	}
-	if m.Pagination != nil {
-		l = m.Pagination.Size()
-		n += 1 + l + sovQuery(uint64(l))
-	}
+	l = m.Params.Size()
+	n += 1 + l + sovQuery(uint64(l))
 	return n
 }
 
-func (m *QueryGetSettleAmountRequest) Size() (n int) {
+func (m *QueryGetInferenceRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Participant)
+	l = len(m.Index)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryGetSettleAmountResponse) Size() (n int) {
+func (m *QueryGetInferenceResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.SettleAmount.Size()
+	l = m.Inference.Size()
 	n += 1 + l + sovQuery(uint64(l))
 	return n
 }
 
-func (m *QueryAllSettleAmountRequest) Size() (n int) {
+func (m *QueryAllInferenceRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -17937,14 +19600,14 @@ func (m *QueryAllSettleAmountRequest) Size() (n int) {
 	return n
 }
 
-func (m *QueryAllSettleAmountResponse) Size() (n int) {
+func (m *QueryAllInferenceResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.SettleAmount) > 0 {
-		for _, e := range m.SettleAmount {
+	if len(m.Inference) > 0 {
+		for _, e := range m.Inference {
 			l = e.Size()
 			n += 1 + l + sovQuery(uint64(l))
 		}
@@ -17956,34 +19619,31 @@ func (m *QueryAllSettleAmountResponse) Size() (n int) {
 	return n
 }
 
-func (m *QueryGetEpochGroupValidationsRequest) Size() (n int) {
+func (m *QueryGetParticipantRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Participant)
+	l = len(m.Index)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
-	if m.EpochIndex != 0 {
-		n += 1 + sovQuery(uint64(m.EpochIndex))
-	}
 	return n
 }
 
-func (m *QueryGetEpochGroupValidationsResponse) Size() (n int) {
+func (m *QueryGetParticipantResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.EpochGroupValidations.Size()
+	l = m.Participant.Size()
 	n += 1 + l + sovQuery(uint64(l))
 	return n
 }
 
-func (m *QueryAllEpochGroupValidationsRequest) Size() (n int) {
+func (m *QueryAllParticipantRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -17996,14 +19656,14 @@ func (m *QueryAllEpochGroupValidationsRequest) Size() (n int) {
 	return n
 }
 
-func (m *QueryAllEpochGroupValidationsResponse) Size() (n int) {
+func (m *QueryAllParticipantResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.EpochGroupValidations) > 0 {
-		for _, e := range m.EpochGroupValidations {
+	if len(m.Participant) > 0 {
+		for _, e := range m.Participant {
 			l = e.Size()
 			n += 1 + l + sovQuery(uint64(l))
 		}
@@ -18012,277 +19672,535 @@ func (m *QueryAllEpochGroupValidationsResponse) Size() (n int) {
 		l = m.Pagination.Size()
 		n += 1 + l + sovQuery(uint64(l))
 	}
-	return n
-}
-
-func (m *QueryPocBatchesForStageRequest) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
 	if m.BlockHeight != 0 {
 		n += 1 + sovQuery(uint64(m.BlockHeight))
 	}
 	return n
 }
 
-func (m *QueryPocBatchesForStageResponse) Size() (n int) {
+func (m *QueryAccountByAddressRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.PocBatch) > 0 {
-		for _, e := range m.PocBatch {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *PoCBatchesWithParticipants) Size() (n int) {
+func (m *QueryAccountByAddressResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Participant)
+	l = len(m.Pubkey)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
-	l = len(m.PubKey)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
+	if m.Balance != 0 {
+		n += 1 + sovQuery(uint64(m.Balance))
 	}
-	l = len(m.HexPubKey)
+	l = len(m.Denom)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
-	if len(m.PocBatch) > 0 {
-		for _, e := range m.PocBatch {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
-	}
 	return n
 }
 
-func (m *QueryPocValidationsForStageRequest) Size() (n int) {
+func (m *QueryGetRandomExecutorRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.BlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.BlockHeight))
+	l = len(m.Model)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryPocValidationsForStageResponse) Size() (n int) {
+func (m *QueryGetRandomExecutorResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.PocValidation) > 0 {
-		for _, e := range m.PocValidation {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
-	}
+	l = m.Executor.Size()
+	n += 1 + l + sovQuery(uint64(l))
 	return n
 }
 
-func (m *PoCValidationsWithParticipants) Size() (n int) {
+func (m *QueryGetEpochGroupDataRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Participant)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.PubKey)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
+	if m.EpochIndex != 0 {
+		n += 1 + sovQuery(uint64(m.EpochIndex))
 	}
-	l = len(m.HexPubKey)
+	l = len(m.ModelId)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
-	if len(m.PocValidation) > 0 {
-		for _, e := range m.PocValidation {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
-	}
 	return n
 }
 
-func (m *QueryPocV2ValidationsForStageRequest) Size() (n int) {
+func (m *QueryGetEpochGroupDataResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.BlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.BlockHeight))
-	}
+	l = m.EpochGroupData.Size()
+	n += 1 + l + sovQuery(uint64(l))
 	return n
 }
 
-func (m *QueryPocV2ValidationsForStageResponse) Size() (n int) {
+func (m *QueryAllEpochGroupDataRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.PocValidation) > 0 {
-		for _, e := range m.PocValidation {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *PoCValidationsWithParticipantsV2) Size() (n int) {
+func (m *QueryAllEpochGroupDataResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Participant)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.PubKey)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.HexPubKey)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	if len(m.PocValidation) > 0 {
-		for _, e := range m.PocValidation {
+	if len(m.EpochGroupData) > 0 {
+		for _, e := range m.EpochGroupData {
 			l = e.Size()
 			n += 1 + l + sovQuery(uint64(l))
 		}
 	}
-	l = len(m.ModelId)
-	if l > 0 {
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
 		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryPoCV2StoreCommitRequest) Size() (n int) {
+func (m *QueryGetSettleAmountRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.PocStageStartBlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.PocStageStartBlockHeight))
-	}
-	l = len(m.ParticipantAddress)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.ModelId)
+	l = len(m.Participant)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryPoCV2StoreCommitResponse) Size() (n int) {
+func (m *QueryGetSettleAmountResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Count != 0 {
-		n += 1 + sovQuery(uint64(m.Count))
-	}
-	l = len(m.RootHash)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	if m.Found {
-		n += 2
-	}
+	l = m.SettleAmount.Size()
+	n += 1 + l + sovQuery(uint64(l))
 	return n
 }
 
-func (m *QueryMLNodeWeightDistributionRequest) Size() (n int) {
+func (m *QueryAllSettleAmountRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.PocStageStartBlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.PocStageStartBlockHeight))
-	}
-	l = len(m.ParticipantAddress)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.ModelId)
-	if l > 0 {
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
 		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryMLNodeWeightDistributionResponse) Size() (n int) {
+func (m *QueryAllSettleAmountResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Weights) > 0 {
-		for _, e := range m.Weights {
+	if len(m.SettleAmount) > 0 {
+		for _, e := range m.SettleAmount {
 			l = e.Size()
 			n += 1 + l + sovQuery(uint64(l))
 		}
 	}
-	if m.Found {
-		n += 2
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryAllPoCV2StoreCommitsForStageRequest) Size() (n int) {
+func (m *QueryEstimateBitcoinRewardRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.PocStageStartBlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.PocStageStartBlockHeight))
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
 	}
 	return n
 }
 
-func (m *QueryAllPoCV2StoreCommitsForStageResponse) Size() (n int) {
+func (m *QueryEstimateBitcoinRewardResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Commits) > 0 {
-		for _, e := range m.Commits {
-			l = e.Size()
-			n += 1 + l + sovQuery(uint64(l))
-		}
-	}
-	return n
+	l = m.SettleAmount.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	return n
+}
+
+func (m *QueryGetEpochGroupValidationsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.EpochIndex != 0 {
+		n += 1 + sovQuery(uint64(m.EpochIndex))
+	}
+	return n
+}
+
+func (m *QueryGetEpochGroupValidationsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.EpochGroupValidations.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	return n
+}
+
+func (m *QueryAllEpochGroupValidationsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryAllEpochGroupValidationsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.EpochGroupValidations) > 0 {
+		for _, e := range m.EpochGroupValidations {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	if m.Pagination != nil {
+		l = m.Pagination.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryPocBatchesForStageRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.BlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.BlockHeight))
+	}
+	return n
+}
+
+func (m *QueryPocBatchesForStageResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.PocBatch) > 0 {
+		for _, e := range m.PocBatch {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *PoCBatchesWithParticipants) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.PubKey)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.HexPubKey)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if len(m.PocBatch) > 0 {
+		for _, e := range m.PocBatch {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *QueryPocValidationsForStageRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.BlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.BlockHeight))
+	}
+	return n
+}
+
+func (m *QueryPocValidationsForStageResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.PocValidation) > 0 {
+		for _, e := range m.PocValidation {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *PoCValidationsWithParticipants) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.PubKey)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.HexPubKey)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if len(m.PocValidation) > 0 {
+		for _, e := range m.PocValidation {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *QueryPocV2ValidationsForStageRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.BlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.BlockHeight))
+	}
+	return n
+}
+
+func (m *QueryPocV2ValidationsForStageResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.PocValidation) > 0 {
+		for _, e := range m.PocValidation {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *PoCValidationsWithParticipantsV2) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.PubKey)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.HexPubKey)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if len(m.PocValidation) > 0 {
+		for _, e := range m.PocValidation {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	l = len(m.ModelId)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryPoCV2StoreCommitRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PocStageStartBlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.PocStageStartBlockHeight))
+	}
+	l = len(m.ParticipantAddress)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.ModelId)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryPoCV2StoreCommitResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Count != 0 {
+		n += 1 + sovQuery(uint64(m.Count))
+	}
+	l = len(m.RootHash)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.Found {
+		n += 2
+	}
+	return n
+}
+
+func (m *QueryMLNodeWeightDistributionRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PocStageStartBlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.PocStageStartBlockHeight))
+	}
+	l = len(m.ParticipantAddress)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.ModelId)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryMLNodeWeightDistributionResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Weights) > 0 {
+		for _, e := range m.Weights {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	if m.Found {
+		n += 2
+	}
+	return n
+}
+
+func (m *QueryAllPoCV2StoreCommitsForStageRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PocStageStartBlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.PocStageStartBlockHeight))
+	}
+	return n
+}
+
+func (m *QueryAllPoCV2StoreCommitsForStageResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Commits) > 0 {
+		for _, e := range m.Commits {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
 }
 
 func (m *PoCV2StoreCommitWithAddress) Size() (n int) {
@@ -19840,6 +21758,30 @@ func (m *QueryGetMLNodeVersionResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryGetLastUpgradeHeightRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *QueryGetLastUpgradeHeightResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.LastUpgradeHeight != 0 {
+		n += 1 + sovQuery(uint64(m.LastUpgradeHeight))
+	}
+	if m.Found {
+		n += 2
+	}
+	return n
+}
+
 func (m *QueryExcludedParticipantsRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -20111,6 +22053,214 @@ func (m *QueryGetDevshardHostEpochStatsResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryMaintenanceCreditRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryMaintenanceCreditResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CreditBlocks != 0 {
+		n += 1 + sovQuery(uint64(m.CreditBlocks))
+	}
+	if m.Found {
+		n += 2
+	}
+	return n
+}
+
+func (m *QueryMaintenanceScheduledRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryMaintenanceScheduledResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Reservation != nil {
+		l = m.Reservation.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.Found {
+		n += 2
+	}
+	return n
+}
+
+func (m *QueryMaintenanceActiveRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *QueryMaintenanceActiveResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Reservations) > 0 {
+		for _, e := range m.Reservations {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *QueryMaintenanceStatusRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryMaintenanceStatusResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.State != nil {
+		l = m.State.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.ActiveReservation != nil {
+		l = m.ActiveReservation.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.ScheduledReservation != nil {
+		l = m.ScheduledReservation.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.Found {
+		n += 2
+	}
+	return n
+}
+
+func (m *QueryMaintenanceConcurrencyRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Height != 0 {
+		n += 1 + sovQuery(uint64(m.Height))
+	}
+	return n
+}
+
+func (m *QueryMaintenanceConcurrencyResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ConcurrentCount != 0 {
+		n += 1 + sovQuery(uint64(m.ConcurrentCount))
+	}
+	if m.ConcurrentPowerBps != 0 {
+		n += 1 + sovQuery(uint64(m.ConcurrentPowerBps))
+	}
+	return n
+}
+
+func (m *QueryMaintenanceSchedulabilityRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.StartHeight != 0 {
+		n += 1 + sovQuery(uint64(m.StartHeight))
+	}
+	if m.DurationBlocks != 0 {
+		n += 1 + sovQuery(uint64(m.DurationBlocks))
+	}
+	return n
+}
+
+func (m *QueryMaintenanceSchedulabilityResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Schedulable {
+		n += 2
+	}
+	l = len(m.RejectionReason)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryListClaimRecipientsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryListClaimRecipientsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
 func sovQuery(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -20190,17 +22340,943 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryGetInferenceRequest) 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: QueryGetInferenceRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetInferenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetInferenceResponse) 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: QueryGetInferenceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetInferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Inference", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Inference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryAllInferenceRequest) 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: QueryAllInferenceRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllInferenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryAllInferenceResponse) 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: QueryAllInferenceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllInferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Inference", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Inference = append(m.Inference, Inference{})
+			if err := m.Inference[len(m.Inference)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryGetParticipantRequest) 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: QueryGetParticipantRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetParticipantResponse) 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: QueryGetParticipantResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Participant.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryAllParticipantRequest) 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: QueryAllParticipantRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryAllParticipantResponse) 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: QueryAllParticipantResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Participant = append(m.Participant, Participant{})
+			if err := m.Participant[len(m.Participant)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+			}
+			m.BlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		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 *QueryAccountByAddressRequest) 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: QueryAccountByAddressRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAccountByAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *QueryAccountByAddressResponse) 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: QueryAccountByAddressResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAccountByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -20210,78 +23286,46 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Pubkey = 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 *QueryGetInferenceRequest) 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
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			m.Balance = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Balance |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -20309,7 +23353,7 @@ func (m *QueryGetInferenceRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Index = string(dAtA[iNdEx:postIndex])
+			m.Denom = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -20332,7 +23376,7 @@ func (m *QueryGetInferenceRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetInferenceResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetRandomExecutorRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -20355,17 +23399,17 @@ func (m *QueryGetInferenceResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetRandomExecutorRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetRandomExecutorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Inference", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -20375,24 +23419,23 @@ func (m *QueryGetInferenceResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Inference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Model = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -20415,7 +23458,7 @@ func (m *QueryGetInferenceResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllInferenceRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetRandomExecutorResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -20438,15 +23481,15 @@ func (m *QueryAllInferenceRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllInferenceRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetRandomExecutorResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllInferenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetRandomExecutorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Executor", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -20473,10 +23516,7 @@ func (m *QueryAllInferenceRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Executor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -20501,7 +23541,7 @@ func (m *QueryAllInferenceRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllInferenceResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -20524,17 +23564,17 @@ func (m *QueryAllInferenceResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllInferenceResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetEpochGroupDataRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllInferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Inference", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var msglen int
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -20544,115 +23584,14 @@ func (m *QueryAllInferenceResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Inference = append(m.Inference, Inference{})
-			if err := m.Inference[len(m.Inference)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			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 *QueryGetParticipantRequest) 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: QueryGetParticipantRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -20680,7 +23619,7 @@ func (m *QueryGetParticipantRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Index = string(dAtA[iNdEx:postIndex])
+			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -20703,7 +23642,7 @@ func (m *QueryGetParticipantRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetParticipantResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -20726,15 +23665,15 @@ func (m *QueryGetParticipantResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetParticipantResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetEpochGroupDataResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -20761,7 +23700,7 @@ func (m *QueryGetParticipantResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Participant.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.EpochGroupData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -20786,7 +23725,7 @@ func (m *QueryGetParticipantResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllParticipantRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -20809,10 +23748,10 @@ func (m *QueryAllParticipantRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllParticipantRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllEpochGroupDataRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -20872,7 +23811,7 @@ func (m *QueryAllParticipantRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllParticipantResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -20895,15 +23834,15 @@ func (m *QueryAllParticipantResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllParticipantResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllEpochGroupDataResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -20930,8 +23869,8 @@ func (m *QueryAllParticipantResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Participant = append(m.Participant, Participant{})
-			if err := m.Participant[len(m.Participant)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.EpochGroupData = append(m.EpochGroupData, EpochGroupData{})
+			if err := m.EpochGroupData[len(m.EpochGroupData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -20971,11 +23910,61 @@ func (m *QueryAllParticipantResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.BlockHeight = 0
+			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 *QueryGetSettleAmountRequest) 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: QueryGetSettleAmountRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetSettleAmountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -20985,11 +23974,24 @@ func (m *QueryAllParticipantResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
+				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.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -21011,7 +24013,7 @@ func (m *QueryAllParticipantResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAccountByAddressRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetSettleAmountResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21034,17 +24036,17 @@ func (m *QueryAccountByAddressRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAccountByAddressRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetSettleAmountResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAccountByAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetSettleAmountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field SettleAmount", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -21054,23 +24056,24 @@ func (m *QueryAccountByAddressRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Address = string(dAtA[iNdEx:postIndex])
+			if err := m.SettleAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -21093,7 +24096,7 @@ func (m *QueryAccountByAddressRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAccountByAddressResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllSettleAmountRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21116,17 +24119,17 @@ func (m *QueryAccountByAddressResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAccountByAddressResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllSettleAmountRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAccountByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllSettleAmountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pubkey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -21136,29 +24139,83 @@ func (m *QueryAccountByAddressResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Pubkey = string(dAtA[iNdEx:postIndex])
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.Balance = 0
+			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 *QueryAllSettleAmountResponse) 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: QueryAllSettleAmountResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllSettleAmountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SettleAmount", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -21168,16 +24225,31 @@ func (m *QueryAccountByAddressResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Balance |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SettleAmount = append(m.SettleAmount, SettleAmount{})
+			if err := m.SettleAmount[len(m.SettleAmount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -21187,23 +24259,27 @@ func (m *QueryAccountByAddressResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Denom = string(dAtA[iNdEx:postIndex])
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -21226,7 +24302,7 @@ func (m *QueryAccountByAddressResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetRandomExecutorRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryEstimateBitcoinRewardRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21249,15 +24325,15 @@ func (m *QueryGetRandomExecutorRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetRandomExecutorRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEstimateBitcoinRewardRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetRandomExecutorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEstimateBitcoinRewardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -21285,7 +24361,7 @@ func (m *QueryGetRandomExecutorRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Model = string(dAtA[iNdEx:postIndex])
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -21308,7 +24384,7 @@ func (m *QueryGetRandomExecutorRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetRandomExecutorResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryEstimateBitcoinRewardResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21331,15 +24407,15 @@ func (m *QueryGetRandomExecutorResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetRandomExecutorResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEstimateBitcoinRewardResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetRandomExecutorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEstimateBitcoinRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Executor", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field SettleAmount", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -21366,7 +24442,7 @@ func (m *QueryGetRandomExecutorResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Executor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.SettleAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -21391,7 +24467,7 @@ func (m *QueryGetRandomExecutorResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21414,34 +24490,15 @@ func (m *QueryGetEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetEpochGroupDataRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-			}
-			m.EpochIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -21469,8 +24526,27 @@ func (m *QueryGetEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ModelId = string(dAtA[iNdEx:postIndex])
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			}
+			m.EpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -21492,7 +24568,7 @@ func (m *QueryGetEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21515,15 +24591,15 @@ func (m *QueryGetEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetEpochGroupDataResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupValidations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -21550,7 +24626,7 @@ func (m *QueryGetEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.EpochGroupData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.EpochGroupValidations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -21575,7 +24651,7 @@ func (m *QueryGetEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21598,10 +24674,10 @@ func (m *QueryAllEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllEpochGroupDataRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -21661,7 +24737,7 @@ func (m *QueryAllEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21684,15 +24760,15 @@ func (m *QueryAllEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllEpochGroupDataResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupValidations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -21719,8 +24795,8 @@ func (m *QueryAllEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.EpochGroupData = append(m.EpochGroupData, EpochGroupData{})
-			if err := m.EpochGroupData[len(m.EpochGroupData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.EpochGroupValidations = append(m.EpochGroupValidations, EpochGroupValidations{})
+			if err := m.EpochGroupValidations[len(m.EpochGroupValidations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -21781,7 +24857,7 @@ func (m *QueryAllEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetSettleAmountRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPocBatchesForStageRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21804,17 +24880,17 @@ func (m *QueryGetSettleAmountRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetSettleAmountRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPocBatchesForStageRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetSettleAmountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPocBatchesForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			var stringLen uint64
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -21824,24 +24900,11 @@ func (m *QueryGetSettleAmountRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.BlockHeight |= int64(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.Participant = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -21863,7 +24926,7 @@ func (m *QueryGetSettleAmountRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetSettleAmountResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPocBatchesForStageResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21886,15 +24949,15 @@ func (m *QueryGetSettleAmountResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetSettleAmountResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPocBatchesForStageResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetSettleAmountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPocBatchesForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SettleAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -21921,7 +24984,8 @@ func (m *QueryGetSettleAmountResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.SettleAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.PocBatch = append(m.PocBatch, PoCBatchesWithParticipants{})
+			if err := m.PocBatch[len(m.PocBatch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -21946,7 +25010,7 @@ func (m *QueryGetSettleAmountResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllSettleAmountRequest) Unmarshal(dAtA []byte) error {
+func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -21969,15 +25033,111 @@ func (m *QueryAllSettleAmountRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllSettleAmountRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: PoCBatchesWithParticipants: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllSettleAmountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PoCBatchesWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", 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.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", 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.PubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", 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.HexPubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -22004,10 +25164,8 @@ func (m *QueryAllSettleAmountRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.PocBatch = append(m.PocBatch, PoCBatch{})
+			if err := m.PocBatch[len(m.PocBatch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -22032,7 +25190,7 @@ func (m *QueryAllSettleAmountRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllSettleAmountResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPocValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22055,17 +25213,17 @@ func (m *QueryAllSettleAmountResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllSettleAmountResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPocValidationsForStageRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllSettleAmountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPocValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SettleAmount", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			var msglen int
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22075,29 +25233,64 @@ func (m *QueryAllSettleAmountResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.BlockHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.SettleAmount = append(m.SettleAmount, SettleAmount{})
-			if err := m.SettleAmount[len(m.SettleAmount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryPocValidationsForStageResponse) 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
 			}
-			iNdEx = postIndex
-		case 2:
+			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: QueryPocValidationsForStageResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryPocValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -22124,10 +25317,8 @@ func (m *QueryAllSettleAmountResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.PocValidation = append(m.PocValidation, PoCValidationsWithParticipants{})
+			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -22152,7 +25343,7 @@ func (m *QueryAllSettleAmountResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
+func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22175,10 +25366,10 @@ func (m *QueryGetEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: PoCValidationsWithParticipants: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PoCValidationsWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -22214,10 +25405,10 @@ func (m *QueryGetEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
 			}
-			m.EpochIndex = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22227,11 +25418,90 @@ func (m *QueryGetEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				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.PubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", 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.HexPubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PocValidation = append(m.PocValidation, PoCValidation{})
+			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -22253,7 +25523,7 @@ func (m *QueryGetEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPocV2ValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22276,17 +25546,17 @@ func (m *QueryGetEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupValidations", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			var msglen int
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22296,25 +25566,11 @@ func (m *QueryGetEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.BlockHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.EpochGroupValidations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -22336,7 +25592,7 @@ func (m *QueryGetEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPocV2ValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22359,15 +25615,15 @@ func (m *QueryAllEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllEpochGroupValidationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -22394,10 +25650,8 @@ func (m *QueryAllEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.PocValidation = append(m.PocValidation, PoCValidationsWithParticipantsV2{})
+			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -22422,7 +25676,7 @@ func (m *QueryAllEpochGroupValidationsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
+func (m *PoCValidationsWithParticipantsV2) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22445,17 +25699,17 @@ func (m *QueryAllEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: PoCValidationsWithParticipantsV2: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllEpochGroupValidationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PoCValidationsWithParticipantsV2: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupValidations", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22465,29 +25719,91 @@ func (m *QueryAllEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.EpochGroupValidations = append(m.EpochGroupValidations, EpochGroupValidations{})
-			if err := m.EpochGroupValidations[len(m.EpochGroupValidations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", 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.PubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", 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.HexPubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -22514,13 +25830,43 @@ func (m *QueryAllEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.PocValidation = append(m.PocValidation, PoCValidationV2{})
+			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", 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.ModelId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -22542,7 +25888,7 @@ func (m *QueryAllEpochGroupValidationsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPocBatchesForStageRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPoCV2StoreCommitRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22565,17 +25911,17 @@ func (m *QueryPocBatchesForStageRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPocBatchesForStageRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPocBatchesForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 			}
-			m.BlockHeight = 0
+			m.PocStageStartBlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22585,11 +25931,75 @@ func (m *QueryPocBatchesForStageRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
+				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", 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.ParticipantAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", 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.ModelId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -22611,7 +26021,7 @@ func (m *QueryPocBatchesForStageRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPocBatchesForStageResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPoCV2StoreCommitResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22634,17 +26044,36 @@ func (m *QueryPocBatchesForStageResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPocBatchesForStageResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPocBatchesForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+			}
+			m.Count = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Count |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22654,26 +26083,46 @@ func (m *QueryPocBatchesForStageResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PocBatch = append(m.PocBatch, PoCBatchesWithParticipants{})
-			if err := m.PocBatch[len(m.PocBatch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
+			if m.RootHash == nil {
+				m.RootHash = []byte{}
 			}
 			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -22695,7 +26144,7 @@ func (m *QueryPocBatchesForStageResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
+func (m *QueryMLNodeWeightDistributionRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22718,17 +26167,17 @@ func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PoCBatchesWithParticipants: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PoCBatchesWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 			}
-			var stringLen uint64
+			m.PocStageStartBlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22738,27 +26187,14 @@ func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.PocStageStartBlockHeight |= int64(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.Participant = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -22786,11 +26222,11 @@ func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PubKey = string(dAtA[iNdEx:postIndex])
+			m.ParticipantAddress = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -22818,11 +26254,61 @@ func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.HexPubKey = string(dAtA[iNdEx:postIndex])
+			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 4:
+		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 *QueryMLNodeWeightDistributionResponse) 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: QueryMLNodeWeightDistributionResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocBatch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -22849,11 +26335,31 @@ func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PocBatch = append(m.PocBatch, PoCBatch{})
-			if err := m.PocBatch[len(m.PocBatch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Weights = append(m.Weights, &MLNodeWeight{})
+			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -22875,7 +26381,7 @@ func (m *PoCBatchesWithParticipants) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPocValidationsForStageRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllPoCV2StoreCommitsForStageRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22898,17 +26404,17 @@ func (m *QueryPocValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPocValidationsForStageRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPocValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 			}
-			m.BlockHeight = 0
+			m.PocStageStartBlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -22918,7 +26424,7 @@ func (m *QueryPocValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
+				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -22944,7 +26450,7 @@ func (m *QueryPocValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPocValidationsForStageResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllPoCV2StoreCommitsForStageResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -22967,15 +26473,15 @@ func (m *QueryPocValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPocValidationsForStageResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPocValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Commits", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -23002,8 +26508,8 @@ func (m *QueryPocValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PocValidation = append(m.PocValidation, PoCValidationsWithParticipants{})
-			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Commits = append(m.Commits, &PoCV2StoreCommitWithAddress{})
+			if err := m.Commits[len(m.Commits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -23028,7 +26534,7 @@ func (m *QueryPocValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
+func (m *PoCV2StoreCommitWithAddress) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23051,15 +26557,15 @@ func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PoCValidationsWithParticipants: wiretype end group for non-group")
+			return fmt.Errorf("proto: PoCV2StoreCommitWithAddress: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PoCValidationsWithParticipants: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PoCV2StoreCommitWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -23087,13 +26593,32 @@ func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Participant = string(dAtA[iNdEx:postIndex])
+			m.ParticipantAddress = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+			}
+			m.Count = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Count |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
 			}
-			var stringLen uint64
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -23103,25 +26628,27 @@ func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PubKey = string(dAtA[iNdEx:postIndex])
+			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
+			if m.RootHash == nil {
+				m.RootHash = []byte{}
+			}
 			iNdEx = postIndex
-		case 3:
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", wireType)
 			}
@@ -23153,11 +26680,11 @@ func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 			}
 			m.HexPubKey = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 4:
+		case 5:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -23167,25 +26694,23 @@ func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PocValidation = append(m.PocValidation, PoCValidation{})
-			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -23208,7 +26733,7 @@ func (m *PoCValidationsWithParticipants) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPocV2ValidationsForStageRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllMLNodeWeightDistributionsForStageRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23231,17 +26756,17 @@ func (m *QueryPocV2ValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPocV2ValidationsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
 			}
-			m.BlockHeight = 0
+			m.PocStageStartBlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -23251,7 +26776,7 @@ func (m *QueryPocV2ValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
+				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -23277,7 +26802,7 @@ func (m *QueryPocV2ValidationsForStageRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPocV2ValidationsForStageResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllMLNodeWeightDistributionsForStageResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23300,15 +26825,15 @@ func (m *QueryPocV2ValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPocV2ValidationsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Distributions", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -23335,8 +26860,8 @@ func (m *QueryPocV2ValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PocValidation = append(m.PocValidation, PoCValidationsWithParticipantsV2{})
-			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Distributions = append(m.Distributions, &MLNodeWeightDistributionWithAddress{})
+			if err := m.Distributions[len(m.Distributions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -23361,7 +26886,7 @@ func (m *QueryPocV2ValidationsForStageResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *PoCValidationsWithParticipantsV2) Unmarshal(dAtA []byte) error {
+func (m *MLNodeWeightDistributionWithAddress) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23384,15 +26909,15 @@ func (m *PoCValidationsWithParticipantsV2) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PoCValidationsWithParticipantsV2: wiretype end group for non-group")
+			return fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PoCValidationsWithParticipantsV2: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -23420,75 +26945,11 @@ func (m *PoCValidationsWithParticipantsV2) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Participant = string(dAtA[iNdEx:postIndex])
+			m.ParticipantAddress = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", 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.PubKey = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", 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.HexPubKey = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocValidation", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -23515,12 +26976,12 @@ func (m *PoCValidationsWithParticipantsV2) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PocValidation = append(m.PocValidation, PoCValidationV2{})
-			if err := m.PocValidation[len(m.PocValidation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Weights = append(m.Weights, &MLNodeWeight{})
+			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
+		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
@@ -23573,7 +27034,7 @@ func (m *PoCValidationsWithParticipantsV2) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPoCV2StoreCommitRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetCurrentEpochRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23596,68 +27057,67 @@ func (m *QueryPoCV2StoreCommitRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetCurrentEpochRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPoCV2StoreCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetCurrentEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
-			}
-			m.PocStageStartBlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", 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
-				}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
 			}
-			if postIndex > l {
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryGetCurrentEpochResponse) 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
 			}
-			m.ParticipantAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
 			}
-			var stringLen uint64
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryGetCurrentEpochResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetCurrentEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
+			}
+			m.Epoch = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -23667,24 +27127,61 @@ func (m *QueryPoCV2StoreCommitRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.Epoch |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ModelId = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryGetTokenomicsDataRequest) 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: QueryGetTokenomicsDataRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetTokenomicsDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -23706,7 +27203,7 @@ func (m *QueryPoCV2StoreCommitRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPoCV2StoreCommitResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetTokenomicsDataResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23729,36 +27226,17 @@ func (m *QueryPoCV2StoreCommitResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetTokenomicsDataResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPoCV2StoreCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetTokenomicsDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
-			}
-			m.Count = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Count |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TokenomicsData", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -23768,46 +27246,25 @@ func (m *QueryPoCV2StoreCommitResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
-			if m.RootHash == nil {
-				m.RootHash = []byte{}
+			if err := m.TokenomicsData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -23829,7 +27286,7 @@ func (m *QueryPoCV2StoreCommitResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryMLNodeWeightDistributionRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetUnitOfComputePriceProposalRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23852,66 +27309,15 @@ func (m *QueryMLNodeWeightDistributionRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryMLNodeWeightDistributionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
-			}
-			m.PocStageStartBlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", 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.ParticipantAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -23939,7 +27345,7 @@ func (m *QueryMLNodeWeightDistributionRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ModelId = string(dAtA[iNdEx:postIndex])
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -23962,7 +27368,7 @@ func (m *QueryMLNodeWeightDistributionRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryMLNodeWeightDistributionResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetUnitOfComputePriceProposalResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -23985,15 +27391,15 @@ func (m *QueryMLNodeWeightDistributionResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryMLNodeWeightDistributionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -24020,16 +27426,18 @@ func (m *QueryMLNodeWeightDistributionResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Weights = append(m.Weights, &MLNodeWeight{})
-			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Proposal == nil {
+				m.Proposal = &UnitOfComputePriceProposal{}
+			}
+			if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
 			}
-			var v int
+			m.Default = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -24039,12 +27447,11 @@ func (m *QueryMLNodeWeightDistributionResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Default |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24066,7 +27473,7 @@ func (m *QueryMLNodeWeightDistributionResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllPoCV2StoreCommitsForStageRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryCurrentEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24089,31 +27496,12 @@ func (m *QueryAllPoCV2StoreCommitsForStageRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
-			}
-			m.PocStageStartBlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24135,7 +27523,7 @@ func (m *QueryAllPoCV2StoreCommitsForStageRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryAllPoCV2StoreCommitsForStageResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryCurrentEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24158,15 +27546,15 @@ func (m *QueryAllPoCV2StoreCommitsForStageResponse) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllPoCV2StoreCommitsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Commits", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -24193,8 +27581,7 @@ func (m *QueryAllPoCV2StoreCommitsForStageResponse) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Commits = append(m.Commits, &PoCV2StoreCommitWithAddress{})
-			if err := m.Commits[len(m.Commits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.EpochGroupData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -24219,7 +27606,7 @@ func (m *QueryAllPoCV2StoreCommitsForStageResponse) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *PoCV2StoreCommitWithAddress) Unmarshal(dAtA []byte) error {
+func (m *QueryPreviousEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24242,161 +27629,12 @@ func (m *PoCV2StoreCommitWithAddress) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: PoCV2StoreCommitWithAddress: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PoCV2StoreCommitWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", 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.ParticipantAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
-			}
-			m.Count = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Count |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
-			if m.RootHash == nil {
-				m.RootHash = []byte{}
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field HexPubKey", 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.HexPubKey = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", 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.ModelId = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24418,7 +27656,7 @@ func (m *PoCV2StoreCommitWithAddress) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllMLNodeWeightDistributionsForStageRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPreviousEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24441,17 +27679,17 @@ func (m *QueryAllMLNodeWeightDistributionsForStageRequest) Unmarshal(dAtA []byte
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartBlockHeight", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
 			}
-			m.PocStageStartBlockHeight = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -24461,11 +27699,25 @@ func (m *QueryAllMLNodeWeightDistributionsForStageRequest) Unmarshal(dAtA []byte
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.PocStageStartBlockHeight |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.EpochGroupData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24487,7 +27739,7 @@ func (m *QueryAllMLNodeWeightDistributionsForStageRequest) Unmarshal(dAtA []byte
 	}
 	return nil
 }
-func (m *QueryAllMLNodeWeightDistributionsForStageResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryModelsAllRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24510,15 +27762,15 @@ func (m *QueryAllMLNodeWeightDistributionsForStageResponse) Unmarshal(dAtA []byt
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryModelsAllRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllMLNodeWeightDistributionsForStageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryModelsAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Distributions", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -24545,8 +27797,10 @@ func (m *QueryAllMLNodeWeightDistributionsForStageResponse) Unmarshal(dAtA []byt
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Distributions = append(m.Distributions, &MLNodeWeightDistributionWithAddress{})
-			if err := m.Distributions[len(m.Distributions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -24571,7 +27825,7 @@ func (m *QueryAllMLNodeWeightDistributionsForStageResponse) Unmarshal(dAtA []byt
 	}
 	return nil
 }
-func (m *MLNodeWeightDistributionWithAddress) Unmarshal(dAtA []byte) error {
+func (m *QueryModelsAllResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24594,17 +27848,17 @@ func (m *MLNodeWeightDistributionWithAddress) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryModelsAllResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MLNodeWeightDistributionWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryModelsAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -24614,27 +27868,29 @@ func (m *MLNodeWeightDistributionWithAddress) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ParticipantAddress = string(dAtA[iNdEx:postIndex])
+			m.Model = append(m.Model, Model{})
+			if err := m.Model[len(m.Model)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -24661,42 +27917,12 @@ func (m *MLNodeWeightDistributionWithAddress) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Weights = append(m.Weights, &MLNodeWeight{})
-			if err := m.Weights[len(m.Weights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", 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 m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
 			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -24719,7 +27945,7 @@ func (m *MLNodeWeightDistributionWithAddress) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetCurrentEpochRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24742,12 +27968,63 @@ func (m *QueryGetCurrentEpochRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetCurrentEpochRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetCurrentEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationHeight", wireType)
+			}
+			m.ExpirationHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ExpirationHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InferenceId", 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.InferenceId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24769,7 +28046,7 @@ func (m *QueryGetCurrentEpochRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetCurrentEpochResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24792,17 +28069,17 @@ func (m *QueryGetCurrentEpochResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetCurrentEpochResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetCurrentEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InferenceTimeout", wireType)
 			}
-			m.Epoch = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -24812,11 +28089,25 @@ func (m *QueryGetCurrentEpochResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Epoch |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.InferenceTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24838,7 +28129,7 @@ func (m *QueryGetCurrentEpochResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetTokenomicsDataRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24861,12 +28152,48 @@ func (m *QueryGetTokenomicsDataRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetTokenomicsDataRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetTokenomicsDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -24888,7 +28215,7 @@ func (m *QueryGetTokenomicsDataRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetTokenomicsDataResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24911,15 +28238,15 @@ func (m *QueryGetTokenomicsDataResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetTokenomicsDataResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetTokenomicsDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenomicsData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field InferenceTimeout", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -24946,7 +28273,44 @@ func (m *QueryGetTokenomicsDataResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.TokenomicsData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.InferenceTimeout = append(m.InferenceTimeout, InferenceTimeout{})
+			if err := m.InferenceTimeout[len(m.InferenceTimeout)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -24971,7 +28335,7 @@ func (m *QueryGetTokenomicsDataResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetUnitOfComputePriceProposalRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -24994,15 +28358,34 @@ func (m *QueryGetUnitOfComputePriceProposalRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
+			}
+			m.EpochId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -25030,7 +28413,7 @@ func (m *QueryGetUnitOfComputePriceProposalRequest) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Participant = string(dAtA[iNdEx:postIndex])
+			m.InferenceId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -25053,7 +28436,7 @@ func (m *QueryGetUnitOfComputePriceProposalRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryGetUnitOfComputePriceProposalResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25076,15 +28459,15 @@ func (m *QueryGetUnitOfComputePriceProposalResponse) Unmarshal(dAtA []byte) erro
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetUnitOfComputePriceProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationDetails", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -25111,82 +28494,10 @@ func (m *QueryGetUnitOfComputePriceProposalResponse) Unmarshal(dAtA []byte) erro
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Proposal == nil {
-				m.Proposal = &UnitOfComputePriceProposal{}
-			}
-			if err := m.Proposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.InferenceValidationDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
-			}
-			m.Default = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Default |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		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 *QueryCurrentEpochGroupDataRequest) 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: QueryCurrentEpochGroupDataRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCurrentEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -25208,7 +28519,7 @@ func (m *QueryCurrentEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryCurrentEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25231,15 +28542,15 @@ func (m *QueryCurrentEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCurrentEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -25266,7 +28577,10 @@ func (m *QueryCurrentEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.EpochGroupData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -25291,7 +28605,7 @@ func (m *QueryCurrentEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPreviousEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25314,65 +28628,49 @@ func (m *QueryPreviousEpochGroupDataRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPreviousEpochGroupDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationDetails", wireType)
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthQuery
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *QueryPreviousEpochGroupDataResponse) 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
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
 			}
-			if iNdEx >= l {
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			m.InferenceValidationDetails = append(m.InferenceValidationDetails, InferenceValidationDetails{})
+			if err := m.InferenceValidationDetails[len(m.InferenceValidationDetails)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPreviousEpochGroupDataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+			iNdEx = postIndex
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochGroupData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -25399,7 +28697,10 @@ func (m *QueryPreviousEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.EpochGroupData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -25424,7 +28725,7 @@ func (m *QueryPreviousEpochGroupDataResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryModelsAllRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetInferenceValidationParametersRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25447,17 +28748,17 @@ func (m *QueryModelsAllRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryModelsAllRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryModelsAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -25467,27 +28768,55 @@ func (m *QueryModelsAllRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
+			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
 			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			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.Requester = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -25510,7 +28839,7 @@ func (m *QueryModelsAllRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryModelsAllResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25533,15 +28862,15 @@ func (m *QueryModelsAllResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryModelsAllResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryModelsAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorPowers", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -25568,14 +28897,33 @@ func (m *QueryModelsAllResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Model = append(m.Model, Model{})
-			if err := m.Model[len(m.Model)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.ValidatorPowers = append(m.ValidatorPowers, &ValidatorPower{})
+			if err := m.ValidatorPowers[len(m.ValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CurrentHeight", wireType)
+			}
+			m.CurrentHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CurrentHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -25602,87 +28950,16 @@ func (m *QueryModelsAllResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Details = append(m.Details, &InferenceValidationDetails{})
+			if err := m.Details[len(m.Details)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			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 *QueryGetInferenceTimeoutRequest) 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: QueryGetInferenceTimeoutRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationHeight", wireType)
-			}
-			m.ExpirationHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ExpirationHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
+		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -25692,23 +28969,27 @@ func (m *QueryGetInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.InferenceId = string(dAtA[iNdEx:postIndex])
+			if m.Parameters == nil {
+				m.Parameters = &ValidationParams{}
+			}
+			if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -25731,7 +29012,7 @@ func (m *QueryGetInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
+func (m *ValidatorPower) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25754,17 +29035,17 @@ func (m *QueryGetInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorPower: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InferenceTimeout", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
 			}
-			var msglen int
+			m.Power = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -25774,25 +29055,30 @@ func (m *QueryGetInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.Power |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			if err := m.InferenceTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.EpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -25814,7 +29100,7 @@ func (m *QueryGetInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryEpochPerformanceSummaryByEpochRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25837,17 +29123,17 @@ func (m *QueryAllInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllInferenceTimeoutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var msglen int
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -25857,28 +29143,11 @@ func (m *QueryAllInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -25900,7 +29169,7 @@ func (m *QueryAllInferenceTimeoutRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryEpochPerformanceSummaryByEpochResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -25923,49 +29192,15 @@ func (m *QueryAllInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllInferenceTimeoutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InferenceTimeout", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.InferenceTimeout = append(m.InferenceTimeout, InferenceTimeout{})
-			if err := m.InferenceTimeout[len(m.InferenceTimeout)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -25992,10 +29227,8 @@ func (m *QueryAllInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.EpochPerformanceSummary = append(m.EpochPerformanceSummary, EpochPerformanceSummary{})
+			if err := m.EpochPerformanceSummary[len(m.EpochPerformanceSummary)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -26020,7 +29253,7 @@ func (m *QueryAllInferenceTimeoutResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryEpochPerformanceSummaryByParticipantRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26043,17 +29276,17 @@ func (m *QueryGetInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			m.EpochId = 0
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -26063,14 +29296,14 @@ func (m *QueryGetInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochId |= uint64(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InferenceId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -26098,7 +29331,7 @@ func (m *QueryGetInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.InferenceId = string(dAtA[iNdEx:postIndex])
+			m.ParticipantId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -26121,7 +29354,7 @@ func (m *QueryGetInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryGetInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryEpochPerformanceSummaryByParticipantResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26144,15 +29377,15 @@ func (m *QueryGetInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) erro
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationDetails", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -26179,7 +29412,7 @@ func (m *QueryGetInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) erro
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.InferenceValidationDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.EpochPerformanceSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -26204,7 +29437,7 @@ func (m *QueryGetInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) erro
 	}
 	return nil
 }
-func (m *QueryAllInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllEpochPerformanceSummaryRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26227,10 +29460,10 @@ func (m *QueryAllInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -26290,7 +29523,7 @@ func (m *QueryAllInferenceValidationDetailsRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryAllInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllEpochPerformanceSummaryResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26313,15 +29546,15 @@ func (m *QueryAllInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) erro
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllInferenceValidationDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InferenceValidationDetails", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -26348,8 +29581,8 @@ func (m *QueryAllInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) erro
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.InferenceValidationDetails = append(m.InferenceValidationDetails, InferenceValidationDetails{})
-			if err := m.InferenceValidationDetails[len(m.InferenceValidationDetails)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.EpochPerformanceSummary = append(m.EpochPerformanceSummary, EpochPerformanceSummary{})
+			if err := m.EpochPerformanceSummary[len(m.EpochPerformanceSummary)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -26410,7 +29643,7 @@ func (m *QueryAllInferenceValidationDetailsResponse) Unmarshal(dAtA []byte) erro
 	}
 	return nil
 }
-func (m *QueryGetInferenceValidationParametersRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryHardwareNodesRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26433,47 +29666,15 @@ func (m *QueryGetInferenceValidationParametersRequest) Unmarshal(dAtA []byte) er
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryHardwareNodesRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryHardwareNodesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ids", 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.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -26501,7 +29702,7 @@ func (m *QueryGetInferenceValidationParametersRequest) Unmarshal(dAtA []byte) er
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Requester = string(dAtA[iNdEx:postIndex])
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -26524,7 +29725,7 @@ func (m *QueryGetInferenceValidationParametersRequest) Unmarshal(dAtA []byte) er
 	}
 	return nil
 }
-func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryHardwareNodesResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26547,15 +29748,15 @@ func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) e
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryHardwareNodesResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetInferenceValidationParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryHardwareNodesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorPowers", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -26582,33 +29783,116 @@ func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) e
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ValidatorPowers = append(m.ValidatorPowers, &ValidatorPower{})
-			if err := m.ValidatorPowers[len(m.ValidatorPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Nodes == nil {
+				m.Nodes = &HardwareNodes{}
+			}
+			if err := m.Nodes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CurrentHeight", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.CurrentHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CurrentHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
 			}
-		case 3:
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryHardwareNodesAllRequest) 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: QueryHardwareNodesAllRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryHardwareNodesAllRequest: 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 *QueryHardwareNodesAllResponse) 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: QueryHardwareNodesAllResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryHardwareNodesAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -26635,16 +29919,66 @@ func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) e
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Details = append(m.Details, &InferenceValidationDetails{})
-			if err := m.Details[len(m.Details)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Nodes = append(m.Nodes, &HardwareNodes{})
+			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 4:
+		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 *QueryGetParticipantCurrentStatsRequest) 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: QueryGetParticipantCurrentStatsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -26654,27 +29988,23 @@ func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) e
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Parameters == nil {
-				m.Parameters = &ValidationParams{}
-			}
-			if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.ParticipantId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -26697,7 +30027,7 @@ func (m *QueryGetInferenceValidationParametersResponse) Unmarshal(dAtA []byte) e
 	}
 	return nil
 }
-func (m *ValidatorPower) Unmarshal(dAtA []byte) error {
+func (m *QueryGetParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26720,17 +30050,17 @@ func (m *ValidatorPower) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorPower: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorPower: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
 			}
-			m.Power = 0
+			m.Weight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -26740,16 +30070,16 @@ func (m *ValidatorPower) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Power |= uint64(b&0x7F) << shift
+				m.Weight |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
 			}
-			m.EpochIndex = 0
+			m.Reputation = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -26759,7 +30089,7 @@ func (m *ValidatorPower) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				m.Reputation |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -26785,7 +30115,7 @@ func (m *ValidatorPower) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryEpochPerformanceSummaryByEpochRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetAllParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26808,31 +30138,12 @@ func (m *QueryEpochPerformanceSummaryByEpochRequest) Unmarshal(dAtA []byte) erro
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-			}
-			m.EpochIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -26854,7 +30165,7 @@ func (m *QueryEpochPerformanceSummaryByEpochRequest) Unmarshal(dAtA []byte) erro
 	}
 	return nil
 }
-func (m *QueryEpochPerformanceSummaryByEpochResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26877,15 +30188,15 @@ func (m *QueryEpochPerformanceSummaryByEpochResponse) Unmarshal(dAtA []byte) err
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByEpochResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantCurrentStats", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -26912,11 +30223,49 @@ func (m *QueryEpochPerformanceSummaryByEpochResponse) Unmarshal(dAtA []byte) err
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.EpochPerformanceSummary = append(m.EpochPerformanceSummary, EpochPerformanceSummary{})
-			if err := m.EpochPerformanceSummary[len(m.EpochPerformanceSummary)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.ParticipantCurrentStats = append(m.ParticipantCurrentStats, &ParticipantCurrentStats{})
+			if err := m.ParticipantCurrentStats[len(m.ParticipantCurrentStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+			}
+			m.BlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
+			}
+			m.EpochId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochId |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -26938,7 +30287,7 @@ func (m *QueryEpochPerformanceSummaryByEpochResponse) Unmarshal(dAtA []byte) err
 	}
 	return nil
 }
-func (m *QueryEpochPerformanceSummaryByParticipantRequest) Unmarshal(dAtA []byte) error {
+func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -26961,17 +30310,17 @@ func (m *QueryEpochPerformanceSummaryByParticipantRequest) Unmarshal(dAtA []byte
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ParticipantCurrentStats: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ParticipantCurrentStats: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
 			}
-			m.EpochIndex = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -26981,16 +30330,29 @@ func (m *QueryEpochPerformanceSummaryByParticipantRequest) Unmarshal(dAtA []byte
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				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.ParticipantId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
 			}
-			var stringLen uint64
+			m.Weight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27000,24 +30362,68 @@ func (m *QueryEpochPerformanceSummaryByParticipantRequest) Unmarshal(dAtA []byte
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.Weight |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
+			m.Reputation = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Reputation |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveWeight", wireType)
+			}
+			m.EffectiveWeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EffectiveWeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CappedWeight", wireType)
+			}
+			m.CappedWeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CappedWeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			m.ParticipantId = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27039,7 +30445,7 @@ func (m *QueryEpochPerformanceSummaryByParticipantRequest) Unmarshal(dAtA []byte
 	}
 	return nil
 }
-func (m *QueryEpochPerformanceSummaryByParticipantResponse) Unmarshal(dAtA []byte) error {
+func (m *ParticipantFullStats) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27062,17 +30468,17 @@ func (m *QueryEpochPerformanceSummaryByParticipantResponse) Unmarshal(dAtA []byt
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ParticipantFullStats: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryEpochPerformanceSummaryByParticipantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ParticipantFullStats: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27082,25 +30488,132 @@ func (m *QueryEpochPerformanceSummaryByParticipantResponse) Unmarshal(dAtA []byt
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.EpochPerformanceSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.AccountAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", 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.OperatorAddress = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
+			}
+			m.Reputation = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Reputation |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EarnedCoinsCurrentEpoch", wireType)
+			}
+			m.EarnedCoinsCurrentEpoch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EarnedCoinsCurrentEpoch |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RewardedCoinsLatestEpoch", wireType)
+			}
+			m.RewardedCoinsLatestEpoch = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RewardedCoinsLatestEpoch |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochsCompleted", wireType)
+			}
+			m.EpochsCompleted = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochsCompleted |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27122,7 +30635,7 @@ func (m *QueryEpochPerformanceSummaryByParticipantResponse) Unmarshal(dAtA []byt
 	}
 	return nil
 }
-func (m *QueryAllEpochPerformanceSummaryRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryParticipantsFullStatsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27145,48 +30658,12 @@ func (m *QueryAllEpochPerformanceSummaryRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParticipantsFullStatsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryParticipantsFullStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27208,7 +30685,7 @@ func (m *QueryAllEpochPerformanceSummaryRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllEpochPerformanceSummaryResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryParticipantsFullStatsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27231,49 +30708,15 @@ func (m *QueryAllEpochPerformanceSummaryResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParticipantsFullStatsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllEpochPerformanceSummaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryParticipantsFullStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochPerformanceSummary", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.EpochPerformanceSummary = append(m.EpochPerformanceSummary, EpochPerformanceSummary{})
-			if err := m.EpochPerformanceSummary[len(m.EpochPerformanceSummary)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantsStats", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -27300,10 +30743,8 @@ func (m *QueryAllEpochPerformanceSummaryResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.ParticipantsStats = append(m.ParticipantsStats, &ParticipantFullStats{})
+			if err := m.ParticipantsStats[len(m.ParticipantsStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -27328,7 +30769,7 @@ func (m *QueryAllEpochPerformanceSummaryResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryHardwareNodesRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryStatsByTimePeriodByDeveloperRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27351,15 +30792,15 @@ func (m *QueryHardwareNodesRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryHardwareNodesRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryHardwareNodesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -27387,8 +30828,46 @@ func (m *QueryHardwareNodesRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Participant = string(dAtA[iNdEx:postIndex])
+			m.Developer = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
+			}
+			m.TimeFrom = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TimeFrom |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+			}
+			m.TimeTo = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TimeTo |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27410,7 +30889,7 @@ func (m *QueryHardwareNodesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryHardwareNodesResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryStatsByTimePeriodByDeveloperResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27433,15 +30912,15 @@ func (m *QueryHardwareNodesResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryHardwareNodesResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryHardwareNodesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -27468,10 +30947,8 @@ func (m *QueryHardwareNodesResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Nodes == nil {
-				m.Nodes = &HardwareNodes{}
-			}
-			if err := m.Nodes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Stats = append(m.Stats, &DeveloperStatsByTime{})
+			if err := m.Stats[len(m.Stats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -27496,57 +30973,7 @@ func (m *QueryHardwareNodesResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryHardwareNodesAllRequest) 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: QueryHardwareNodesAllRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryHardwareNodesAllRequest: 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 *QueryHardwareNodesAllResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27569,17 +30996,17 @@ func (m *QueryHardwareNodesAllResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryHardwareNodesAllResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryHardwareNodesAllResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27589,26 +31016,43 @@ func (m *QueryHardwareNodesAllResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Nodes = append(m.Nodes, &HardwareNodes{})
-			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Developer = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
+			}
+			m.EpochsN = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochsN |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27630,7 +31074,7 @@ func (m *QueryHardwareNodesAllResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27653,17 +31097,17 @@ func (m *QueryGetParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
 			}
-			var stringLen uint64
+			m.EpochsN = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27673,24 +31117,11 @@ func (m *QueryGetParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.EpochsN |= int32(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.ParticipantId = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27712,7 +31143,7 @@ func (m *QueryGetParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27735,17 +31166,17 @@ func (m *QueryGetParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
 			}
-			m.Weight = 0
+			m.TimeFrom = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27755,16 +31186,16 @@ func (m *QueryGetParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Weight |= uint64(b&0x7F) << shift
+				m.TimeFrom |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 2:
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
 			}
-			m.Reputation = 0
+			m.TimeTo = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27774,7 +31205,7 @@ func (m *QueryGetParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Reputation |= int32(b&0x7F) << shift
+				m.TimeTo |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -27800,7 +31231,7 @@ func (m *QueryGetParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetAllParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryInferencesAndTokensStatsByModelsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27823,12 +31254,50 @@ func (m *QueryGetAllParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
+			}
+			m.TimeFrom = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TimeFrom |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+			}
+			m.TimeTo = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TimeTo |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -27850,7 +31319,7 @@ func (m *QueryGetAllParticipantCurrentStatsRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) error {
+func (m *ModelStats) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27873,17 +31342,17 @@ func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) erro
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ModelStats: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetAllParticipantCurrentStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ModelStats: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantCurrentStats", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27893,31 +31362,29 @@ func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) erro
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ParticipantCurrentStats = append(m.ParticipantCurrentStats, &ParticipantCurrentStats{})
-			if err := m.ParticipantCurrentStats[len(m.ParticipantCurrentStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Model = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
 			}
-			m.BlockHeight = 0
+			m.AiTokens = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27927,16 +31394,16 @@ func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) erro
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
+				m.AiTokens |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
 			}
-			m.EpochId = 0
+			m.Inferences = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -27946,7 +31413,7 @@ func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) erro
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochId |= int64(b&0x7F) << shift
+				m.Inferences |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -27972,7 +31439,7 @@ func (m *QueryGetAllParticipantCurrentStatsResponse) Unmarshal(dAtA []byte) erro
 	}
 	return nil
 }
-func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
+func (m *QueryInferencesAndTokensStatsByModelsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -27995,17 +31462,17 @@ func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ParticipantCurrentStats: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ParticipantCurrentStats: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StatsModels", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28015,48 +31482,81 @@ func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ParticipantId = string(dAtA[iNdEx:postIndex])
+			m.StatsModels = append(m.StatsModels, &ModelStats{})
+			if err := m.StatsModels[len(m.StatsModels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.Weight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Weight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
 			}
-		case 3:
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryInferencesAndTokensStatsResponse) 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: QueryInferencesAndTokensStatsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
 			}
-			m.Reputation = 0
+			m.AiTokens = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28066,16 +31566,16 @@ func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Reputation |= int32(b&0x7F) << shift
+				m.AiTokens |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 4:
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveWeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
 			}
-			m.EffectiveWeight = 0
+			m.Inferences = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28085,16 +31585,16 @@ func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EffectiveWeight |= uint64(b&0x7F) << shift
+				m.Inferences |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 5:
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CappedWeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ActualInferencesCost", wireType)
 			}
-			m.CappedWeight = 0
+			m.ActualInferencesCost = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28104,7 +31604,7 @@ func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CappedWeight |= uint64(b&0x7F) << shift
+				m.ActualInferencesCost |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -28130,7 +31630,7 @@ func (m *ParticipantCurrentStats) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ParticipantFullStats) Unmarshal(dAtA []byte) error {
+func (m *QueryCountAllParticipantsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28153,138 +31653,67 @@ func (m *ParticipantFullStats) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ParticipantFullStats: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCountAllParticipantsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ParticipantFullStats: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCountAllParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", 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
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.AccountAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", 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
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryCountAllParticipantsResponse) 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 postIndex > l {
+			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
 			}
-			m.OperatorAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Reputation", wireType)
-			}
-			m.Reputation = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Reputation |= int32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EarnedCoinsCurrentEpoch", wireType)
-			}
-			m.EarnedCoinsCurrentEpoch = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.EarnedCoinsCurrentEpoch |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RewardedCoinsLatestEpoch", wireType)
-			}
-			m.RewardedCoinsLatestEpoch = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.RewardedCoinsLatestEpoch |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
 			}
-		case 6:
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryCountAllParticipantsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryCountAllParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochsCompleted", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
 			}
-			m.EpochsCompleted = 0
+			m.Total = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28294,7 +31723,7 @@ func (m *ParticipantFullStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochsCompleted |= uint32(b&0x7F) << shift
+				m.Total |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -28320,7 +31749,7 @@ func (m *ParticipantFullStats) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryParticipantsFullStatsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryDebugStatsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28343,10 +31772,10 @@ func (m *QueryParticipantsFullStatsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParticipantsFullStatsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryDebugStatsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParticipantsFullStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryDebugStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		default:
@@ -28370,7 +31799,7 @@ func (m *QueryParticipantsFullStatsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryParticipantsFullStatsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryDebugStatsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28393,15 +31822,15 @@ func (m *QueryParticipantsFullStatsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParticipantsFullStatsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryDebugStatsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParticipantsFullStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryDebugStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantsStats", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StatsByTime", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -28428,8 +31857,42 @@ func (m *QueryParticipantsFullStatsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ParticipantsStats = append(m.ParticipantsStats, &ParticipantFullStats{})
-			if err := m.ParticipantsStats[len(m.ParticipantsStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.StatsByTime = append(m.StatsByTime, &QueryDebugStatsResponse_TemporaryTimeStat{})
+			if err := m.StatsByTime[len(m.StatsByTime)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StatsByEpoch", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.StatsByEpoch = append(m.StatsByEpoch, &QueryDebugStatsResponse_TemporaryEpochStat{})
+			if err := m.StatsByEpoch[len(m.StatsByEpoch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -28454,7 +31917,7 @@ func (m *QueryParticipantsFullStatsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryStatsByTimePeriodByDeveloperRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryDebugStatsResponse_TemporaryTimeStat) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28477,10 +31940,10 @@ func (m *QueryStatsByTimePeriodByDeveloperRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: TemporaryTimeStat: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: TemporaryTimeStat: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -28516,10 +31979,10 @@ func (m *QueryStatsByTimePeriodByDeveloperRequest) Unmarshal(dAtA []byte) error
 			m.Developer = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
 			}
-			m.TimeFrom = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28529,30 +31992,26 @@ func (m *QueryStatsByTimePeriodByDeveloperRequest) Unmarshal(dAtA []byte) error
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.TimeFrom |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
 			}
-			m.TimeTo = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.TimeTo |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stats = append(m.Stats, &DeveloperStatsByTime{})
+			if err := m.Stats[len(m.Stats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -28574,7 +32033,7 @@ func (m *QueryStatsByTimePeriodByDeveloperRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryStatsByTimePeriodByDeveloperResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryDebugStatsResponse_TemporaryEpochStat) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28597,13 +32056,45 @@ func (m *QueryStatsByTimePeriodByDeveloperResponse) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: TemporaryEpochStat: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryStatsByTimePeriodByDeveloperResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: TemporaryEpochStat: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Developer", 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.Developer = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
 			}
@@ -28632,7 +32123,7 @@ func (m *QueryStatsByTimePeriodByDeveloperResponse) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Stats = append(m.Stats, &DeveloperStatsByTime{})
+			m.Stats = append(m.Stats, &DeveloperStatsByEpoch{})
 			if err := m.Stats[len(m.Stats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -28658,7 +32149,7 @@ func (m *QueryStatsByTimePeriodByDeveloperResponse) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetMinimumValidationAverageRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28681,15 +32172,84 @@ func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) Unmarshal(dAtA []byte) e
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryStatsByDeveloperAndEpochBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: 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 *QueryGetMinimumValidationAverageResponse) 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: QueryGetMinimumValidationAverageResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TrafficBasis", wireType)
+			}
+			m.TrafficBasis = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TrafficBasis |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MinimumValidationAverage", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -28717,13 +32277,13 @@ func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) Unmarshal(dAtA []byte) e
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Developer = string(dAtA[iNdEx:postIndex])
+			m.MinimumValidationAverage = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 2:
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			m.EpochsN = 0
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28733,7 +32293,7 @@ func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) Unmarshal(dAtA []byte) e
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochsN |= int32(b&0x7F) << shift
+				m.BlockHeight |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -28759,7 +32319,7 @@ func (m *QueryStatsByDeveloperAndEpochBackwardsRequest) Unmarshal(dAtA []byte) e
 	}
 	return nil
 }
-func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28782,17 +32342,17 @@ func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Unmarshal(dAtA [
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetPartialUpgradeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByEpochsBackwardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochsN", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
 			}
-			m.EpochsN = 0
+			m.Height = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28802,7 +32362,7 @@ func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Unmarshal(dAtA [
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochsN |= int32(b&0x7F) << shift
+				m.Height |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -28828,7 +32388,7 @@ func (m *QueryInferencesAndTokensStatsByEpochsBackwardsRequest) Unmarshal(dAtA [
 	}
 	return nil
 }
-func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28851,17 +32411,17 @@ func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) Unmarshal(dAtA []byte
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetPartialUpgradeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByTimePeriodRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PartialUpgrade", wireType)
 			}
-			m.TimeFrom = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28871,16 +32431,80 @@ func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) Unmarshal(dAtA []byte
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.TimeFrom |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
 			}
-			m.TimeTo = 0
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PartialUpgrade.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			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 *QueryAllPartialUpgradeRequest) 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: QueryAllPartialUpgradeRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryAllPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28890,11 +32514,28 @@ func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) Unmarshal(dAtA []byte
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.TimeTo |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -28916,7 +32557,7 @@ func (m *QueryInferencesAndTokensStatsByTimePeriodRequest) Unmarshal(dAtA []byte
 	}
 	return nil
 }
-func (m *QueryInferencesAndTokensStatsByModelsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -28939,17 +32580,17 @@ func (m *QueryInferencesAndTokensStatsByModelsRequest) Unmarshal(dAtA []byte) er
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllPartialUpgradeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TimeFrom", wireType)
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PartialUpgrade", wireType)
 			}
-			m.TimeFrom = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28959,16 +32600,31 @@ func (m *QueryInferencesAndTokensStatsByModelsRequest) Unmarshal(dAtA []byte) er
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.TimeFrom |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TimeTo", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
 			}
-			m.TimeTo = 0
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PartialUpgrade = append(m.PartialUpgrade, PartialUpgrade{})
+			if err := m.PartialUpgrade[len(m.PartialUpgrade)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -28978,11 +32634,28 @@ func (m *QueryInferencesAndTokensStatsByModelsRequest) Unmarshal(dAtA []byte) er
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.TimeTo |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -29004,7 +32677,7 @@ func (m *QueryInferencesAndTokensStatsByModelsRequest) Unmarshal(dAtA []byte) er
 	}
 	return nil
 }
-func (m *ModelStats) Unmarshal(dAtA []byte) error {
+func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29027,15 +32700,15 @@ func (m *ModelStats) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ModelStats: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetBridgeTransactionRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ModelStats: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetBridgeTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field OriginChain", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -29063,13 +32736,13 @@ func (m *ModelStats) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Model = string(dAtA[iNdEx:postIndex])
+			m.OriginChain = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
 			}
-			m.AiTokens = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -29079,16 +32752,29 @@ func (m *ModelStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.AiTokens |= int64(b&0x7F) << shift
+				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.BlockNumber = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReceiptIndex", wireType)
 			}
-			m.Inferences = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -29098,11 +32784,24 @@ func (m *ModelStats) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Inferences |= int32(b&0x7F) << shift
+				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.ReceiptIndex = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -29124,7 +32823,7 @@ func (m *ModelStats) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryInferencesAndTokensStatsByModelsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetBridgeTransactionResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29147,15 +32846,15 @@ func (m *QueryInferencesAndTokensStatsByModelsResponse) Unmarshal(dAtA []byte) e
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetBridgeTransactionResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsByModelsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetBridgeTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StatsModels", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BridgeTransactions", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -29182,8 +32881,8 @@ func (m *QueryInferencesAndTokensStatsByModelsResponse) Unmarshal(dAtA []byte) e
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.StatsModels = append(m.StatsModels, &ModelStats{})
-			if err := m.StatsModels[len(m.StatsModels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.BridgeTransactions = append(m.BridgeTransactions, BridgeTransaction{})
+			if err := m.BridgeTransactions[len(m.BridgeTransactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -29208,7 +32907,7 @@ func (m *QueryInferencesAndTokensStatsByModelsResponse) Unmarshal(dAtA []byte) e
 	}
 	return nil
 }
-func (m *QueryInferencesAndTokensStatsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryAllBridgeTransactionsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29231,17 +32930,17 @@ func (m *QueryInferencesAndTokensStatsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryInferencesAndTokensStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AiTokens", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
-			m.AiTokens = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -29251,49 +32950,28 @@ func (m *QueryInferencesAndTokensStatsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.AiTokens |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
 			}
-			m.Inferences = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Inferences |= int32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
 			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ActualInferencesCost", wireType)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
 			}
-			m.ActualInferencesCost = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ActualInferencesCost |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -29315,7 +32993,7 @@ func (m *QueryInferencesAndTokensStatsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryCountAllParticipantsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryAllBridgeTransactionsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29338,12 +33016,82 @@ func (m *QueryCountAllParticipantsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryCountAllParticipantsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCountAllParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BridgeTransactions", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.BridgeTransactions = append(m.BridgeTransactions, BridgeTransaction{})
+			if err := m.BridgeTransactions[len(m.BridgeTransactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -29365,7 +33113,7 @@ func (m *QueryCountAllParticipantsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryCountAllParticipantsResponse) Unmarshal(dAtA []byte) error {
+func (m *WrappedTokenBalance) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29388,17 +33136,17 @@ func (m *QueryCountAllParticipantsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryCountAllParticipantsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: WrappedTokenBalance: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCountAllParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: WrappedTokenBalance: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TokenInfo", wireType)
 			}
-			m.Total = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -29408,61 +33156,156 @@ func (m *QueryCountAllParticipantsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Total |= int64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.TokenInfo == nil {
+				m.TokenInfo = &BridgeWrappedTokenContract{}
+			}
+			if err := m.TokenInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", 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
 			}
-			if (iNdEx + skippy) > l {
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *QueryDebugStatsRequest) 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
+			m.Symbol = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
 			}
-			if iNdEx >= l {
+			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
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			m.Balance = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: QueryDebugStatsRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryDebugStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
+			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.Decimals = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FormattedBalance", 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.FormattedBalance = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -29484,7 +33327,7 @@ func (m *QueryDebugStatsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryDebugStatsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryWrappedTokenBalancesRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29507,51 +33350,17 @@ func (m *QueryDebugStatsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryDebugStatsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryDebugStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StatsByTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.StatsByTime = append(m.StatsByTime, &QueryDebugStatsResponse_TemporaryTimeStat{})
-			if err := m.StatsByTime[len(m.StatsByTime)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StatsByEpoch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -29561,25 +33370,23 @@ func (m *QueryDebugStatsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.StatsByEpoch = append(m.StatsByEpoch, &QueryDebugStatsResponse_TemporaryEpochStat{})
-			if err := m.StatsByEpoch[len(m.StatsByEpoch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Address = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -29602,7 +33409,7 @@ func (m *QueryDebugStatsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryDebugStatsResponse_TemporaryTimeStat) Unmarshal(dAtA []byte) error {
+func (m *QueryWrappedTokenBalancesResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29625,47 +33432,15 @@ func (m *QueryDebugStatsResponse_TemporaryTimeStat) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: TemporaryTimeStat: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TemporaryTimeStat: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Developer", 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.Developer = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -29692,8 +33467,8 @@ func (m *QueryDebugStatsResponse_TemporaryTimeStat) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Stats = append(m.Stats, &DeveloperStatsByTime{})
-			if err := m.Stats[len(m.Stats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Balances = append(m.Balances, &WrappedTokenBalance{})
+			if err := m.Balances[len(m.Balances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -29718,7 +33493,7 @@ func (m *QueryDebugStatsResponse_TemporaryTimeStat) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryDebugStatsResponse_TemporaryEpochStat) Unmarshal(dAtA []byte) error {
+func (m *QueryBridgeAddressesByChainRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29741,15 +33516,15 @@ func (m *QueryDebugStatsResponse_TemporaryEpochStat) Unmarshal(dAtA []byte) erro
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: TemporaryEpochStat: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TemporaryEpochStat: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Developer", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -29777,41 +33552,7 @@ func (m *QueryDebugStatsResponse_TemporaryEpochStat) Unmarshal(dAtA []byte) erro
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Developer = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Stats = append(m.Stats, &DeveloperStatsByEpoch{})
-			if err := m.Stats[len(m.Stats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.ChainId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -29834,7 +33575,7 @@ func (m *QueryDebugStatsResponse_TemporaryEpochStat) Unmarshal(dAtA []byte) erro
 	}
 	return nil
 }
-func (m *QueryGetMinimumValidationAverageRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryBridgeAddressesByChainResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29857,12 +33598,46 @@ func (m *QueryGetMinimumValidationAverageRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetMinimumValidationAverageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Addresses = append(m.Addresses, BridgeContractAddress{})
+			if err := m.Addresses[len(m.Addresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -29884,7 +33659,7 @@ func (m *QueryGetMinimumValidationAverageRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetMinimumValidationAverageResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryValidateWrappedTokenForTradeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -29907,34 +33682,15 @@ func (m *QueryGetMinimumValidationAverageResponse) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetMinimumValidationAverageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TrafficBasis", wireType)
-			}
-			m.TrafficBasis = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.TrafficBasis |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinimumValidationAverage", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -29962,27 +33718,8 @@ func (m *QueryGetMinimumValidationAverageResponse) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.MinimumValidationAverage = string(dAtA[iNdEx:postIndex])
+			m.ContractAddress = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
-			}
-			m.BlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.BlockHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30004,7 +33741,7 @@ func (m *QueryGetMinimumValidationAverageResponse) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryGetPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryValidateWrappedTokenForTradeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30027,17 +33764,17 @@ func (m *QueryGetPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetPartialUpgradeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IsValid", wireType)
 			}
-			m.Height = 0
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30047,11 +33784,12 @@ func (m *QueryGetPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Height |= uint64(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			m.IsValid = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30073,7 +33811,7 @@ func (m *QueryGetPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryValidateIbcTokenForTradeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30096,17 +33834,17 @@ func (m *QueryGetPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetPartialUpgradeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PartialUpgrade", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30116,24 +33854,23 @@ func (m *QueryGetPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.PartialUpgrade.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.IbcDenom = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -30156,7 +33893,7 @@ func (m *QueryGetPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryValidateIbcTokenForTradeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30179,17 +33916,17 @@ func (m *QueryAllPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllPartialUpgradeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllPartialUpgradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsValid", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30199,28 +33936,81 @@ func (m *QueryAllPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
+			m.IsValid = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			m.Decimals = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Decimals |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryLiquidityPoolRequest) 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 err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-			iNdEx = postIndex
+			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: QueryLiquidityPoolRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryLiquidityPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30242,7 +34032,7 @@ func (m *QueryAllPartialUpgradeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30265,17 +34055,17 @@ func (m *QueryAllPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllPartialUpgradeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryLiquidityPoolResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllPartialUpgradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PartialUpgrade", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30285,31 +34075,29 @@ func (m *QueryAllPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.PartialUpgrade = append(m.PartialUpgrade, PartialUpgrade{})
-			if err := m.PartialUpgrade[len(m.PartialUpgrade)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Address = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
 			}
-			var msglen int
+			m.CodeId = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30319,28 +34107,80 @@ func (m *QueryAllPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.CodeId |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			m.BlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryEpochInfoRequest) 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 err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-			iNdEx = postIndex
+			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: QueryEpochInfoRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryEpochInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30362,7 +34202,7 @@ func (m *QueryAllPartialUpgradeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30385,17 +34225,36 @@ func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetBridgeTransactionRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryEpochInfoResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetBridgeTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryEpochInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+			}
+			m.BlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OriginChain", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30405,29 +34264,30 @@ func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.OriginChain = string(dAtA[iNdEx:postIndex])
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
-		case 2:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field LatestEpoch", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30437,29 +34297,50 @@ func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.BlockNumber = string(dAtA[iNdEx:postIndex])
+			if err := m.LatestEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
-		case 3:
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsConfirmationPocActive", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IsConfirmationPocActive = bool(v != 0)
+		case 5:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReceiptIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ActiveConfirmationPocEvent", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30469,23 +34350,27 @@ func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ReceiptIndex = string(dAtA[iNdEx:postIndex])
+			if m.ActiveConfirmationPocEvent == nil {
+				m.ActiveConfirmationPocEvent = &ConfirmationPoCEvent{}
+			}
+			if err := m.ActiveConfirmationPocEvent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -30508,7 +34393,7 @@ func (m *QueryGetBridgeTransactionRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetBridgeTransactionResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryCountPoCbatchesAtHeightRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30531,17 +34416,17 @@ func (m *QueryGetBridgeTransactionResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetBridgeTransactionResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetBridgeTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BridgeTransactions", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			var msglen int
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30551,26 +34436,11 @@ func (m *QueryGetBridgeTransactionResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.BlockHeight |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.BridgeTransactions = append(m.BridgeTransactions, BridgeTransaction{})
-			if err := m.BridgeTransactions[len(m.BridgeTransactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30592,7 +34462,7 @@ func (m *QueryGetBridgeTransactionResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllBridgeTransactionsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryCountPoCbatchesAtHeightResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30615,17 +34485,17 @@ func (m *QueryAllBridgeTransactionsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllBridgeTransactionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
 			}
-			var msglen int
+			m.Count = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30635,28 +34505,11 @@ func (m *QueryAllBridgeTransactionsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.Count |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30678,7 +34531,7 @@ func (m *QueryAllBridgeTransactionsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryAllBridgeTransactionsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryCountPoCvalidationsAtHeightRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30701,51 +34554,17 @@ func (m *QueryAllBridgeTransactionsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryAllBridgeTransactionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BridgeTransactions", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.BridgeTransactions = append(m.BridgeTransactions, BridgeTransaction{})
-			if err := m.BridgeTransactions[len(m.BridgeTransactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			var msglen int
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30755,28 +34574,11 @@ func (m *QueryAllBridgeTransactionsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.BlockHeight |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -30798,7 +34600,7 @@ func (m *QueryAllBridgeTransactionsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *WrappedTokenBalance) Unmarshal(dAtA []byte) error {
+func (m *QueryCountPoCvalidationsAtHeightResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -30821,149 +34623,17 @@ func (m *WrappedTokenBalance) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: WrappedTokenBalance: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: WrappedTokenBalance: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenInfo", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.TokenInfo == nil {
-				m.TokenInfo = &BridgeWrappedTokenContract{}
-			}
-			if err := m.TokenInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", 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.Symbol = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Balance", 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.Balance = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", 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.Decimals = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field FormattedBalance", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
 			}
-			var stringLen uint64
+			m.Count = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -30973,24 +34643,11 @@ func (m *WrappedTokenBalance) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.Count |= 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.FormattedBalance = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31012,7 +34669,7 @@ func (m *WrappedTokenBalance) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryWrappedTokenBalancesRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryApprovedTokensForTradeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31035,44 +34692,12 @@ func (m *QueryWrappedTokenBalancesRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryWrappedTokenBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31094,7 +34719,7 @@ func (m *QueryWrappedTokenBalancesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryWrappedTokenBalancesResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryApprovedTokensForTradeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31117,15 +34742,15 @@ func (m *QueryWrappedTokenBalancesResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryWrappedTokenBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ApprovedTokens", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -31152,8 +34777,8 @@ func (m *QueryWrappedTokenBalancesResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Balances = append(m.Balances, &WrappedTokenBalance{})
-			if err := m.Balances[len(m.Balances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.ApprovedTokens = append(m.ApprovedTokens, BridgeTokenReference{})
+			if err := m.ApprovedTokens[len(m.ApprovedTokens)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -31178,7 +34803,7 @@ func (m *QueryWrappedTokenBalancesResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryBridgeAddressesByChainRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetModelPerTokenPriceRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31201,15 +34826,15 @@ func (m *QueryBridgeAddressesByChainRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryBridgeAddressesByChainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -31237,7 +34862,7 @@ func (m *QueryBridgeAddressesByChainRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ChainId = string(dAtA[iNdEx:postIndex])
+			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -31260,7 +34885,7 @@ func (m *QueryBridgeAddressesByChainRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryBridgeAddressesByChainResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetModelPerTokenPriceResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31283,17 +34908,17 @@ func (m *QueryBridgeAddressesByChainResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryBridgeAddressesByChainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
 			}
-			var msglen int
+			m.Price = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31303,26 +34928,81 @@ func (m *QueryBridgeAddressesByChainResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.Price |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Found = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Addresses = append(m.Addresses, BridgeContractAddress{})
-			if err := m.Addresses[len(m.Addresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryGetAllModelPerTokenPricesRequest) 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
 			}
-			iNdEx = postIndex
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31344,7 +35024,7 @@ func (m *QueryBridgeAddressesByChainResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryValidateWrappedTokenForTradeRequest) Unmarshal(dAtA []byte) error {
+func (m *ModelPrice) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31367,15 +35047,15 @@ func (m *QueryValidateWrappedTokenForTradeRequest) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ModelPrice: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ModelPrice: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -31403,8 +35083,27 @@ func (m *QueryValidateWrappedTokenForTradeRequest) Unmarshal(dAtA []byte) error
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ContractAddress = string(dAtA[iNdEx:postIndex])
+			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+			}
+			m.Price = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Price |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31426,7 +35125,7 @@ func (m *QueryValidateWrappedTokenForTradeRequest) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryValidateWrappedTokenForTradeResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetAllModelPerTokenPricesResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31449,17 +35148,17 @@ func (m *QueryValidateWrappedTokenForTradeResponse) Unmarshal(dAtA []byte) error
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryValidateWrappedTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsValid", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelPrices", wireType)
 			}
-			var v int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31469,12 +35168,26 @@ func (m *QueryValidateWrappedTokenForTradeResponse) Unmarshal(dAtA []byte) error
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.IsValid = bool(v != 0)
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ModelPrices = append(m.ModelPrices, ModelPrice{})
+			if err := m.ModelPrices[len(m.ModelPrices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31496,7 +35209,7 @@ func (m *QueryValidateWrappedTokenForTradeResponse) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryValidateIbcTokenForTradeRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetModelCapacityRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31519,15 +35232,15 @@ func (m *QueryValidateIbcTokenForTradeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetModelCapacityRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetModelCapacityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -31555,7 +35268,7 @@ func (m *QueryValidateIbcTokenForTradeRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.IbcDenom = string(dAtA[iNdEx:postIndex])
+			m.ModelId = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -31578,7 +35291,7 @@ func (m *QueryValidateIbcTokenForTradeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryValidateIbcTokenForTradeResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetModelCapacityResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31601,17 +35314,17 @@ func (m *QueryValidateIbcTokenForTradeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetModelCapacityResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryValidateIbcTokenForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetModelCapacityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsValid", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
 			}
-			var v int
+			m.Capacity = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31621,17 +35334,16 @@ func (m *QueryValidateIbcTokenForTradeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Capacity |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.IsValid = bool(v != 0)
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
-			m.Decimals = 0
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31641,11 +35353,12 @@ func (m *QueryValidateIbcTokenForTradeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Decimals |= uint32(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31667,7 +35380,7 @@ func (m *QueryValidateIbcTokenForTradeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryLiquidityPoolRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetAllModelCapacitiesRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31690,10 +35403,10 @@ func (m *QueryLiquidityPoolRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryLiquidityPoolRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryLiquidityPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		default:
@@ -31717,7 +35430,7 @@ func (m *QueryLiquidityPoolRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetAllModelCapacitiesResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31740,17 +35453,17 @@ func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryLiquidityPoolResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryLiquidityPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelCapacities", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31760,29 +35473,81 @@ func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Address = string(dAtA[iNdEx:postIndex])
+			m.ModelCapacities = append(m.ModelCapacities, ModelCapacity{})
+			if err := m.ModelCapacities[len(m.ModelCapacities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CodeId", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.CodeId = 0
+			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 *ModelCapacity) 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: ModelCapacity: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ModelCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+			}
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31792,16 +35557,29 @@ func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CodeId |= uint64(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ModelId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
 			}
-			m.BlockHeight = 0
+			m.Capacity = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31811,7 +35589,7 @@ func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= uint64(b&0x7F) << shift
+				m.Capacity |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -31837,7 +35615,7 @@ func (m *QueryLiquidityPoolResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryEpochInfoRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGranteesByMessageTypeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31860,12 +35638,76 @@ func (m *QueryEpochInfoRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryEpochInfoRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryEpochInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GranterAddress", 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.GranterAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MessageTypeUrl", 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.MessageTypeUrl = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -31887,7 +35729,7 @@ func (m *QueryEpochInfoRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
+func (m *Grantee) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -31910,36 +35752,17 @@ func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryEpochInfoResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: Grantee: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryEpochInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Grantee: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
-			}
-			m.BlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31949,30 +35772,29 @@ func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Address = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LatestEpoch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -31982,48 +35804,77 @@ func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.LatestEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.PubKey = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
 				return err
 			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsConfirmationPocActive", wireType)
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
 			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
 			}
-			m.IsConfirmationPocActive = bool(v != 0)
-		case 5:
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryGranteesByMessageTypeResponse) 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: QueryGranteesByMessageTypeResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ActiveConfirmationPocEvent", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Grantees", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -32050,10 +35901,8 @@ func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ActiveConfirmationPocEvent == nil {
-				m.ActiveConfirmationPocEvent = &ConfirmationPoCEvent{}
-			}
-			if err := m.ActiveConfirmationPocEvent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Grantees = append(m.Grantees, &Grantee{})
+			if err := m.Grantees[len(m.Grantees)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -32078,7 +35927,7 @@ func (m *QueryEpochInfoResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryCountPoCbatchesAtHeightRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryParticipantAllowListRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32101,31 +35950,12 @@ func (m *QueryCountPoCbatchesAtHeightRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParticipantAllowListRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryParticipantAllowListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
-			}
-			m.BlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.BlockHeight |= int32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32147,7 +35977,7 @@ func (m *QueryCountPoCbatchesAtHeightRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryCountPoCbatchesAtHeightResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryParticipantAllowListResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32170,17 +36000,17 @@ func (m *QueryCountPoCbatchesAtHeightResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParticipantAllowListResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCountPoCbatchesAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryParticipantAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
 			}
-			m.Count = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32190,11 +36020,74 @@ func (m *QueryCountPoCbatchesAtHeightResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= uint64(b&0x7F) << shift
+				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.Addresses = append(m.Addresses, 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 *QueryGetMLNodeVersionRequest) 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: QueryGetMLNodeVersionRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetMLNodeVersionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32216,7 +36109,7 @@ func (m *QueryCountPoCbatchesAtHeightResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryCountPoCvalidationsAtHeightRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetMLNodeVersionResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32239,17 +36132,17 @@ func (m *QueryCountPoCvalidationsAtHeightRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetMLNodeVersionResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetMLNodeVersionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MlnodeVersion", wireType)
 			}
-			m.BlockHeight = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32259,80 +36152,25 @@ func (m *QueryCountPoCvalidationsAtHeightRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int32(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *QueryCountPoCvalidationsAtHeightResponse) 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
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
 			}
-			if iNdEx >= l {
+			if postIndex > 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: QueryCountPoCvalidationsAtHeightResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryCountPoCvalidationsAtHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
-			}
-			m.Count = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Count |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if err := m.MlnodeVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32354,7 +36192,7 @@ func (m *QueryCountPoCvalidationsAtHeightResponse) Unmarshal(dAtA []byte) error
 	}
 	return nil
 }
-func (m *QueryApprovedTokensForTradeRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetLastUpgradeHeightRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32377,10 +36215,10 @@ func (m *QueryApprovedTokensForTradeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetLastUpgradeHeightRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryApprovedTokensForTradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetLastUpgradeHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		default:
@@ -32404,7 +36242,7 @@ func (m *QueryApprovedTokensForTradeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryApprovedTokensForTradeResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetLastUpgradeHeightResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32427,17 +36265,17 @@ func (m *QueryApprovedTokensForTradeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetLastUpgradeHeightResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryApprovedTokensForTradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetLastUpgradeHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ApprovedTokens", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastUpgradeHeight", wireType)
 			}
-			var msglen int
+			m.LastUpgradeHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32447,26 +36285,31 @@ func (m *QueryApprovedTokensForTradeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.LastUpgradeHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
-			m.ApprovedTokens = append(m.ApprovedTokens, BridgeTokenReference{})
-			if err := m.ApprovedTokens[len(m.ApprovedTokens)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			iNdEx = postIndex
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32488,7 +36331,7 @@ func (m *QueryApprovedTokensForTradeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetModelPerTokenPriceRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryExcludedParticipantsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32511,17 +36354,17 @@ func (m *QueryGetModelPerTokenPriceRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryExcludedParticipantsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetModelPerTokenPriceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryExcludedParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var stringLen uint64
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32531,24 +36374,11 @@ func (m *QueryGetModelPerTokenPriceRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.EpochIndex |= 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.ModelId = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32570,7 +36400,7 @@ func (m *QueryGetModelPerTokenPriceRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetModelPerTokenPriceResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryExcludedParticipantsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32593,17 +36423,17 @@ func (m *QueryGetModelPerTokenPriceResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryExcludedParticipantsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetModelPerTokenPriceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryExcludedParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 			}
-			m.Price = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32613,31 +36443,26 @@ func (m *QueryGetModelPerTokenPriceResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Price |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
 			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
 			}
-			m.Found = bool(v != 0)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Items = append(m.Items, &ExcludedParticipant{})
+			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32659,7 +36484,7 @@ func (m *QueryGetModelPerTokenPriceResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetAllModelPerTokenPricesRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryActiveConfirmationPoCEventRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32682,10 +36507,10 @@ func (m *QueryGetAllModelPerTokenPricesRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		default:
@@ -32709,7 +36534,7 @@ func (m *QueryGetAllModelPerTokenPricesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ModelPrice) Unmarshal(dAtA []byte) error {
+func (m *QueryActiveConfirmationPoCEventResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32732,17 +36557,17 @@ func (m *ModelPrice) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ModelPrice: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ModelPrice: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
 			}
-			var stringLen uint64
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32752,29 +36577,17 @@ func (m *ModelPrice) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				v |= int(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.ModelId = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
+			m.IsActive = bool(v != 0)
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
 			}
-			m.Price = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32784,11 +36597,28 @@ func (m *ModelPrice) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Price |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Event == nil {
+				m.Event = &ConfirmationPoCEvent{}
+			}
+			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32810,7 +36640,7 @@ func (m *ModelPrice) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetAllModelPerTokenPricesResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryConfirmationPoCEventsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32833,17 +36663,17 @@ func (m *QueryGetAllModelPerTokenPricesResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetAllModelPerTokenPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelPrices", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var msglen int
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32853,26 +36683,11 @@ func (m *QueryGetAllModelPerTokenPricesResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ModelPrices = append(m.ModelPrices, ModelPrice{})
-			if err := m.ModelPrices[len(m.ModelPrices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -32894,7 +36709,7 @@ func (m *QueryGetAllModelPerTokenPricesResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetModelCapacityRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryConfirmationPoCEventsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32917,17 +36732,17 @@ func (m *QueryGetModelCapacityRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetModelCapacityRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetModelCapacityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -32937,23 +36752,25 @@ func (m *QueryGetModelCapacityRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ModelId = string(dAtA[iNdEx:postIndex])
+			m.Events = append(m.Events, &ConfirmationPoCEvent{})
+			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -32976,7 +36793,7 @@ func (m *QueryGetModelCapacityRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetModelCapacityResponse) Unmarshal(dAtA []byte) error {
+func (m *ParticipantWithBalance) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -32999,17 +36816,17 @@ func (m *QueryGetModelCapacityResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetModelCapacityResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ParticipantWithBalance: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetModelCapacityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ParticipantWithBalance: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
-			m.Capacity = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33019,16 +36836,30 @@ func (m *QueryGetModelCapacityResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Capacity |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Participant.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
 			}
-			var v int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33038,62 +36869,26 @@ func (m *QueryGetModelCapacityResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Found = bool(v != 0)
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *QueryGetAllModelCapacitiesRequest) 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
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
 			}
-			if iNdEx >= l {
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			m.Balances = append(m.Balances, types.Coin{})
+			if err := m.Balances[len(m.Balances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetAllModelCapacitiesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -33115,7 +36910,7 @@ func (m *QueryGetAllModelCapacitiesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetAllModelCapacitiesResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryParticipantsWithBalancesRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33138,15 +36933,15 @@ func (m *QueryGetAllModelCapacitiesResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetAllModelCapacitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelCapacities", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -33173,8 +36968,10 @@ func (m *QueryGetAllModelCapacitiesResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ModelCapacities = append(m.ModelCapacities, ModelCapacity{})
-			if err := m.ModelCapacities[len(m.ModelCapacities)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Pagination == nil {
+				m.Pagination = &query.PageRequest{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -33199,7 +36996,7 @@ func (m *QueryGetAllModelCapacitiesResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ModelCapacity) Unmarshal(dAtA []byte) error {
+func (m *QueryParticipantsWithBalancesResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33222,17 +37019,17 @@ func (m *ModelCapacity) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ModelCapacity: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ModelCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModelId", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33242,29 +37039,67 @@ func (m *ModelCapacity) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ModelId = string(dAtA[iNdEx:postIndex])
+			m.Participants = append(m.Participants, ParticipantWithBalance{})
+			if err := m.Participants[len(m.Participants)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Pagination == nil {
+				m.Pagination = &query.PageResponse{}
+			}
+			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			m.Capacity = 0
+			m.BlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33274,7 +37109,7 @@ func (m *ModelCapacity) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Capacity |= uint64(b&0x7F) << shift
+				m.BlockHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -33300,7 +37135,7 @@ func (m *ModelCapacity) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGranteesByMessageTypeRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryRandomSeedsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33323,49 +37158,17 @@ func (m *QueryGranteesByMessageTypeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryRandomSeedsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGranteesByMessageTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryRandomSeedsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GranterAddress", 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.GranterAddress = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MessageTypeUrl", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var stringLen uint64
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33375,24 +37178,11 @@ func (m *QueryGranteesByMessageTypeRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.EpochIndex |= 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.MessageTypeUrl = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -33414,7 +37204,7 @@ func (m *QueryGranteesByMessageTypeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Grantee) Unmarshal(dAtA []byte) error {
+func (m *QueryRandomSeedsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33437,17 +37227,17 @@ func (m *Grantee) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Grantee: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryRandomSeedsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Grantee: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryRandomSeedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Seeds", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33457,55 +37247,25 @@ func (m *Grantee) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Address = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", 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.Seeds = append(m.Seeds, &RandomSeed{})
+			if err := m.Seeds[len(m.Seeds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-			m.PubKey = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -33528,7 +37288,7 @@ func (m *Grantee) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGranteesByMessageTypeResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPoCValidationSnapshotRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33551,17 +37311,17 @@ func (m *QueryGranteesByMessageTypeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGranteesByMessageTypeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Grantees", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartHeight", wireType)
 			}
-			var msglen int
+			m.PocStageStartHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33571,76 +37331,11 @@ func (m *QueryGranteesByMessageTypeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.PocStageStartHeight |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Grantees = append(m.Grantees, &Grantee{})
-			if err := m.Grantees[len(m.Grantees)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			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 *QueryParticipantAllowListRequest) 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: QueryParticipantAllowListRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParticipantAllowListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -33662,7 +37357,7 @@ func (m *QueryParticipantAllowListRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryParticipantAllowListResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPoCValidationSnapshotResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33685,17 +37380,17 @@ func (m *QueryParticipantAllowListResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParticipantAllowListResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParticipantAllowListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33705,24 +37400,48 @@ func (m *QueryParticipantAllowListResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
+			if m.Snapshot == nil {
+				m.Snapshot = &PoCValidationSnapshot{}
+			}
+			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -33744,7 +37463,7 @@ func (m *QueryParticipantAllowListResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetMLNodeVersionRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryPreservedNodesSnapshotRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33767,10 +37486,10 @@ func (m *QueryGetMLNodeVersionRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetMLNodeVersionRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetMLNodeVersionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		default:
@@ -33794,7 +37513,7 @@ func (m *QueryGetMLNodeVersionRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetMLNodeVersionResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryPreservedNodesSnapshotResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33817,15 +37536,15 @@ func (m *QueryGetMLNodeVersionResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetMLNodeVersionResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetMLNodeVersionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MlnodeVersion", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -33852,10 +37571,33 @@ func (m *QueryGetMLNodeVersionResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.MlnodeVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Snapshot == nil {
+				m.Snapshot = &PreservedNodesSnapshot{}
+			}
+			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -33877,7 +37619,7 @@ func (m *QueryGetMLNodeVersionResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryExcludedParticipantsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetDevshardEscrowRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33900,17 +37642,17 @@ func (m *QueryExcludedParticipantsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryExcludedParticipantsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetDevshardEscrowRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryExcludedParticipantsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetDevshardEscrowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
 			}
-			m.EpochIndex = 0
+			m.Id = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -33920,7 +37662,7 @@ func (m *QueryExcludedParticipantsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				m.Id |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -33946,7 +37688,7 @@ func (m *QueryExcludedParticipantsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryExcludedParticipantsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetDevshardEscrowResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -33969,15 +37711,15 @@ func (m *QueryExcludedParticipantsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryExcludedParticipantsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetDevshardEscrowResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryExcludedParticipantsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Escrow", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -34004,11 +37746,33 @@ func (m *QueryExcludedParticipantsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Items = append(m.Items, &ExcludedParticipant{})
-			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Escrow == nil {
+				m.Escrow = &DevshardEscrow{}
+			}
+			if err := m.Escrow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34030,7 +37794,7 @@ func (m *QueryExcludedParticipantsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryActiveConfirmationPoCEventRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryGetDevshardHostEpochStatsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34053,12 +37817,63 @@ func (m *QueryActiveConfirmationPoCEventRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			}
+			m.EpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", 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.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34080,7 +37895,7 @@ func (m *QueryActiveConfirmationPoCEventRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryActiveConfirmationPoCEventResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryGetDevshardHostEpochStatsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34103,35 +37918,15 @@ func (m *QueryActiveConfirmationPoCEventResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryActiveConfirmationPoCEventResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.IsActive = bool(v != 0)
-		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -34158,68 +37953,18 @@ func (m *QueryActiveConfirmationPoCEventResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Event == nil {
-				m.Event = &ConfirmationPoCEvent{}
+			if m.Stats == nil {
+				m.Stats = &DevshardHostEpochStats{}
 			}
-			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			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 *QueryConfirmationPoCEventsRequest) 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: QueryConfirmationPoCEventsRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryConfirmationPoCEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
-			m.EpochIndex = 0
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34229,11 +37974,12 @@ func (m *QueryConfirmationPoCEventsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34255,7 +38001,7 @@ func (m *QueryConfirmationPoCEventsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryConfirmationPoCEventsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceCreditRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34278,17 +38024,17 @@ func (m *QueryConfirmationPoCEventsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceCreditRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryConfirmationPoCEventsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceCreditRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34298,25 +38044,23 @@ func (m *QueryConfirmationPoCEventsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Events = append(m.Events, &ConfirmationPoCEvent{})
-			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -34339,7 +38083,7 @@ func (m *QueryConfirmationPoCEventsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ParticipantWithBalance) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceCreditResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34362,17 +38106,17 @@ func (m *ParticipantWithBalance) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ParticipantWithBalance: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceCreditResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ParticipantWithBalance: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceCreditResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreditBlocks", wireType)
 			}
-			var msglen int
+			m.CreditBlocks = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34382,30 +38126,16 @@ func (m *ParticipantWithBalance) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.CreditBlocks |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Participant.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Balances", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34415,26 +38145,12 @@ func (m *ParticipantWithBalance) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Balances = append(m.Balances, types.Coin{})
-			if err := m.Balances[len(m.Balances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34456,7 +38172,7 @@ func (m *ParticipantWithBalance) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryParticipantsWithBalancesRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceScheduledRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34479,17 +38195,17 @@ func (m *QueryParticipantsWithBalancesRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceScheduledRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParticipantsWithBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceScheduledRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34499,27 +38215,23 @@ func (m *QueryParticipantsWithBalancesRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageRequest{}
-			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -34542,7 +38254,7 @@ func (m *QueryParticipantsWithBalancesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryParticipantsWithBalancesResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceScheduledResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34565,49 +38277,15 @@ func (m *QueryParticipantsWithBalancesResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceScheduledResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryParticipantsWithBalancesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceScheduledResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Participants = append(m.Participants, ParticipantWithBalance{})
-			if err := m.Participants[len(m.Participants)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Reservation", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -34634,18 +38312,18 @@ func (m *QueryParticipantsWithBalancesResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Pagination == nil {
-				m.Pagination = &query.PageResponse{}
+			if m.Reservation == nil {
+				m.Reservation = &MaintenanceReservation{}
 			}
-			if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Reservation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
-			m.BlockHeight = 0
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34655,11 +38333,12 @@ func (m *QueryParticipantsWithBalancesResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BlockHeight |= int64(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34681,7 +38360,7 @@ func (m *QueryParticipantsWithBalancesResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryRandomSeedsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceActiveRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34704,31 +38383,12 @@ func (m *QueryRandomSeedsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryRandomSeedsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceActiveRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryRandomSeedsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceActiveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-			}
-			m.EpochIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34750,7 +38410,7 @@ func (m *QueryRandomSeedsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryRandomSeedsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceActiveResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34773,15 +38433,15 @@ func (m *QueryRandomSeedsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryRandomSeedsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceActiveResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryRandomSeedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceActiveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Seeds", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Reservations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -34808,8 +38468,8 @@ func (m *QueryRandomSeedsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Seeds = append(m.Seeds, &RandomSeed{})
-			if err := m.Seeds[len(m.Seeds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Reservations = append(m.Reservations, &MaintenanceReservation{})
+			if err := m.Reservations[len(m.Reservations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -34834,7 +38494,7 @@ func (m *QueryRandomSeedsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPoCValidationSnapshotRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceStatusRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34857,17 +38517,17 @@ func (m *QueryPoCValidationSnapshotRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceStatusRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPoCValidationSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PocStageStartHeight", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
-			m.PocStageStartHeight = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -34877,11 +38537,24 @@ func (m *QueryPoCValidationSnapshotRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.PocStageStartHeight |= int64(b&0x7F) << shift
+				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.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -34903,7 +38576,7 @@ func (m *QueryPoCValidationSnapshotRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPoCValidationSnapshotResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceStatusResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -34926,15 +38599,15 @@ func (m *QueryPoCValidationSnapshotResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceStatusResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPoCValidationSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -34961,14 +38634,86 @@ func (m *QueryPoCValidationSnapshotResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Snapshot == nil {
-				m.Snapshot = &PoCValidationSnapshot{}
+			if m.State == nil {
+				m.State = &MaintenanceState{}
 			}
-			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ActiveReservation", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ActiveReservation == nil {
+				m.ActiveReservation = &MaintenanceReservation{}
+			}
+			if err := m.ActiveReservation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ScheduledReservation", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ScheduledReservation == nil {
+				m.ScheduledReservation = &MaintenanceReservation{}
+			}
+			if err := m.ScheduledReservation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
 			}
@@ -35009,7 +38754,7 @@ func (m *QueryPoCValidationSnapshotResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPreservedNodesSnapshotRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceConcurrencyRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -35032,12 +38777,31 @@ func (m *QueryPreservedNodesSnapshotRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceConcurrencyRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPreservedNodesSnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceConcurrencyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			m.Height = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Height |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -35059,7 +38823,7 @@ func (m *QueryPreservedNodesSnapshotRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryPreservedNodesSnapshotResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceConcurrencyResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -35082,17 +38846,17 @@ func (m *QueryPreservedNodesSnapshotResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceConcurrencyResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryPreservedNodesSnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceConcurrencyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConcurrentCount", wireType)
 			}
-			var msglen int
+			m.ConcurrentCount = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -35102,33 +38866,16 @@ func (m *QueryPreservedNodesSnapshotResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.ConcurrentCount |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Snapshot == nil {
-				m.Snapshot = &PreservedNodesSnapshot{}
-			}
-			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ConcurrentPowerBps", wireType)
 			}
-			var v int
+			m.ConcurrentPowerBps = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -35138,12 +38885,11 @@ func (m *QueryPreservedNodesSnapshotResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.ConcurrentPowerBps |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -35165,7 +38911,7 @@ func (m *QueryPreservedNodesSnapshotResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetDevshardEscrowRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceSchedulabilityRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -35188,17 +38934,49 @@ func (m *QueryGetDevshardEscrowRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetDevshardEscrowRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceSchedulabilityRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetDevshardEscrowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceSchedulabilityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", 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.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
 			}
-			m.Id = 0
+			m.StartHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -35208,7 +38986,26 @@ func (m *QueryGetDevshardEscrowRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Id |= uint64(b&0x7F) << shift
+				m.StartHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DurationBlocks", wireType)
+			}
+			m.DurationBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DurationBlocks |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -35234,7 +39031,7 @@ func (m *QueryGetDevshardEscrowRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetDevshardEscrowResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryMaintenanceSchedulabilityResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -35257,17 +39054,17 @@ func (m *QueryGetDevshardEscrowResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetDevshardEscrowResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMaintenanceSchedulabilityResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetDevshardEscrowResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMaintenanceSchedulabilityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Escrow", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Schedulable", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -35277,33 +39074,17 @@ func (m *QueryGetDevshardEscrowResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Escrow == nil {
-				m.Escrow = &DevshardEscrow{}
-			}
-			if err := m.Escrow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
+			m.Schedulable = bool(v != 0)
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RejectionReason", wireType)
 			}
-			var v int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -35313,12 +39094,24 @@ func (m *QueryGetDevshardEscrowResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Found = bool(v != 0)
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RejectionReason = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -35340,7 +39133,7 @@ func (m *QueryGetDevshardEscrowResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetDevshardHostEpochStatsRequest) Unmarshal(dAtA []byte) error {
+func (m *QueryListClaimRecipientsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -35363,32 +39156,13 @@ func (m *QueryGetDevshardHostEpochStatsRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryListClaimRecipientsRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryListClaimRecipientsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
-			}
-			m.EpochIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
 			}
@@ -35441,7 +39215,7 @@ func (m *QueryGetDevshardHostEpochStatsRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryGetDevshardHostEpochStatsResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryListClaimRecipientsResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -35464,15 +39238,15 @@ func (m *QueryGetDevshardHostEpochStatsResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryListClaimRecipientsResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryGetDevshardHostEpochStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryListClaimRecipientsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -35499,33 +39273,11 @@ func (m *QueryGetDevshardHostEpochStatsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Stats == nil {
-				m.Stats = &DevshardHostEpochStats{}
-			}
-			if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Entries = append(m.Entries, ClaimRecipientEntry{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.Found = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
diff --git a/inference-chain/x/inference/types/query.pb.gw.go b/inference-chain/x/inference/types/query.pb.gw.go
index 945bc5c2f0..6b92c94e17 100644
--- a/inference-chain/x/inference/types/query.pb.gw.go
+++ b/inference-chain/x/inference/types/query.pb.gw.go
@@ -519,6 +519,60 @@ func local_request_Query_SettleAmountAll_0(ctx context.Context, marshaler runtim
 
 }
 
+func request_Query_EstimateBitcoinReward_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryEstimateBitcoinRewardRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := client.EstimateBitcoinReward(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_EstimateBitcoinReward_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryEstimateBitcoinRewardRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := server.EstimateBitcoinReward(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Query_EpochGroupValidations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq QueryGetEpochGroupValidationsRequest
 	var metadata runtime.ServerMetadata
@@ -2997,6 +3051,24 @@ func local_request_Query_MLNodeVersion_0(ctx context.Context, marshaler runtime.
 
 }
 
+func request_Query_LastUpgradeHeight_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryGetLastUpgradeHeightRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.LastUpgradeHeight(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_LastUpgradeHeight_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryGetLastUpgradeHeightRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.LastUpgradeHeight(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Query_ParticipantAllowList_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq QueryParticipantAllowListRequest
 	var metadata runtime.ServerMetadata
@@ -3505,172 +3577,558 @@ func local_request_Query_PoCDelegation_0(ctx context.Context, marshaler runtime.
 
 }
 
-// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
-// UnaryRPC     :call QueryServer directly.
-// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
-// 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 {
+func request_Query_MaintenanceCredit_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceCreditRequest
+	var metadata runtime.ServerMetadata
 
-	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()
-		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_Params_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
-		}
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
 
-		forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
 
-	})
+	protoReq.Participant, err = runtime.String(val)
 
-	mux.Handle("GET", pattern_Query_Inference_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_Inference_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
-		}
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
 
-		forward_Query_Inference_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	msg, err := client.MaintenanceCredit(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
 
-	})
+}
 
-	mux.Handle("GET", pattern_Query_InferenceAll_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_InferenceAll_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
-		}
+func local_request_Query_MaintenanceCredit_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceCreditRequest
+	var metadata runtime.ServerMetadata
 
-		forward_Query_InferenceAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
 
-	})
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
 
-	mux.Handle("GET", pattern_Query_Participant_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_Participant_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
-		}
+	protoReq.Participant, err = runtime.String(val)
 
-		forward_Query_Participant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
 
-	})
+	msg, err := server.MaintenanceCredit(ctx, &protoReq)
+	return msg, metadata, err
 
-	mux.Handle("GET", pattern_Query_ParticipantAll_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_ParticipantAll_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_ParticipantAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+func request_Query_MaintenanceScheduled_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceScheduledRequest
+	var metadata runtime.ServerMetadata
 
-	})
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
 
-	mux.Handle("GET", pattern_Query_AccountByAddress_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_AccountByAddress_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
-		}
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
 
-		forward_Query_AccountByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	protoReq.Participant, err = runtime.String(val)
 
-	})
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
 
-	mux.Handle("GET", pattern_Query_GetRandomExecutor_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_GetRandomExecutor_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
-		}
+	msg, err := client.MaintenanceScheduled(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
 
-		forward_Query_GetRandomExecutor_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+}
 
-	})
+func local_request_Query_MaintenanceScheduled_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceScheduledRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := server.MaintenanceScheduled(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_MaintenanceActive_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceActiveRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.MaintenanceActive(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_MaintenanceActive_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceActiveRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.MaintenanceActive(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_MaintenanceStatus_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceStatusRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := client.MaintenanceStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_MaintenanceStatus_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceStatusRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := server.MaintenanceStatus(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_MaintenanceConcurrency_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceConcurrencyRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
+	}
+
+	protoReq.Height, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
+	}
+
+	msg, err := client.MaintenanceConcurrency(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_MaintenanceConcurrency_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceConcurrencyRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
+	}
+
+	protoReq.Height, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
+	}
+
+	msg, err := server.MaintenanceConcurrency(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_MaintenanceSchedulability_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceSchedulabilityRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	val, ok = pathParams["start_height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "start_height")
+	}
+
+	protoReq.StartHeight, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "start_height", err)
+	}
+
+	val, ok = pathParams["duration_blocks"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "duration_blocks")
+	}
+
+	protoReq.DurationBlocks, err = runtime.Uint64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "duration_blocks", err)
+	}
+
+	msg, err := client.MaintenanceSchedulability(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_MaintenanceSchedulability_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryMaintenanceSchedulabilityRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	val, ok = pathParams["start_height"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "start_height")
+	}
+
+	protoReq.StartHeight, err = runtime.Int64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "start_height", err)
+	}
+
+	val, ok = pathParams["duration_blocks"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "duration_blocks")
+	}
+
+	protoReq.DurationBlocks, err = runtime.Uint64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "duration_blocks", err)
+	}
+
+	msg, err := server.MaintenanceSchedulability(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Query_ListClaimRecipients_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryListClaimRecipientsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := client.ListClaimRecipients(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_ListClaimRecipients_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryListClaimRecipientsRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["participant"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "participant")
+	}
+
+	protoReq.Participant, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "participant", err)
+	}
+
+	msg, err := server.ListClaimRecipients(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
+// UnaryRPC     :call QueryServer directly.
+// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
+// 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_Params_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_Params_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_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_Inference_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_Inference_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_Inference_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_InferenceAll_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_InferenceAll_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_InferenceAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_Participant_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_Participant_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_Participant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_ParticipantAll_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_ParticipantAll_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_ParticipantAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_AccountByAddress_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_AccountByAddress_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_AccountByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetRandomExecutor_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_GetRandomExecutor_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_GetRandomExecutor_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
 
 	mux.Handle("GET", pattern_Query_EpochGroupData_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
@@ -3764,6 +4222,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_EstimateBitcoinReward_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_EstimateBitcoinReward_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_EstimateBitcoinReward_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_EpochGroupValidations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -4856,7 +5337,191 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_CountPoCvalidationsAtHeight_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_CountPoCvalidationsAtHeight_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_CountPoCvalidationsAtHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetModelPerTokenPrice_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_GetModelPerTokenPrice_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_GetModelPerTokenPrice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetAllModelPerTokenPrices_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_GetAllModelPerTokenPrices_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_GetAllModelPerTokenPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetModelCapacity_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_GetModelCapacity_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_GetModelCapacity_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GetAllModelCapacities_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_GetAllModelCapacities_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_GetAllModelCapacities_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_GranteesByMessageType_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_GranteesByMessageType_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_GranteesByMessageType_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_MLNodeVersion_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_MLNodeVersion_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_MLNodeVersion_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_LastUpgradeHeight_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_LastUpgradeHeight_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_LastUpgradeHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_ParticipantAllowList_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_ParticipantAllowList_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 {
@@ -4864,11 +5529,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_CountPoCvalidationsAtHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ParticipantAllowList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_GetModelPerTokenPrice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_ExcludedParticipants_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -4879,7 +5544,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_GetModelPerTokenPrice_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_ExcludedParticipants_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 {
@@ -4887,11 +5552,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_GetModelPerTokenPrice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ExcludedParticipants_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_GetAllModelPerTokenPrices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_ActiveConfirmationPoCEvent_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -4902,7 +5567,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_GetAllModelPerTokenPrices_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_ActiveConfirmationPoCEvent_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 {
@@ -4910,11 +5575,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_GetAllModelPerTokenPrices_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ActiveConfirmationPoCEvent_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_GetModelCapacity_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_ListConfirmationPoCEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -4925,7 +5590,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_GetModelCapacity_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_ListConfirmationPoCEvents_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 {
@@ -4933,11 +5598,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_GetModelCapacity_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ListConfirmationPoCEvents_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_GetAllModelCapacities_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_ListRandomSeeds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -4948,7 +5613,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_GetAllModelCapacities_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_ListRandomSeeds_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 {
@@ -4956,11 +5621,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_GetAllModelCapacities_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ListRandomSeeds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_GranteesByMessageType_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_ParticipantsWithBalances_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -4971,7 +5636,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_GranteesByMessageType_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_ParticipantsWithBalances_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 {
@@ -4979,11 +5644,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_GranteesByMessageType_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ParticipantsWithBalances_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_MLNodeVersion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_PoCValidationSnapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -4994,7 +5659,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_MLNodeVersion_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_PoCValidationSnapshot_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 {
@@ -5002,11 +5667,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_MLNodeVersion_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_PoCValidationSnapshot_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_ParticipantAllowList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_DevshardEscrow_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5017,7 +5682,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_ParticipantAllowList_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_DevshardEscrow_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 {
@@ -5025,11 +5690,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_ParticipantAllowList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_DevshardEscrow_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_ExcludedParticipants_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_PreservedNodesSnapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5040,7 +5705,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_ExcludedParticipants_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_PreservedNodesSnapshot_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 {
@@ -5048,11 +5713,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_ExcludedParticipants_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_PreservedNodesSnapshot_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_ActiveConfirmationPoCEvent_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_DevshardHostEpochStats_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5063,7 +5728,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_ActiveConfirmationPoCEvent_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_DevshardHostEpochStats_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 {
@@ -5071,11 +5736,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_ActiveConfirmationPoCEvent_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_DevshardHostEpochStats_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_ListConfirmationPoCEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_PoCDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5086,7 +5751,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_ListConfirmationPoCEvents_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_PoCDelegation_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 {
@@ -5094,11 +5759,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_ListConfirmationPoCEvents_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_PoCDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_ListRandomSeeds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_MaintenanceCredit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5109,7 +5774,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_ListRandomSeeds_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_MaintenanceCredit_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 {
@@ -5117,11 +5782,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_ListRandomSeeds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_MaintenanceCredit_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_ParticipantsWithBalances_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_MaintenanceScheduled_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5132,7 +5797,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_ParticipantsWithBalances_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_MaintenanceScheduled_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 {
@@ -5140,11 +5805,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_ParticipantsWithBalances_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_MaintenanceScheduled_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_PoCValidationSnapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_MaintenanceActive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5155,7 +5820,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_PoCValidationSnapshot_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_MaintenanceActive_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 {
@@ -5163,11 +5828,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_PoCValidationSnapshot_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_MaintenanceActive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_DevshardEscrow_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_MaintenanceStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5178,7 +5843,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_DevshardEscrow_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_MaintenanceStatus_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 {
@@ -5186,11 +5851,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_DevshardEscrow_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_MaintenanceStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_PreservedNodesSnapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_MaintenanceConcurrency_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5201,7 +5866,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_PreservedNodesSnapshot_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_MaintenanceConcurrency_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 {
@@ -5209,11 +5874,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_PreservedNodesSnapshot_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_MaintenanceConcurrency_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_DevshardHostEpochStats_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_MaintenanceSchedulability_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5224,7 +5889,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_DevshardHostEpochStats_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_MaintenanceSchedulability_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 {
@@ -5232,11 +5897,11 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_DevshardHostEpochStats_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_MaintenanceSchedulability_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Query_PoCDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Query_ListClaimRecipients_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 		var stream runtime.ServerTransportStream
@@ -5247,7 +5912,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 			return
 		}
-		resp, md, err := local_request_Query_PoCDelegation_0(rctx, inboundMarshaler, server, req, pathParams)
+		resp, md, err := local_request_Query_ListClaimRecipients_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 {
@@ -5255,7 +5920,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 			return
 		}
 
-		forward_Query_PoCDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Query_ListClaimRecipients_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -5520,6 +6185,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_EstimateBitcoinReward_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_EstimateBitcoinReward_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_EstimateBitcoinReward_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_EpochGroupValidations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -6600,6 +7285,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_LastUpgradeHeight_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_LastUpgradeHeight_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_LastUpgradeHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_ParticipantAllowList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -6820,6 +7525,146 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_MaintenanceCredit_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_MaintenanceCredit_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_MaintenanceCredit_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_MaintenanceScheduled_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_MaintenanceScheduled_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_MaintenanceScheduled_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_MaintenanceActive_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_MaintenanceActive_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_MaintenanceActive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_MaintenanceStatus_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_MaintenanceStatus_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_MaintenanceStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_MaintenanceConcurrency_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_MaintenanceConcurrency_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_MaintenanceConcurrency_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_MaintenanceSchedulability_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_MaintenanceSchedulability_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_MaintenanceSchedulability_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("GET", pattern_Query_ListClaimRecipients_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_ListClaimRecipients_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_ListClaimRecipients_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -6846,6 +7691,8 @@ var (
 
 	pattern_Query_SettleAmountAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"productscience", "inference", "settle_amount"}, "", runtime.AssumeColonVerbOpt(true)))
 
+	pattern_Query_EstimateBitcoinReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "estimate_bitcoin_reward", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
+
 	pattern_Query_EpochGroupValidations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"productscience", "inference", "epoch_group_validations", "participant", "epoch_index"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_EpochGroupValidationsAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"productscience", "inference", "epoch_group_validations"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -6954,6 +7801,8 @@ var (
 
 	pattern_Query_MLNodeVersion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"productscience", "inference", "mlnode_version"}, "", runtime.AssumeColonVerbOpt(true)))
 
+	pattern_Query_LastUpgradeHeight_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"productscience", "inference", "last_upgrade_height"}, "", runtime.AssumeColonVerbOpt(true)))
+
 	pattern_Query_ParticipantAllowList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"productscience", "inference", "participant_allow_list"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_ExcludedParticipants_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "excluded_participants", "epoch_index"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -6975,6 +7824,20 @@ var (
 	pattern_Query_DevshardHostEpochStats_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"productscience", "inference", "devshard_host_epoch_stats", "epoch_index", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_PoCDelegation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "poc_delegation", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_MaintenanceCredit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "maintenance_credit", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_MaintenanceScheduled_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "maintenance_scheduled", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_MaintenanceActive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"productscience", "inference", "maintenance_active"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_MaintenanceStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "maintenance_status", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_MaintenanceConcurrency_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "maintenance_concurrency", "height"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_MaintenanceSchedulability_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"productscience", "inference", "maintenance_schedulability", "participant", "start_height", "duration_blocks"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_ListClaimRecipients_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"productscience", "inference", "list_claim_recipients", "participant"}, "", runtime.AssumeColonVerbOpt(true)))
 )
 
 var (
@@ -7000,6 +7863,8 @@ var (
 
 	forward_Query_SettleAmountAll_0 = runtime.ForwardResponseMessage
 
+	forward_Query_EstimateBitcoinReward_0 = runtime.ForwardResponseMessage
+
 	forward_Query_EpochGroupValidations_0 = runtime.ForwardResponseMessage
 
 	forward_Query_EpochGroupValidationsAll_0 = runtime.ForwardResponseMessage
@@ -7108,6 +7973,8 @@ var (
 
 	forward_Query_MLNodeVersion_0 = runtime.ForwardResponseMessage
 
+	forward_Query_LastUpgradeHeight_0 = runtime.ForwardResponseMessage
+
 	forward_Query_ParticipantAllowList_0 = runtime.ForwardResponseMessage
 
 	forward_Query_ExcludedParticipants_0 = runtime.ForwardResponseMessage
@@ -7129,4 +7996,18 @@ var (
 	forward_Query_DevshardHostEpochStats_0 = runtime.ForwardResponseMessage
 
 	forward_Query_PoCDelegation_0 = runtime.ForwardResponseMessage
+
+	forward_Query_MaintenanceCredit_0 = runtime.ForwardResponseMessage
+
+	forward_Query_MaintenanceScheduled_0 = runtime.ForwardResponseMessage
+
+	forward_Query_MaintenanceActive_0 = runtime.ForwardResponseMessage
+
+	forward_Query_MaintenanceStatus_0 = runtime.ForwardResponseMessage
+
+	forward_Query_MaintenanceConcurrency_0 = runtime.ForwardResponseMessage
+
+	forward_Query_MaintenanceSchedulability_0 = runtime.ForwardResponseMessage
+
+	forward_Query_ListClaimRecipients_0 = runtime.ForwardResponseMessage
 )
diff --git a/inference-chain/x/inference/types/settle_amount.go b/inference-chain/x/inference/types/settle_amount.go
index 12625466c7..1eda3e25e1 100644
--- a/inference-chain/x/inference/types/settle_amount.go
+++ b/inference-chain/x/inference/types/settle_amount.go
@@ -1,10 +1,14 @@
 package types
 
-import "math"
+import (
+	"math"
+	"math/bits"
+)
 
+// saturate to MaxInt64 on overflow — a wrapped sum can silently zero a real payout downstream.
 func (sa *SettleAmount) GetTotalCoins() int64 {
-	sum := sa.RewardCoins + sa.WorkCoins
-	if sum > math.MaxInt64 {
+	sum, carry := bits.Add64(sa.RewardCoins, sa.WorkCoins, 0)
+	if carry != 0 || sum > math.MaxInt64 {
 		return math.MaxInt64
 	}
 	return int64(sum)
diff --git a/inference-chain/x/inference/types/tx.pb.go b/inference-chain/x/inference/types/tx.pb.go
index 03cb43efca..84f1495212 100644
--- a/inference-chain/x/inference/types/tx.pb.go
+++ b/inference-chain/x/inference/types/tx.pb.go
@@ -126,6 +126,7 @@ func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo
 
+// Deprecated: Do not use.
 type MsgStartInference struct {
 	Creator            string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
 	InferenceId        string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
@@ -276,6 +277,7 @@ func (m *MsgStartInference) GetOriginalPromptHash() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgStartInferenceResponse struct {
 	InferenceIndex string `protobuf:"bytes,1,opt,name=inference_index,json=inferenceIndex,proto3" json:"inference_index,omitempty"`
 	ErrorMessage   string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
@@ -328,6 +330,7 @@ func (m *MsgStartInferenceResponse) GetErrorMessage() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgFinishInference struct {
 	Creator              string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
 	InferenceId          string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
@@ -494,6 +497,7 @@ func (m *MsgFinishInference) GetOriginalPromptHash() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgFinishInferenceResponse struct {
 	InferenceIndex string `protobuf:"bytes,1,opt,name=inference_index,json=inferenceIndex,proto3" json:"inference_index,omitempty"`
 	ErrorMessage   string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
@@ -666,6 +670,7 @@ func (m *MsgSubmitNewParticipantResponse) GetStatus() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgValidation struct {
 	Creator         string   `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
 	Id              string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
@@ -768,6 +773,7 @@ func (m *MsgValidation) GetValueDecimal() *Decimal {
 	return nil
 }
 
+// Deprecated: Do not use.
 type MsgValidationResponse struct {
 }
 
@@ -926,6 +932,7 @@ func (m *MsgSubmitNewUnfundedParticipantResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgSubmitNewUnfundedParticipantResponse proto.InternalMessageInfo
 
+// Deprecated: Do not use.
 type MsgInvalidateInference struct {
 	Creator     string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
 	InferenceId string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
@@ -986,6 +993,7 @@ func (m *MsgInvalidateInference) GetInvalidator() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgInvalidateInferenceResponse struct {
 }
 
@@ -1022,6 +1030,7 @@ func (m *MsgInvalidateInferenceResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgInvalidateInferenceResponse proto.InternalMessageInfo
 
+// Deprecated: Do not use.
 type MsgRevalidateInference struct {
 	Creator     string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
 	InferenceId string `protobuf:"bytes,2,opt,name=inference_id,json=inferenceId,proto3" json:"inference_id,omitempty"`
@@ -1082,6 +1091,7 @@ func (m *MsgRevalidateInference) GetInvalidator() string {
 	return ""
 }
 
+// Deprecated: Do not use.
 type MsgRevalidateInferenceResponse struct {
 }
 
@@ -1230,6 +1240,98 @@ func (m *MsgClaimRewardsResponse) GetResult() string {
 	return ""
 }
 
+// MsgSetClaimRecipients lets the account owner (cold key) batch-configure
+// per-epoch recipient overrides for MsgClaimRewards. Must be signed by the
+// participant's own key; it is intentionally NOT granted to warm keys via
+// authz, so an operational key cannot redirect rewards.
+type MsgSetClaimRecipients struct {
+	Creator string                `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	Entries []ClaimRecipientEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries"`
+}
+
+func (m *MsgSetClaimRecipients) Reset()         { *m = MsgSetClaimRecipients{} }
+func (m *MsgSetClaimRecipients) String() string { return proto.CompactTextString(m) }
+func (*MsgSetClaimRecipients) ProtoMessage()    {}
+func (*MsgSetClaimRecipients) Descriptor() ([]byte, []int) {
+	return fileDescriptor_09b36d0241b9acd5, []int{18}
+}
+func (m *MsgSetClaimRecipients) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgSetClaimRecipients) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgSetClaimRecipients.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 *MsgSetClaimRecipients) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgSetClaimRecipients.Merge(m, src)
+}
+func (m *MsgSetClaimRecipients) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgSetClaimRecipients) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgSetClaimRecipients.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgSetClaimRecipients proto.InternalMessageInfo
+
+func (m *MsgSetClaimRecipients) GetCreator() string {
+	if m != nil {
+		return m.Creator
+	}
+	return ""
+}
+
+func (m *MsgSetClaimRecipients) GetEntries() []ClaimRecipientEntry {
+	if m != nil {
+		return m.Entries
+	}
+	return nil
+}
+
+type MsgSetClaimRecipientsResponse struct {
+}
+
+func (m *MsgSetClaimRecipientsResponse) Reset()         { *m = MsgSetClaimRecipientsResponse{} }
+func (m *MsgSetClaimRecipientsResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgSetClaimRecipientsResponse) ProtoMessage()    {}
+func (*MsgSetClaimRecipientsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_09b36d0241b9acd5, []int{19}
+}
+func (m *MsgSetClaimRecipientsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgSetClaimRecipientsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgSetClaimRecipientsResponse.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 *MsgSetClaimRecipientsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgSetClaimRecipientsResponse.Merge(m, src)
+}
+func (m *MsgSetClaimRecipientsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgSetClaimRecipientsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgSetClaimRecipientsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgSetClaimRecipientsResponse proto.InternalMessageInfo
+
 type MsgSubmitPocBatch struct {
 	Creator                  string    `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
 	PocStageStartBlockHeight int64     `protobuf:"varint,2,opt,name=poc_stage_start_block_height,json=pocStageStartBlockHeight,proto3" json:"poc_stage_start_block_height,omitempty"`
@@ -1243,7 +1345,7 @@ func (m *MsgSubmitPocBatch) Reset()         { *m = MsgSubmitPocBatch{} }
 func (m *MsgSubmitPocBatch) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitPocBatch) ProtoMessage()    {}
 func (*MsgSubmitPocBatch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{18}
+	return fileDescriptor_09b36d0241b9acd5, []int{20}
 }
 func (m *MsgSubmitPocBatch) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1321,7 +1423,7 @@ func (m *MsgSubmitPocBatchResponse) Reset()         { *m = MsgSubmitPocBatchResp
 func (m *MsgSubmitPocBatchResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitPocBatchResponse) ProtoMessage()    {}
 func (*MsgSubmitPocBatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{19}
+	return fileDescriptor_09b36d0241b9acd5, []int{21}
 }
 func (m *MsgSubmitPocBatchResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1361,7 +1463,7 @@ func (m *MsgSubmitPocValidationsV2) Reset()         { *m = MsgSubmitPocValidatio
 func (m *MsgSubmitPocValidationsV2) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitPocValidationsV2) ProtoMessage()    {}
 func (*MsgSubmitPocValidationsV2) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{20}
+	return fileDescriptor_09b36d0241b9acd5, []int{22}
 }
 func (m *MsgSubmitPocValidationsV2) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1418,7 +1520,7 @@ func (m *MsgSubmitPocValidationsV2Response) Reset()         { *m = MsgSubmitPocV
 func (m *MsgSubmitPocValidationsV2Response) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitPocValidationsV2Response) ProtoMessage()    {}
 func (*MsgSubmitPocValidationsV2Response) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{21}
+	return fileDescriptor_09b36d0241b9acd5, []int{23}
 }
 func (m *MsgSubmitPocValidationsV2Response) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1460,7 +1562,7 @@ func (m *MsgPoCV2StoreCommit) Reset()         { *m = MsgPoCV2StoreCommit{} }
 func (m *MsgPoCV2StoreCommit) String() string { return proto.CompactTextString(m) }
 func (*MsgPoCV2StoreCommit) ProtoMessage()    {}
 func (*MsgPoCV2StoreCommit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{22}
+	return fileDescriptor_09b36d0241b9acd5, []int{24}
 }
 func (m *MsgPoCV2StoreCommit) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1533,7 +1635,7 @@ func (m *MsgPoCV2StoreCommitResponse) Reset()         { *m = MsgPoCV2StoreCommit
 func (m *MsgPoCV2StoreCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgPoCV2StoreCommitResponse) ProtoMessage()    {}
 func (*MsgPoCV2StoreCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{23}
+	return fileDescriptor_09b36d0241b9acd5, []int{25}
 }
 func (m *MsgPoCV2StoreCommitResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1574,7 +1676,7 @@ func (m *MsgMLNodeWeightDistribution) Reset()         { *m = MsgMLNodeWeightDist
 func (m *MsgMLNodeWeightDistribution) String() string { return proto.CompactTextString(m) }
 func (*MsgMLNodeWeightDistribution) ProtoMessage()    {}
 func (*MsgMLNodeWeightDistribution) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{24}
+	return fileDescriptor_09b36d0241b9acd5, []int{26}
 }
 func (m *MsgMLNodeWeightDistribution) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1639,7 +1741,7 @@ func (m *MsgMLNodeWeightDistributionResponse) Reset()         { *m = MsgMLNodeWe
 func (m *MsgMLNodeWeightDistributionResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgMLNodeWeightDistributionResponse) ProtoMessage()    {}
 func (*MsgMLNodeWeightDistributionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{25}
+	return fileDescriptor_09b36d0241b9acd5, []int{27}
 }
 func (m *MsgMLNodeWeightDistributionResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1678,7 +1780,7 @@ func (m *MsgSubmitSeed) Reset()         { *m = MsgSubmitSeed{} }
 func (m *MsgSubmitSeed) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitSeed) ProtoMessage()    {}
 func (*MsgSubmitSeed) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{26}
+	return fileDescriptor_09b36d0241b9acd5, []int{28}
 }
 func (m *MsgSubmitSeed) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1735,7 +1837,7 @@ func (m *MsgSubmitSeedResponse) Reset()         { *m = MsgSubmitSeedResponse{} }
 func (m *MsgSubmitSeedResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitSeedResponse) ProtoMessage()    {}
 func (*MsgSubmitSeedResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{27}
+	return fileDescriptor_09b36d0241b9acd5, []int{29}
 }
 func (m *MsgSubmitSeedResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1773,7 +1875,7 @@ func (m *MsgSubmitUnitOfComputePriceProposal) Reset()         { *m = MsgSubmitUn
 func (m *MsgSubmitUnitOfComputePriceProposal) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitUnitOfComputePriceProposal) ProtoMessage()    {}
 func (*MsgSubmitUnitOfComputePriceProposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{28}
+	return fileDescriptor_09b36d0241b9acd5, []int{30}
 }
 func (m *MsgSubmitUnitOfComputePriceProposal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1827,7 +1929,7 @@ func (m *MsgSubmitUnitOfComputePriceProposalResponse) String() string {
 }
 func (*MsgSubmitUnitOfComputePriceProposalResponse) ProtoMessage() {}
 func (*MsgSubmitUnitOfComputePriceProposalResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{29}
+	return fileDescriptor_09b36d0241b9acd5, []int{31}
 }
 func (m *MsgSubmitUnitOfComputePriceProposalResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1873,7 +1975,7 @@ func (m *MsgRegisterModel) Reset()         { *m = MsgRegisterModel{} }
 func (m *MsgRegisterModel) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterModel) ProtoMessage()    {}
 func (*MsgRegisterModel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{30}
+	return fileDescriptor_09b36d0241b9acd5, []int{32}
 }
 func (m *MsgRegisterModel) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1979,7 +2081,7 @@ func (m *MsgRegisterModelResponse) Reset()         { *m = MsgRegisterModelRespon
 func (m *MsgRegisterModelResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterModelResponse) ProtoMessage()    {}
 func (*MsgRegisterModelResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{31}
+	return fileDescriptor_09b36d0241b9acd5, []int{33}
 }
 func (m *MsgRegisterModelResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2017,7 +2119,7 @@ func (m *MsgDeleteGovernanceModel) Reset()         { *m = MsgDeleteGovernanceMod
 func (m *MsgDeleteGovernanceModel) String() string { return proto.CompactTextString(m) }
 func (*MsgDeleteGovernanceModel) ProtoMessage()    {}
 func (*MsgDeleteGovernanceModel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{32}
+	return fileDescriptor_09b36d0241b9acd5, []int{34}
 }
 func (m *MsgDeleteGovernanceModel) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2067,7 +2169,7 @@ func (m *MsgDeleteGovernanceModelResponse) Reset()         { *m = MsgDeleteGover
 func (m *MsgDeleteGovernanceModelResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgDeleteGovernanceModelResponse) ProtoMessage()    {}
 func (*MsgDeleteGovernanceModelResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{33}
+	return fileDescriptor_09b36d0241b9acd5, []int{35}
 }
 func (m *MsgDeleteGovernanceModelResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2106,7 +2208,7 @@ func (m *MsgSubmitHardwareDiff) Reset()         { *m = MsgSubmitHardwareDiff{} }
 func (m *MsgSubmitHardwareDiff) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitHardwareDiff) ProtoMessage()    {}
 func (*MsgSubmitHardwareDiff) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{34}
+	return fileDescriptor_09b36d0241b9acd5, []int{36}
 }
 func (m *MsgSubmitHardwareDiff) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2163,7 +2265,7 @@ func (m *MsgSubmitHardwareDiffResponse) Reset()         { *m = MsgSubmitHardware
 func (m *MsgSubmitHardwareDiffResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitHardwareDiffResponse) ProtoMessage()    {}
 func (*MsgSubmitHardwareDiffResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{35}
+	return fileDescriptor_09b36d0241b9acd5, []int{37}
 }
 func (m *MsgSubmitHardwareDiffResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2203,7 +2305,7 @@ func (m *MsgCreatePartialUpgrade) Reset()         { *m = MsgCreatePartialUpgrade
 func (m *MsgCreatePartialUpgrade) String() string { return proto.CompactTextString(m) }
 func (*MsgCreatePartialUpgrade) ProtoMessage()    {}
 func (*MsgCreatePartialUpgrade) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{36}
+	return fileDescriptor_09b36d0241b9acd5, []int{38}
 }
 func (m *MsgCreatePartialUpgrade) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2267,7 +2369,7 @@ func (m *MsgCreatePartialUpgradeResponse) Reset()         { *m = MsgCreatePartia
 func (m *MsgCreatePartialUpgradeResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgCreatePartialUpgradeResponse) ProtoMessage()    {}
 func (*MsgCreatePartialUpgradeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{37}
+	return fileDescriptor_09b36d0241b9acd5, []int{39}
 }
 func (m *MsgCreatePartialUpgradeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2312,7 +2414,7 @@ func (m *MsgBridgeExchange) Reset()         { *m = MsgBridgeExchange{} }
 func (m *MsgBridgeExchange) String() string { return proto.CompactTextString(m) }
 func (*MsgBridgeExchange) ProtoMessage()    {}
 func (*MsgBridgeExchange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{38}
+	return fileDescriptor_09b36d0241b9acd5, []int{40}
 }
 func (m *MsgBridgeExchange) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2412,7 +2514,7 @@ func (m *MsgBridgeExchangeResponse) Reset()         { *m = MsgBridgeExchangeResp
 func (m *MsgBridgeExchangeResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgBridgeExchangeResponse) ProtoMessage()    {}
 func (*MsgBridgeExchangeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{39}
+	return fileDescriptor_09b36d0241b9acd5, []int{41}
 }
 func (m *MsgBridgeExchangeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2459,7 +2561,7 @@ func (m *MsgAddParticipantsToAllowList) Reset()         { *m = MsgAddParticipant
 func (m *MsgAddParticipantsToAllowList) String() string { return proto.CompactTextString(m) }
 func (*MsgAddParticipantsToAllowList) ProtoMessage()    {}
 func (*MsgAddParticipantsToAllowList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{40}
+	return fileDescriptor_09b36d0241b9acd5, []int{42}
 }
 func (m *MsgAddParticipantsToAllowList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2509,7 +2611,7 @@ func (m *MsgAddParticipantsToAllowListResponse) Reset()         { *m = MsgAddPar
 func (m *MsgAddParticipantsToAllowListResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgAddParticipantsToAllowListResponse) ProtoMessage()    {}
 func (*MsgAddParticipantsToAllowListResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{41}
+	return fileDescriptor_09b36d0241b9acd5, []int{43}
 }
 func (m *MsgAddParticipantsToAllowListResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2549,7 +2651,7 @@ func (m *MsgRemoveParticipantsFromAllowList) Reset()         { *m = MsgRemovePar
 func (m *MsgRemoveParticipantsFromAllowList) String() string { return proto.CompactTextString(m) }
 func (*MsgRemoveParticipantsFromAllowList) ProtoMessage()    {}
 func (*MsgRemoveParticipantsFromAllowList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{42}
+	return fileDescriptor_09b36d0241b9acd5, []int{44}
 }
 func (m *MsgRemoveParticipantsFromAllowList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2603,7 +2705,7 @@ func (m *MsgRemoveParticipantsFromAllowListResponse) String() string {
 }
 func (*MsgRemoveParticipantsFromAllowListResponse) ProtoMessage() {}
 func (*MsgRemoveParticipantsFromAllowListResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{43}
+	return fileDescriptor_09b36d0241b9acd5, []int{45}
 }
 func (m *MsgRemoveParticipantsFromAllowListResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2642,7 +2744,7 @@ func (m *MsgRegisterBridgeAddresses) Reset()         { *m = MsgRegisterBridgeAdd
 func (m *MsgRegisterBridgeAddresses) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterBridgeAddresses) ProtoMessage()    {}
 func (*MsgRegisterBridgeAddresses) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{44}
+	return fileDescriptor_09b36d0241b9acd5, []int{46}
 }
 func (m *MsgRegisterBridgeAddresses) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2699,7 +2801,7 @@ func (m *MsgRegisterBridgeAddressesResponse) Reset()         { *m = MsgRegisterB
 func (m *MsgRegisterBridgeAddressesResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterBridgeAddressesResponse) ProtoMessage()    {}
 func (*MsgRegisterBridgeAddressesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{45}
+	return fileDescriptor_09b36d0241b9acd5, []int{47}
 }
 func (m *MsgRegisterBridgeAddressesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2742,7 +2844,7 @@ func (m *MsgRegisterTokenMetadata) Reset()         { *m = MsgRegisterTokenMetada
 func (m *MsgRegisterTokenMetadata) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterTokenMetadata) ProtoMessage()    {}
 func (*MsgRegisterTokenMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{46}
+	return fileDescriptor_09b36d0241b9acd5, []int{48}
 }
 func (m *MsgRegisterTokenMetadata) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2827,7 +2929,7 @@ func (m *MsgRegisterTokenMetadataResponse) Reset()         { *m = MsgRegisterTok
 func (m *MsgRegisterTokenMetadataResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterTokenMetadataResponse) ProtoMessage()    {}
 func (*MsgRegisterTokenMetadataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{47}
+	return fileDescriptor_09b36d0241b9acd5, []int{49}
 }
 func (m *MsgRegisterTokenMetadataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2866,7 +2968,7 @@ func (m *MsgApproveBridgeTokenForTrading) Reset()         { *m = MsgApproveBridg
 func (m *MsgApproveBridgeTokenForTrading) String() string { return proto.CompactTextString(m) }
 func (*MsgApproveBridgeTokenForTrading) ProtoMessage()    {}
 func (*MsgApproveBridgeTokenForTrading) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{48}
+	return fileDescriptor_09b36d0241b9acd5, []int{50}
 }
 func (m *MsgApproveBridgeTokenForTrading) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2925,7 +3027,7 @@ func (m *MsgApproveBridgeTokenForTradingResponse) Reset() {
 func (m *MsgApproveBridgeTokenForTradingResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgApproveBridgeTokenForTradingResponse) ProtoMessage()    {}
 func (*MsgApproveBridgeTokenForTradingResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{49}
+	return fileDescriptor_09b36d0241b9acd5, []int{51}
 }
 func (m *MsgApproveBridgeTokenForTradingResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2965,7 +3067,7 @@ func (m *MsgRegisterLiquidityPool) Reset()         { *m = MsgRegisterLiquidityPo
 func (m *MsgRegisterLiquidityPool) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterLiquidityPool) ProtoMessage()    {}
 func (*MsgRegisterLiquidityPool) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{50}
+	return fileDescriptor_09b36d0241b9acd5, []int{52}
 }
 func (m *MsgRegisterLiquidityPool) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3029,7 +3131,7 @@ func (m *MsgRegisterLiquidityPoolResponse) Reset()         { *m = MsgRegisterLiq
 func (m *MsgRegisterLiquidityPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterLiquidityPoolResponse) ProtoMessage()    {}
 func (*MsgRegisterLiquidityPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{51}
+	return fileDescriptor_09b36d0241b9acd5, []int{53}
 }
 func (m *MsgRegisterLiquidityPoolResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3071,7 +3173,7 @@ func (m *MsgRequestBridgeWithdrawal) Reset()         { *m = MsgRequestBridgeWith
 func (m *MsgRequestBridgeWithdrawal) String() string { return proto.CompactTextString(m) }
 func (*MsgRequestBridgeWithdrawal) ProtoMessage()    {}
 func (*MsgRequestBridgeWithdrawal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{52}
+	return fileDescriptor_09b36d0241b9acd5, []int{54}
 }
 func (m *MsgRequestBridgeWithdrawal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3145,7 +3247,7 @@ func (m *MsgRequestBridgeWithdrawalResponse) Reset()         { *m = MsgRequestBr
 func (m *MsgRequestBridgeWithdrawalResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRequestBridgeWithdrawalResponse) ProtoMessage()    {}
 func (*MsgRequestBridgeWithdrawalResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{53}
+	return fileDescriptor_09b36d0241b9acd5, []int{55}
 }
 func (m *MsgRequestBridgeWithdrawalResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3208,7 +3310,7 @@ func (m *MsgRequestBridgeMint) Reset()         { *m = MsgRequestBridgeMint{} }
 func (m *MsgRequestBridgeMint) String() string { return proto.CompactTextString(m) }
 func (*MsgRequestBridgeMint) ProtoMessage()    {}
 func (*MsgRequestBridgeMint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{54}
+	return fileDescriptor_09b36d0241b9acd5, []int{56}
 }
 func (m *MsgRequestBridgeMint) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3282,7 +3384,7 @@ func (m *MsgRequestBridgeMintResponse) Reset()         { *m = MsgRequestBridgeMi
 func (m *MsgRequestBridgeMintResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRequestBridgeMintResponse) ProtoMessage()    {}
 func (*MsgRequestBridgeMintResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{55}
+	return fileDescriptor_09b36d0241b9acd5, []int{57}
 }
 func (m *MsgRequestBridgeMintResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3341,7 +3443,7 @@ func (m *MsgCancelBridgeOperation) Reset()         { *m = MsgCancelBridgeOperati
 func (m *MsgCancelBridgeOperation) String() string { return proto.CompactTextString(m) }
 func (*MsgCancelBridgeOperation) ProtoMessage()    {}
 func (*MsgCancelBridgeOperation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{56}
+	return fileDescriptor_09b36d0241b9acd5, []int{58}
 }
 func (m *MsgCancelBridgeOperation) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3391,7 +3493,7 @@ func (m *MsgCancelBridgeOperationResponse) Reset()         { *m = MsgCancelBridg
 func (m *MsgCancelBridgeOperationResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgCancelBridgeOperationResponse) ProtoMessage()    {}
 func (*MsgCancelBridgeOperationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{57}
+	return fileDescriptor_09b36d0241b9acd5, []int{59}
 }
 func (m *MsgCancelBridgeOperationResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3432,7 +3534,7 @@ func (m *MsgGovernanceCancelBridgeOperation) Reset()         { *m = MsgGovernanc
 func (m *MsgGovernanceCancelBridgeOperation) String() string { return proto.CompactTextString(m) }
 func (*MsgGovernanceCancelBridgeOperation) ProtoMessage()    {}
 func (*MsgGovernanceCancelBridgeOperation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{58}
+	return fileDescriptor_09b36d0241b9acd5, []int{60}
 }
 func (m *MsgGovernanceCancelBridgeOperation) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3507,7 +3609,7 @@ func (m *MsgGovernanceCancelBridgeOperationResponse) String() string {
 }
 func (*MsgGovernanceCancelBridgeOperationResponse) ProtoMessage() {}
 func (*MsgGovernanceCancelBridgeOperationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{59}
+	return fileDescriptor_09b36d0241b9acd5, []int{61}
 }
 func (m *MsgGovernanceCancelBridgeOperationResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3546,7 +3648,7 @@ func (m *MsgRegisterWrappedTokenContract) Reset()         { *m = MsgRegisterWrap
 func (m *MsgRegisterWrappedTokenContract) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterWrappedTokenContract) ProtoMessage()    {}
 func (*MsgRegisterWrappedTokenContract) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{60}
+	return fileDescriptor_09b36d0241b9acd5, []int{62}
 }
 func (m *MsgRegisterWrappedTokenContract) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3598,7 +3700,7 @@ func (m *MsgRegisterWrappedTokenContractResponse) Reset() {
 func (m *MsgRegisterWrappedTokenContractResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterWrappedTokenContractResponse) ProtoMessage()    {}
 func (*MsgRegisterWrappedTokenContractResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{61}
+	return fileDescriptor_09b36d0241b9acd5, []int{63}
 }
 func (m *MsgRegisterWrappedTokenContractResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3641,7 +3743,7 @@ func (m *MsgMigrateAllWrappedTokens) Reset()         { *m = MsgMigrateAllWrapped
 func (m *MsgMigrateAllWrappedTokens) String() string { return proto.CompactTextString(m) }
 func (*MsgMigrateAllWrappedTokens) ProtoMessage()    {}
 func (*MsgMigrateAllWrappedTokens) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{62}
+	return fileDescriptor_09b36d0241b9acd5, []int{64}
 }
 func (m *MsgMigrateAllWrappedTokens) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3707,7 +3809,7 @@ func (m *MsgMigrateAllWrappedTokensResponse) Reset()         { *m = MsgMigrateAl
 func (m *MsgMigrateAllWrappedTokensResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgMigrateAllWrappedTokensResponse) ProtoMessage()    {}
 func (*MsgMigrateAllWrappedTokensResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{63}
+	return fileDescriptor_09b36d0241b9acd5, []int{65}
 }
 func (m *MsgMigrateAllWrappedTokensResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3753,7 +3855,7 @@ func (m *MsgApproveIbcTokenForTrading) Reset()         { *m = MsgApproveIbcToken
 func (m *MsgApproveIbcTokenForTrading) String() string { return proto.CompactTextString(m) }
 func (*MsgApproveIbcTokenForTrading) ProtoMessage()    {}
 func (*MsgApproveIbcTokenForTrading) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{64}
+	return fileDescriptor_09b36d0241b9acd5, []int{66}
 }
 func (m *MsgApproveIbcTokenForTrading) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3810,7 +3912,7 @@ func (m *MsgApproveIbcTokenForTradingResponse) Reset()         { *m = MsgApprove
 func (m *MsgApproveIbcTokenForTradingResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgApproveIbcTokenForTradingResponse) ProtoMessage()    {}
 func (*MsgApproveIbcTokenForTradingResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{65}
+	return fileDescriptor_09b36d0241b9acd5, []int{67}
 }
 func (m *MsgApproveIbcTokenForTradingResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3853,7 +3955,7 @@ func (m *MsgRegisterIbcTokenMetadata) Reset()         { *m = MsgRegisterIbcToken
 func (m *MsgRegisterIbcTokenMetadata) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterIbcTokenMetadata) ProtoMessage()    {}
 func (*MsgRegisterIbcTokenMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{66}
+	return fileDescriptor_09b36d0241b9acd5, []int{68}
 }
 func (m *MsgRegisterIbcTokenMetadata) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3938,7 +4040,7 @@ func (m *MsgRegisterIbcTokenMetadataResponse) Reset()         { *m = MsgRegister
 func (m *MsgRegisterIbcTokenMetadataResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterIbcTokenMetadataResponse) ProtoMessage()    {}
 func (*MsgRegisterIbcTokenMetadataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{67}
+	return fileDescriptor_09b36d0241b9acd5, []int{69}
 }
 func (m *MsgRegisterIbcTokenMetadataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3977,7 +4079,7 @@ func (m *MsgCreateDevshardEscrow) Reset()         { *m = MsgCreateDevshardEscrow
 func (m *MsgCreateDevshardEscrow) String() string { return proto.CompactTextString(m) }
 func (*MsgCreateDevshardEscrow) ProtoMessage()    {}
 func (*MsgCreateDevshardEscrow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{68}
+	return fileDescriptor_09b36d0241b9acd5, []int{70}
 }
 func (m *MsgCreateDevshardEscrow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4035,7 +4137,7 @@ func (m *MsgCreateDevshardEscrowResponse) Reset()         { *m = MsgCreateDevsha
 func (m *MsgCreateDevshardEscrowResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgCreateDevshardEscrowResponse) ProtoMessage()    {}
 func (*MsgCreateDevshardEscrowResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{69}
+	return fileDescriptor_09b36d0241b9acd5, []int{71}
 }
 func (m *MsgCreateDevshardEscrowResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4087,7 +4189,7 @@ func (m *MsgSettleDevshardEscrow) Reset()         { *m = MsgSettleDevshardEscrow
 func (m *MsgSettleDevshardEscrow) String() string { return proto.CompactTextString(m) }
 func (*MsgSettleDevshardEscrow) ProtoMessage()    {}
 func (*MsgSettleDevshardEscrow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{70}
+	return fileDescriptor_09b36d0241b9acd5, []int{72}
 }
 func (m *MsgSettleDevshardEscrow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4186,7 +4288,7 @@ func (m *MsgSettleDevshardEscrowResponse) Reset()         { *m = MsgSettleDevsha
 func (m *MsgSettleDevshardEscrowResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSettleDevshardEscrowResponse) ProtoMessage()    {}
 func (*MsgSettleDevshardEscrowResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{71}
+	return fileDescriptor_09b36d0241b9acd5, []int{73}
 }
 func (m *MsgSettleDevshardEscrowResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4224,7 +4326,7 @@ func (m *MsgSetDevshardRequestsEnabled) Reset()         { *m = MsgSetDevshardReq
 func (m *MsgSetDevshardRequestsEnabled) String() string { return proto.CompactTextString(m) }
 func (*MsgSetDevshardRequestsEnabled) ProtoMessage()    {}
 func (*MsgSetDevshardRequestsEnabled) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{72}
+	return fileDescriptor_09b36d0241b9acd5, []int{74}
 }
 func (m *MsgSetDevshardRequestsEnabled) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4274,7 +4376,7 @@ func (m *MsgSetDevshardRequestsEnabledResponse) Reset()         { *m = MsgSetDev
 func (m *MsgSetDevshardRequestsEnabledResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSetDevshardRequestsEnabledResponse) ProtoMessage()    {}
 func (*MsgSetDevshardRequestsEnabledResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_09b36d0241b9acd5, []int{73}
+	return fileDescriptor_09b36d0241b9acd5, []int{75}
 }
 func (m *MsgSetDevshardRequestsEnabledResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4303,329 +4405,552 @@ func (m *MsgSetDevshardRequestsEnabledResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgSetDevshardRequestsEnabledResponse proto.InternalMessageInfo
 
-func init() {
-	proto.RegisterType((*MsgUpdateParams)(nil), "inference.inference.MsgUpdateParams")
-	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "inference.inference.MsgUpdateParamsResponse")
-	proto.RegisterType((*MsgStartInference)(nil), "inference.inference.MsgStartInference")
-	proto.RegisterType((*MsgStartInferenceResponse)(nil), "inference.inference.MsgStartInferenceResponse")
-	proto.RegisterType((*MsgFinishInference)(nil), "inference.inference.MsgFinishInference")
-	proto.RegisterType((*MsgFinishInferenceResponse)(nil), "inference.inference.MsgFinishInferenceResponse")
-	proto.RegisterType((*MsgSubmitNewParticipant)(nil), "inference.inference.MsgSubmitNewParticipant")
-	proto.RegisterType((*MsgSubmitNewParticipantResponse)(nil), "inference.inference.MsgSubmitNewParticipantResponse")
-	proto.RegisterType((*MsgValidation)(nil), "inference.inference.MsgValidation")
-	proto.RegisterType((*MsgValidationResponse)(nil), "inference.inference.MsgValidationResponse")
-	proto.RegisterType((*MsgSubmitNewUnfundedParticipant)(nil), "inference.inference.MsgSubmitNewUnfundedParticipant")
-	proto.RegisterType((*MsgSubmitNewUnfundedParticipantResponse)(nil), "inference.inference.MsgSubmitNewUnfundedParticipantResponse")
-	proto.RegisterType((*MsgInvalidateInference)(nil), "inference.inference.MsgInvalidateInference")
-	proto.RegisterType((*MsgInvalidateInferenceResponse)(nil), "inference.inference.MsgInvalidateInferenceResponse")
-	proto.RegisterType((*MsgRevalidateInference)(nil), "inference.inference.MsgRevalidateInference")
-	proto.RegisterType((*MsgRevalidateInferenceResponse)(nil), "inference.inference.MsgRevalidateInferenceResponse")
-	proto.RegisterType((*MsgClaimRewards)(nil), "inference.inference.MsgClaimRewards")
-	proto.RegisterType((*MsgClaimRewardsResponse)(nil), "inference.inference.MsgClaimRewardsResponse")
-	proto.RegisterType((*MsgSubmitPocBatch)(nil), "inference.inference.MsgSubmitPocBatch")
-	proto.RegisterType((*MsgSubmitPocBatchResponse)(nil), "inference.inference.MsgSubmitPocBatchResponse")
-	proto.RegisterType((*MsgSubmitPocValidationsV2)(nil), "inference.inference.MsgSubmitPocValidationsV2")
-	proto.RegisterType((*MsgSubmitPocValidationsV2Response)(nil), "inference.inference.MsgSubmitPocValidationsV2Response")
-	proto.RegisterType((*MsgPoCV2StoreCommit)(nil), "inference.inference.MsgPoCV2StoreCommit")
-	proto.RegisterType((*MsgPoCV2StoreCommitResponse)(nil), "inference.inference.MsgPoCV2StoreCommitResponse")
-	proto.RegisterType((*MsgMLNodeWeightDistribution)(nil), "inference.inference.MsgMLNodeWeightDistribution")
-	proto.RegisterType((*MsgMLNodeWeightDistributionResponse)(nil), "inference.inference.MsgMLNodeWeightDistributionResponse")
-	proto.RegisterType((*MsgSubmitSeed)(nil), "inference.inference.MsgSubmitSeed")
-	proto.RegisterType((*MsgSubmitSeedResponse)(nil), "inference.inference.MsgSubmitSeedResponse")
-	proto.RegisterType((*MsgSubmitUnitOfComputePriceProposal)(nil), "inference.inference.MsgSubmitUnitOfComputePriceProposal")
-	proto.RegisterType((*MsgSubmitUnitOfComputePriceProposalResponse)(nil), "inference.inference.MsgSubmitUnitOfComputePriceProposalResponse")
-	proto.RegisterType((*MsgRegisterModel)(nil), "inference.inference.MsgRegisterModel")
-	proto.RegisterType((*MsgRegisterModelResponse)(nil), "inference.inference.MsgRegisterModelResponse")
-	proto.RegisterType((*MsgDeleteGovernanceModel)(nil), "inference.inference.MsgDeleteGovernanceModel")
-	proto.RegisterType((*MsgDeleteGovernanceModelResponse)(nil), "inference.inference.MsgDeleteGovernanceModelResponse")
-	proto.RegisterType((*MsgSubmitHardwareDiff)(nil), "inference.inference.MsgSubmitHardwareDiff")
-	proto.RegisterType((*MsgSubmitHardwareDiffResponse)(nil), "inference.inference.MsgSubmitHardwareDiffResponse")
-	proto.RegisterType((*MsgCreatePartialUpgrade)(nil), "inference.inference.MsgCreatePartialUpgrade")
-	proto.RegisterType((*MsgCreatePartialUpgradeResponse)(nil), "inference.inference.MsgCreatePartialUpgradeResponse")
-	proto.RegisterType((*MsgBridgeExchange)(nil), "inference.inference.MsgBridgeExchange")
-	proto.RegisterType((*MsgBridgeExchangeResponse)(nil), "inference.inference.MsgBridgeExchangeResponse")
-	proto.RegisterType((*MsgAddParticipantsToAllowList)(nil), "inference.inference.MsgAddParticipantsToAllowList")
-	proto.RegisterType((*MsgAddParticipantsToAllowListResponse)(nil), "inference.inference.MsgAddParticipantsToAllowListResponse")
-	proto.RegisterType((*MsgRemoveParticipantsFromAllowList)(nil), "inference.inference.MsgRemoveParticipantsFromAllowList")
-	proto.RegisterType((*MsgRemoveParticipantsFromAllowListResponse)(nil), "inference.inference.MsgRemoveParticipantsFromAllowListResponse")
-	proto.RegisterType((*MsgRegisterBridgeAddresses)(nil), "inference.inference.MsgRegisterBridgeAddresses")
-	proto.RegisterType((*MsgRegisterBridgeAddressesResponse)(nil), "inference.inference.MsgRegisterBridgeAddressesResponse")
-	proto.RegisterType((*MsgRegisterTokenMetadata)(nil), "inference.inference.MsgRegisterTokenMetadata")
-	proto.RegisterType((*MsgRegisterTokenMetadataResponse)(nil), "inference.inference.MsgRegisterTokenMetadataResponse")
-	proto.RegisterType((*MsgApproveBridgeTokenForTrading)(nil), "inference.inference.MsgApproveBridgeTokenForTrading")
-	proto.RegisterType((*MsgApproveBridgeTokenForTradingResponse)(nil), "inference.inference.MsgApproveBridgeTokenForTradingResponse")
-	proto.RegisterType((*MsgRegisterLiquidityPool)(nil), "inference.inference.MsgRegisterLiquidityPool")
-	proto.RegisterType((*MsgRegisterLiquidityPoolResponse)(nil), "inference.inference.MsgRegisterLiquidityPoolResponse")
-	proto.RegisterType((*MsgRequestBridgeWithdrawal)(nil), "inference.inference.MsgRequestBridgeWithdrawal")
-	proto.RegisterType((*MsgRequestBridgeWithdrawalResponse)(nil), "inference.inference.MsgRequestBridgeWithdrawalResponse")
-	proto.RegisterType((*MsgRequestBridgeMint)(nil), "inference.inference.MsgRequestBridgeMint")
-	proto.RegisterType((*MsgRequestBridgeMintResponse)(nil), "inference.inference.MsgRequestBridgeMintResponse")
-	proto.RegisterType((*MsgCancelBridgeOperation)(nil), "inference.inference.MsgCancelBridgeOperation")
-	proto.RegisterType((*MsgCancelBridgeOperationResponse)(nil), "inference.inference.MsgCancelBridgeOperationResponse")
-	proto.RegisterType((*MsgGovernanceCancelBridgeOperation)(nil), "inference.inference.MsgGovernanceCancelBridgeOperation")
-	proto.RegisterType((*MsgGovernanceCancelBridgeOperationResponse)(nil), "inference.inference.MsgGovernanceCancelBridgeOperationResponse")
-	proto.RegisterType((*MsgRegisterWrappedTokenContract)(nil), "inference.inference.MsgRegisterWrappedTokenContract")
-	proto.RegisterType((*MsgRegisterWrappedTokenContractResponse)(nil), "inference.inference.MsgRegisterWrappedTokenContractResponse")
-	proto.RegisterType((*MsgMigrateAllWrappedTokens)(nil), "inference.inference.MsgMigrateAllWrappedTokens")
-	proto.RegisterType((*MsgMigrateAllWrappedTokensResponse)(nil), "inference.inference.MsgMigrateAllWrappedTokensResponse")
-	proto.RegisterType((*MsgApproveIbcTokenForTrading)(nil), "inference.inference.MsgApproveIbcTokenForTrading")
-	proto.RegisterType((*MsgApproveIbcTokenForTradingResponse)(nil), "inference.inference.MsgApproveIbcTokenForTradingResponse")
-	proto.RegisterType((*MsgRegisterIbcTokenMetadata)(nil), "inference.inference.MsgRegisterIbcTokenMetadata")
-	proto.RegisterType((*MsgRegisterIbcTokenMetadataResponse)(nil), "inference.inference.MsgRegisterIbcTokenMetadataResponse")
-	proto.RegisterType((*MsgCreateDevshardEscrow)(nil), "inference.inference.MsgCreateDevshardEscrow")
-	proto.RegisterType((*MsgCreateDevshardEscrowResponse)(nil), "inference.inference.MsgCreateDevshardEscrowResponse")
-	proto.RegisterType((*MsgSettleDevshardEscrow)(nil), "inference.inference.MsgSettleDevshardEscrow")
-	proto.RegisterType((*MsgSettleDevshardEscrowResponse)(nil), "inference.inference.MsgSettleDevshardEscrowResponse")
-	proto.RegisterType((*MsgSetDevshardRequestsEnabled)(nil), "inference.inference.MsgSetDevshardRequestsEnabled")
-	proto.RegisterType((*MsgSetDevshardRequestsEnabledResponse)(nil), "inference.inference.MsgSetDevshardRequestsEnabledResponse")
+// MsgScheduleMaintenance schedules a maintenance window for a participant.
+type MsgScheduleMaintenance struct {
+	Creator        string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	Participant    string `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
+	StartHeight    int64  `protobuf:"varint,3,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"`
+	DurationBlocks uint64 `protobuf:"varint,4,opt,name=duration_blocks,json=durationBlocks,proto3" json:"duration_blocks,omitempty"`
 }
 
-func init() { proto.RegisterFile("inference/inference/tx.proto", fileDescriptor_09b36d0241b9acd5) }
-
-var fileDescriptor_09b36d0241b9acd5 = []byte{
-	// 3815 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3b, 0x4b, 0x6c, 0x1d, 0x47,
-	0x72, 0x1e, 0x3e, 0x7e, 0x9b, 0x1f, 0x51, 0x23, 0xae, 0xf4, 0xf4, 0x24, 0x51, 0xd4, 0xb3, 0x65,
-	0x51, 0x92, 0x25, 0xda, 0x5c, 0xef, 0xc6, 0x51, 0x16, 0x76, 0xf8, 0xf1, 0x87, 0x6b, 0x53, 0x22,
-	0x86, 0xb2, 0x1d, 0x04, 0x01, 0x06, 0xfd, 0x66, 0x9a, 0xf3, 0x66, 0xf5, 0x66, 0x7a, 0xdc, 0xdd,
-	0x8f, 0x14, 0x03, 0x04, 0x58, 0x6c, 0x92, 0x05, 0xb2, 0x08, 0x82, 0x20, 0x39, 0x04, 0x48, 0x80,
-	0x24, 0x40, 0x0e, 0x09, 0x90, 0x43, 0x7c, 0xc8, 0x3d, 0x40, 0x3e, 0xc0, 0x1e, 0x8d, 0x05, 0x02,
-	0x04, 0x08, 0x10, 0x18, 0xf6, 0x41, 0xb7, 0x1c, 0x72, 0xcb, 0x2d, 0xe8, 0xcf, 0xf4, 0x7c, 0xde,
-	0xf4, 0xcc, 0xa3, 0x6c, 0x25, 0xb9, 0x48, 0xaf, 0xab, 0xab, 0xaa, 0xab, 0xaa, 0xab, 0xaa, 0xab,
-	0xab, 0x87, 0xe0, 0x6a, 0x18, 0x1f, 0x21, 0x82, 0x62, 0x0f, 0x6d, 0x64, 0xbf, 0xd8, 0xd3, 0xfb,
-	0x09, 0xc1, 0x0c, 0xdb, 0x17, 0x34, 0xec, 0xbe, 0xfe, 0xd5, 0x39, 0x0f, 0xa3, 0x30, 0xc6, 0x1b,
-	0xe2, 0x5f, 0x89, 0xd7, 0xb9, 0xe4, 0x61, 0x1a, 0x61, 0xba, 0x11, 0xd1, 0x60, 0xe3, 0xf8, 0x0d,
-	0xfe, 0x9f, 0x9a, 0xb8, 0x2c, 0x27, 0x5c, 0x31, 0xda, 0x90, 0x03, 0x35, 0xb5, 0x12, 0xe0, 0x00,
-	0x4b, 0x38, 0xff, 0x95, 0x12, 0x04, 0x18, 0x07, 0x03, 0xb4, 0x21, 0x46, 0xbd, 0xe1, 0xd1, 0x06,
-	0x8c, 0x4f, 0xd5, 0xd4, 0x5a, 0x95, 0xa8, 0x09, 0x24, 0x30, 0x4a, 0x59, 0xde, 0xaa, 0xc2, 0xe8,
-	0x43, 0xe2, 0x9f, 0x40, 0x82, 0xdc, 0x18, 0xfb, 0xa8, 0x8e, 0x55, 0x8f, 0x84, 0x7e, 0x50, 0x8b,
-	0x91, 0x60, 0xcf, 0x3d, 0xde, 0x54, 0x18, 0xb7, 0xab, 0x30, 0x7c, 0x74, 0x4c, 0xf9, 0x82, 0x2e,
-	0xa2, 0x1e, 0xc1, 0x27, 0x0a, 0x75, 0xdd, 0xc4, 0xcc, 0x47, 0x03, 0x14, 0x40, 0x16, 0xe2, 0x58,
-	0x62, 0x76, 0xff, 0xc9, 0x02, 0xe7, 0xf6, 0x69, 0xf0, 0x71, 0xe2, 0x43, 0x86, 0x0e, 0x84, 0x6e,
-	0xf6, 0xf7, 0xc1, 0x1c, 0x1c, 0xb2, 0x3e, 0x26, 0x21, 0x3b, 0x6d, 0x5b, 0x6b, 0xd6, 0xfa, 0xdc,
-	0x76, 0xfb, 0x17, 0x7f, 0x7f, 0x6f, 0x45, 0x59, 0x73, 0xcb, 0xf7, 0x09, 0xa2, 0xf4, 0x90, 0x91,
-	0x30, 0x0e, 0x9c, 0x0c, 0xd5, 0x7e, 0x1b, 0x4c, 0x4b, 0xeb, 0xb4, 0x27, 0xd6, 0xac, 0xf5, 0xf9,
-	0xcd, 0x2b, 0xf7, 0x2b, 0x76, 0xf3, 0xbe, 0x5c, 0x64, 0x7b, 0xee, 0xe7, 0xff, 0x71, 0xfd, 0xa5,
-	0xbf, 0x79, 0xf6, 0xf9, 0x1d, 0xcb, 0x51, 0x54, 0x0f, 0xde, 0xfa, 0xc9, 0xb3, 0xcf, 0xef, 0x64,
-	0xfc, 0x7e, 0xf6, 0xec, 0xf3, 0x3b, 0x37, 0x33, 0xf1, 0x9f, 0xe6, 0x54, 0x29, 0x49, 0xdc, 0xbd,
-	0x0c, 0x2e, 0x95, 0x40, 0x0e, 0xa2, 0x09, 0x8e, 0x29, 0xea, 0xfe, 0xdd, 0x24, 0x38, 0xbf, 0x4f,
-	0x83, 0x43, 0x06, 0x09, 0xdb, 0x4b, 0x19, 0xd8, 0x6d, 0x30, 0xe3, 0x11, 0x04, 0x19, 0x26, 0x52,
-	0x41, 0x27, 0x1d, 0xda, 0x37, 0xc0, 0x82, 0x5e, 0xc7, 0x0d, 0x7d, 0xa1, 0xca, 0x9c, 0x33, 0xaf,
-	0x61, 0x7b, 0xbe, 0x7d, 0x1d, 0xcc, 0x27, 0x04, 0x47, 0x09, 0x73, 0xfb, 0x90, 0xf6, 0xdb, 0x2d,
-	0x81, 0x01, 0x24, 0xe8, 0x03, 0x48, 0xfb, 0xf6, 0x6d, 0xb0, 0xa4, 0x10, 0x12, 0x78, 0x3a, 0xc0,
-	0xd0, 0x6f, 0x4f, 0x0a, 0x2b, 0x4e, 0xb4, 0x2d, 0x67, 0x51, 0xce, 0x1c, 0xc8, 0x09, 0x7b, 0x05,
-	0x4c, 0x45, 0xd8, 0x47, 0x83, 0xf6, 0xb4, 0xe0, 0x22, 0x07, 0x5c, 0x08, 0x82, 0x3e, 0x1b, 0x22,
-	0xca, 0x90, 0xef, 0xf6, 0x4e, 0xdb, 0x33, 0x52, 0x08, 0x0d, 0xdb, 0x3e, 0xe5, 0x42, 0x40, 0x4a,
-	0xc3, 0x20, 0x46, 0xbe, 0xcb, 0x70, 0x7b, 0x56, 0x0a, 0x91, 0x82, 0x1e, 0x63, 0xce, 0x83, 0x3b,
-	0xa0, 0x7b, 0x8c, 0x08, 0x0d, 0x71, 0xdc, 0x9e, 0x93, 0x3c, 0x38, 0xec, 0x13, 0x09, 0xb2, 0xaf,
-	0x01, 0x10, 0xc1, 0xa7, 0x2e, 0xc3, 0x4f, 0x50, 0x4c, 0xdb, 0x60, 0xcd, 0x5a, 0x9f, 0x74, 0xe6,
-	0x22, 0xf8, 0xf4, 0xb1, 0x00, 0xd8, 0xaf, 0x01, 0x5b, 0xa9, 0x21, 0x30, 0x5c, 0x0f, 0x0f, 0x63,
-	0xd6, 0x9e, 0x17, 0x68, 0xcb, 0x72, 0x46, 0x60, 0xee, 0x70, 0xb8, 0x7d, 0x17, 0x9c, 0x57, 0xf2,
-	0xb9, 0x2c, 0x8c, 0x10, 0x65, 0x30, 0x4a, 0xda, 0x0b, 0x6b, 0xd6, 0x7a, 0xcb, 0x59, 0x56, 0x13,
-	0x8f, 0x53, 0xb8, 0x7d, 0x0f, 0xd8, 0x8c, 0xc0, 0x98, 0x1e, 0x21, 0xe2, 0x72, 0x89, 0x21, 0x1b,
-	0x12, 0xd4, 0x5e, 0x12, 0x22, 0x9e, 0x4f, 0x67, 0x0e, 0xd3, 0x09, 0xfb, 0x2e, 0x38, 0x87, 0x49,
-	0x18, 0x84, 0x31, 0x1c, 0xb8, 0x72, 0xe1, 0xf6, 0x39, 0x6d, 0xd1, 0xa5, 0x74, 0xea, 0x40, 0xcc,
-	0xd8, 0xaf, 0x83, 0x95, 0x12, 0xb2, 0xdc, 0xa7, 0x65, 0xc1, 0xdd, 0x2e, 0x62, 0xf3, 0xfd, 0x7a,
-	0xb0, 0xc0, 0x1d, 0x2f, 0xf5, 0x80, 0x6e, 0x08, 0x2e, 0x8f, 0x38, 0x4c, 0xea, 0x4e, 0xf6, 0x2d,
-	0x70, 0x2e, 0xe7, 0x1e, 0xb1, 0x8f, 0x9e, 0x2a, 0x07, 0x5a, 0xca, 0x3c, 0x84, 0x43, 0xed, 0x97,
-	0xc1, 0x22, 0x22, 0x04, 0x13, 0x37, 0x42, 0x94, 0xc2, 0x00, 0x29, 0x47, 0x5a, 0x10, 0xc0, 0x7d,
-	0x09, 0xeb, 0xfe, 0xd5, 0x14, 0xb0, 0xf7, 0x69, 0xf0, 0x5e, 0x18, 0x87, 0xb4, 0xff, 0x2d, 0x79,
-	0xe7, 0xcb, 0x60, 0x91, 0x28, 0x69, 0xf3, 0xfe, 0xb9, 0x90, 0x02, 0x85, 0x87, 0xde, 0x03, 0xcb,
-	0x1a, 0x69, 0xd4, 0x47, 0xcf, 0xa5, 0x73, 0xa9, 0x97, 0x56, 0x7b, 0xc2, 0x94, 0xc1, 0x13, 0xde,
-	0x04, 0x17, 0x3d, 0x1c, 0x25, 0x03, 0xc4, 0xf3, 0x4c, 0x81, 0x62, 0x5a, 0x50, 0xac, 0x64, 0xb3,
-	0x39, 0xaa, 0xeb, 0x60, 0x1e, 0x3d, 0x45, 0xde, 0xb0, 0xe0, 0xf2, 0x20, 0x05, 0x6d, 0x9f, 0xda,
-	0x37, 0xc1, 0x52, 0xea, 0x19, 0x44, 0xe2, 0x48, 0xa7, 0x5f, 0xcc, 0x41, 0xb7, 0x4f, 0xab, 0xfd,
-	0x70, 0xee, 0x4c, 0x7e, 0x08, 0x4c, 0x7e, 0x78, 0x0f, 0xd8, 0x52, 0x20, 0x9c, 0x47, 0x9f, 0x97,
-	0xe8, 0xe9, 0x4c, 0x86, 0x5e, 0x0e, 0xe3, 0x85, 0xd1, 0x30, 0xae, 0xf0, 0xec, 0x45, 0xa3, 0x67,
-	0xeb, 0x64, 0xb1, 0x94, 0x4f, 0x16, 0xa5, 0x74, 0x74, 0x6e, 0x24, 0x1d, 0x7d, 0xd3, 0x80, 0xf8,
-	0x11, 0xe8, 0x8c, 0x3a, 0xe9, 0x0b, 0x8a, 0x88, 0x3f, 0xb1, 0x44, 0x2a, 0x3f, 0x1c, 0xf6, 0xa2,
-	0x90, 0x3d, 0x44, 0x27, 0x07, 0x90, 0xb0, 0xd0, 0x0b, 0x13, 0x18, 0xb3, 0x9a, 0xb0, 0x58, 0x06,
-	0xad, 0x21, 0x19, 0x28, 0x86, 0xfc, 0x27, 0x5f, 0xec, 0x18, 0x0e, 0x42, 0x9f, 0x4f, 0xbb, 0x4f,
-	0xd0, 0x69, 0x1a, 0x05, 0x1a, 0xf8, 0x21, 0x3a, 0xe5, 0xf9, 0xef, 0x04, 0x93, 0x27, 0x48, 0x62,
-	0x08, 0xff, 0x77, 0xe6, 0x24, 0xe4, 0x43, 0x74, 0x5a, 0xb2, 0xc2, 0x11, 0xb8, 0x6e, 0x10, 0x4c,
-	0x9b, 0xe2, 0x2e, 0x38, 0x9f, 0x64, 0xe0, 0x82, 0x31, 0x96, 0x73, 0x13, 0xd2, 0x1c, 0x17, 0xc1,
-	0x34, 0x65, 0x90, 0x0d, 0xa9, 0x12, 0x5b, 0x8d, 0xba, 0xff, 0x30, 0x01, 0x16, 0xf7, 0x69, 0xf0,
-	0x89, 0x14, 0x94, 0xa7, 0x69, 0xb3, 0xde, 0x4b, 0x60, 0x42, 0x27, 0x81, 0x89, 0xd0, 0x1f, 0x49,
-	0x0f, 0xad, 0xd1, 0xf4, 0x70, 0xc6, 0xc8, 0x1f, 0xc9, 0x26, 0x53, 0x15, 0xd9, 0xa4, 0x0d, 0xa6,
-	0x8e, 0xe1, 0x60, 0x88, 0x44, 0x7c, 0x5b, 0x82, 0x91, 0x04, 0xd8, 0x5d, 0x1e, 0x01, 0xc7, 0x5a,
-	0x15, 0x11, 0xd5, 0xb3, 0x4e, 0x01, 0x66, 0x6f, 0x89, 0xad, 0x1a, 0x22, 0xd7, 0x47, 0x5e, 0x18,
-	0xc1, 0x81, 0x08, 0xeb, 0xf9, 0xcd, 0xab, 0x95, 0xd5, 0xc3, 0xae, 0xc4, 0x11, 0x1b, 0x39, 0x44,
-	0x6a, 0x54, 0xda, 0xa9, 0x4b, 0xe0, 0x3b, 0x05, 0x03, 0xea, 0x5a, 0xe0, 0x17, 0x56, 0x71, 0x0f,
-	0x3f, 0x8e, 0x8f, 0x86, 0xb1, 0x8f, 0xfc, 0xf1, 0x9c, 0xac, 0x0d, 0x66, 0xa0, 0x2c, 0x7d, 0x94,
-	0xc5, 0xd3, 0x61, 0xea, 0x7e, 0xad, 0xcc, 0xfd, 0x2e, 0x81, 0x99, 0x64, 0xd8, 0xcb, 0xb9, 0xd5,
-	0x74, 0x32, 0xec, 0x71, 0x97, 0x1b, 0xf1, 0xcb, 0xa9, 0x46, 0xbf, 0x9c, 0xae, 0xf7, 0xcb, 0xdb,
-	0xe0, 0x56, 0x83, 0x4e, 0x5a, 0xff, 0xdf, 0xb5, 0xc0, 0xc5, 0x7d, 0x1a, 0xec, 0xc5, 0x6a, 0x35,
-	0xf4, 0x2d, 0x1d, 0x39, 0x6b, 0x60, 0x3e, 0x8c, 0xb5, 0x06, 0x99, 0xd7, 0x69, 0x50, 0x49, 0xe4,
-	0x35, 0xb0, 0x5a, 0x2d, 0x46, 0x59, 0x52, 0x07, 0xfd, 0xbf, 0x90, 0xb4, 0x42, 0x0c, 0x2d, 0x69,
-	0x2c, 0xea, 0xe7, 0x9d, 0x01, 0x0c, 0x23, 0x07, 0x9d, 0x40, 0xe2, 0xd3, 0x1a, 0x09, 0x6d, 0x30,
-	0x49, 0x11, 0x92, 0x92, 0xb5, 0x1c, 0xf1, 0x5b, 0x9c, 0x7b, 0x09, 0xf6, 0xfa, 0x2a, 0x5d, 0xb4,
-	0xc4, 0x11, 0x09, 0x04, 0x48, 0x24, 0x8a, 0x92, 0x44, 0x7b, 0x22, 0x3f, 0xe6, 0xd7, 0xd3, 0xe9,
-	0xe7, 0x22, 0x98, 0x86, 0x91, 0x38, 0x67, 0x2d, 0xc1, 0x44, 0x8d, 0x38, 0x9c, 0x20, 0x3a, 0x1c,
-	0xb0, 0x34, 0xd3, 0xc8, 0x51, 0xf7, 0xdf, 0x2d, 0x59, 0x1a, 0x0b, 0xd7, 0x39, 0xc0, 0xde, 0x36,
-	0x64, 0x5e, 0xbf, 0x46, 0xfa, 0xb7, 0xc1, 0x55, 0x7e, 0x87, 0xa0, 0x0c, 0x06, 0x88, 0xff, 0x4b,
-	0x98, 0xdb, 0x1b, 0x60, 0xef, 0x89, 0xdb, 0x47, 0x61, 0xd0, 0x67, 0x4a, 0xab, 0x76, 0x82, 0xbd,
-	0x43, 0x8e, 0x22, 0x2a, 0xa8, 0x6d, 0x8e, 0xf0, 0x81, 0x98, 0xb7, 0x2f, 0x83, 0xd9, 0x1e, 0x5f,
-	0x22, 0xcb, 0x4c, 0x33, 0x62, 0xbc, 0xe7, 0x73, 0x11, 0x63, 0x1c, 0x7b, 0x88, 0xb6, 0x27, 0xd7,
-	0x5a, 0xeb, 0x2d, 0x47, 0x8d, 0xb8, 0xc1, 0xfc, 0x90, 0xf2, 0x52, 0xa3, 0xb5, 0x6e, 0x39, 0xe2,
-	0x37, 0x8f, 0x2d, 0x51, 0xd8, 0x86, 0xbe, 0x0a, 0x8d, 0x69, 0x3e, 0xdc, 0xf3, 0x4b, 0x86, 0xba,
-	0x22, 0xcb, 0xb8, 0x82, 0x72, 0x7a, 0xd7, 0xbe, 0xb0, 0x8a, 0xb3, 0x59, 0xb2, 0xa0, 0x9f, 0x6c,
-	0xbe, 0x40, 0x13, 0x7c, 0x08, 0xe6, 0xb3, 0xcc, 0x47, 0xdb, 0xad, 0xb5, 0xd6, 0xfa, 0xfc, 0xe6,
-	0xed, 0xea, 0x7b, 0x12, 0xde, 0xc9, 0xa4, 0x7a, 0x37, 0x66, 0xe4, 0xf4, 0x93, 0x4d, 0x27, 0x4f,
-	0x5d, 0xd2, 0xf7, 0x65, 0x70, 0xc3, 0xa8, 0x91, 0xd6, 0xfb, 0xbf, 0x2d, 0x70, 0x61, 0x9f, 0x06,
-	0x9c, 0xf7, 0xe6, 0x21, 0xc3, 0x04, 0xed, 0xe0, 0x28, 0x0a, 0xd9, 0x0b, 0xd4, 0xb8, 0x0d, 0xa6,
-	0x64, 0xed, 0xc7, 0x77, 0x7c, 0x51, 0x9e, 0x0d, 0x9e, 0x2a, 0xf8, 0xe6, 0x08, 0xc6, 0xaa, 0x16,
-	0xe1, 0x59, 0x72, 0x41, 0xcc, 0xce, 0x72, 0xa0, 0x38, 0x56, 0xde, 0x01, 0x33, 0x28, 0x66, 0x24,
-	0x44, 0x54, 0xec, 0xff, 0xfc, 0xe6, 0x4d, 0xa3, 0xa1, 0x36, 0xa5, 0x1e, 0xc2, 0x4c, 0x4e, 0x4a,
-	0x55, 0x32, 0xd0, 0x35, 0x70, 0xa5, 0x42, 0x75, 0x6d, 0x9a, 0x3f, 0x98, 0x10, 0xf3, 0xfb, 0x1f,
-	0x3d, 0xc4, 0x3e, 0xfa, 0x54, 0x08, 0xbf, 0x1b, 0x52, 0x46, 0xc2, 0xde, 0xb0, 0xe1, 0x14, 0xfe,
-	0xa6, 0x26, 0x7a, 0x07, 0xcc, 0x9c, 0x88, 0x5f, 0xa9, 0x43, 0xdc, 0xa8, 0xd4, 0x33, 0x2f, 0x99,
-	0xb0, 0x54, 0x4a, 0x65, 0xbf, 0x97, 0x19, 0x6a, 0x52, 0x30, 0x78, 0xad, 0x86, 0x41, 0x5e, 0xa9,
-	0x5a, 0x7b, 0xdd, 0x04, 0x2f, 0xd7, 0xd8, 0x43, 0xdb, 0xed, 0x58, 0x94, 0x2b, 0xd2, 0xef, 0x0e,
-	0x79, 0x42, 0x33, 0x1b, 0xaa, 0x94, 0xea, 0x26, 0xca, 0xa9, 0xce, 0xbe, 0x0a, 0xe6, 0xb2, 0xb2,
-	0x5a, 0xa6, 0x88, 0x0c, 0x50, 0x79, 0xca, 0x67, 0xeb, 0x6a, 0x81, 0x3c, 0x21, 0xb7, 0x9c, 0xf8,
-	0x38, 0x0e, 0xd9, 0xa3, 0xa3, 0x1d, 0x1c, 0x25, 0x43, 0x86, 0x0e, 0x48, 0xe8, 0xa1, 0x03, 0x82,
-	0x13, 0x4c, 0xe1, 0xa0, 0x46, 0xcc, 0x15, 0x30, 0x95, 0x70, 0x54, 0x25, 0xa0, 0x1c, 0x94, 0x56,
-	0xbf, 0x07, 0xee, 0x8e, 0xb1, 0x88, 0x96, 0xe9, 0x4f, 0x5b, 0x60, 0x59, 0x1c, 0x24, 0x41, 0x48,
-	0x19, 0x22, 0xfb, 0xa2, 0x70, 0xbf, 0x3a, 0xd2, 0x67, 0xc9, 0x77, 0x53, 0x64, 0x59, 0x9f, 0x60,
-	0x2a, 0xef, 0x0e, 0x13, 0xba, 0xac, 0x17, 0xa0, 0xed, 0x53, 0x55, 0xfc, 0xb5, 0x74, 0xf1, 0xf7,
-	0x00, 0x74, 0x86, 0x71, 0xc8, 0xa8, 0x8b, 0x8f, 0x5c, 0x4f, 0x0a, 0xe3, 0x26, 0x88, 0xc8, 0x0b,
-	0x98, 0x08, 0xb0, 0x49, 0xe7, 0xa2, 0xc0, 0xc8, 0x84, 0x45, 0x44, 0xdc, 0xc0, 0x78, 0x4e, 0xed,
-	0x1f, 0xb9, 0x04, 0x25, 0x58, 0x15, 0x24, 0xd3, 0xfd, 0x23, 0x07, 0x25, 0xd8, 0xbe, 0x02, 0xe6,
-	0xfa, 0x82, 0x5d, 0x14, 0x32, 0x95, 0x6e, 0x67, 0xfb, 0x47, 0x2a, 0x6b, 0x5c, 0x03, 0x40, 0x5c,
-	0x41, 0x5c, 0x48, 0x02, 0xda, 0x9e, 0x59, 0x6b, 0x71, 0x0d, 0x04, 0x64, 0x8b, 0x04, 0xd4, 0xbe,
-	0x00, 0xa6, 0x8e, 0x5d, 0x02, 0x23, 0x51, 0xd0, 0x4d, 0x3a, 0x93, 0xc7, 0x0e, 0x8c, 0xf8, 0x65,
-	0x84, 0xf5, 0x09, 0x1e, 0x06, 0xfd, 0x64, 0xc8, 0x84, 0x7c, 0x22, 0xd5, 0x8b, 0x1b, 0xda, 0xa4,
-	0x63, 0x67, 0x73, 0x07, 0x88, 0x3c, 0xe4, 0x33, 0xf6, 0x23, 0xb0, 0x92, 0x65, 0x3d, 0x97, 0xf5,
-	0x09, 0xa2, 0x7d, 0x3c, 0xf0, 0xc5, 0x2d, 0xad, 0xa9, 0x4c, 0xbc, 0x90, 0x51, 0x3e, 0x4e, 0x09,
-	0x1f, 0x2c, 0x15, 0xfb, 0x4c, 0xdd, 0x0e, 0x68, 0x97, 0xf7, 0x46, 0x6f, 0xdc, 0xaf, 0x89, 0xb9,
-	0x5d, 0x34, 0x40, 0x0c, 0xbd, 0x8f, 0x8f, 0x11, 0x89, 0x61, 0xec, 0xa1, 0x71, 0xf6, 0xaf, 0x54,
-	0x9b, 0x8f, 0xac, 0xda, 0x05, 0x6b, 0x26, 0xce, 0x7a, 0xf5, 0x7f, 0xb1, 0x72, 0x4e, 0xfe, 0x81,
-	0xea, 0x2b, 0xee, 0x86, 0x47, 0x47, 0x35, 0xde, 0xfb, 0x3e, 0x58, 0x8c, 0xd1, 0xc9, 0x23, 0xae,
-	0x47, 0x78, 0x14, 0x8a, 0x62, 0xc3, 0x9c, 0x53, 0x52, 0x9e, 0x3c, 0xc6, 0x9d, 0x22, 0x9d, 0xfd,
-	0x2b, 0x60, 0x86, 0xa0, 0x08, 0x1f, 0x23, 0xbf, 0x36, 0x2d, 0x15, 0x58, 0xa4, 0x14, 0xa5, 0x68,
-	0xb9, 0x0e, 0xae, 0x55, 0xaa, 0xa1, 0x15, 0xfd, 0x5b, 0x79, 0xed, 0xdb, 0xe1, 0xf8, 0x48, 0x94,
-	0xae, 0x70, 0xf0, 0x71, 0x12, 0x10, 0xe8, 0xa3, 0x06, 0x33, 0x5f, 0x04, 0xd3, 0xb9, 0x34, 0x3b,
-	0xe9, 0xa8, 0x11, 0xaf, 0xf4, 0x72, 0xad, 0xae, 0xb4, 0xd2, 0xcb, 0x77, 0xbf, 0xd6, 0xc1, 0x39,
-	0x98, 0x84, 0xdb, 0x61, 0x0c, 0x79, 0xf2, 0xfb, 0x21, 0xc5, 0xb1, 0xaa, 0xd5, 0xcb, 0xe0, 0x91,
-	0xad, 0xbb, 0x21, 0xae, 0x11, 0x55, 0xc2, 0x6a, 0x85, 0xfe, 0x75, 0x42, 0xd4, 0x56, 0xdb, 0xa2,
-	0xc5, 0xfb, 0xee, 0x53, 0xaf, 0x0f, 0xe3, 0x40, 0xa8, 0x92, 0x15, 0x9f, 0x4a, 0x15, 0x0d, 0xe0,
-	0x22, 0xcb, 0xbb, 0xf8, 0x4e, 0x1f, 0x86, 0x71, 0x5a, 0xbe, 0xe6, 0x40, 0x5c, 0x64, 0x0f, 0xc7,
-	0x8c, 0x40, 0x8f, 0xa9, 0x2e, 0xac, 0x52, 0xac, 0x0c, 0xe6, 0x17, 0x2f, 0x7c, 0x12, 0x23, 0x92,
-	0xa2, 0x49, 0xcd, 0x0a, 0x30, 0xb1, 0x1e, 0x1f, 0x1f, 0x88, 0xab, 0x89, 0x0a, 0xfc, 0x3c, 0x28,
-	0x57, 0x51, 0xaa, 0x4a, 0x4b, 0x55, 0x94, 0x6b, 0x60, 0x5e, 0x9c, 0x70, 0x0f, 0x87, 0x51, 0x0f,
-	0x91, 0xb4, 0x3d, 0x99, 0x03, 0xc9, 0x8b, 0x9f, 0x87, 0xc2, 0x44, 0xde, 0x76, 0x55, 0xab, 0xa6,
-	0x00, 0xcb, 0xe1, 0x50, 0x07, 0x63, 0xa6, 0x3a, 0x94, 0x05, 0x98, 0x32, 0xbd, 0xb6, 0x51, 0xf7,
-	0xae, 0xa8, 0xdb, 0x8a, 0x66, 0xd5, 0x05, 0xb0, 0x0c, 0x39, 0x2b, 0x0d, 0xb9, 0xee, 0x13, 0xe1,
-	0x76, 0x5b, 0x7e, 0xfe, 0x32, 0x44, 0x1f, 0xe3, 0xad, 0xc1, 0x00, 0x9f, 0x7c, 0xc4, 0x4b, 0xc9,
-	0x7a, 0xd7, 0xe2, 0xb3, 0xd2, 0x54, 0x88, 0x8a, 0x28, 0xe2, 0xb3, 0x29, 0x60, 0xc4, 0x29, 0x6e,
-	0x81, 0x9b, 0xb5, 0x8b, 0x69, 0xd7, 0x48, 0x40, 0x57, 0xa4, 0x1b, 0x1e, 0x28, 0x79, 0xdc, 0xf7,
-	0x08, 0x8e, 0x5e, 0x8c, 0x68, 0xaf, 0x81, 0x3b, 0xcd, 0x2b, 0x6a, 0xf9, 0x7e, 0x6a, 0x89, 0x7e,
-	0x4f, 0x9a, 0x0f, 0xa5, 0xad, 0xb7, 0x52, 0xe6, 0xcd, 0x82, 0x79, 0xdc, 0x55, 0x1f, 0xc2, 0x28,
-	0x6d, 0xf0, 0x64, 0x80, 0xa2, 0xd8, 0xad, 0x26, 0xb1, 0x5f, 0x51, 0x86, 0xaa, 0x94, 0x43, 0x8b,
-	0xfb, 0x5f, 0x56, 0x21, 0x7d, 0x8b, 0xf3, 0x6c, 0x1f, 0x31, 0xe8, 0x43, 0x06, 0x1b, 0x84, 0xe5,
-	0x49, 0x94, 0xcb, 0xb6, 0x97, 0xe6, 0xe9, 0x74, 0x78, 0x86, 0x40, 0xb3, 0xc1, 0x64, 0xcc, 0x75,
-	0x95, 0x01, 0x26, 0x7e, 0x8b, 0xd6, 0xce, 0x69, 0xd4, 0xc3, 0x83, 0xf4, 0x30, 0x95, 0x23, 0xbb,
-	0x03, 0x66, 0x55, 0x8f, 0x83, 0x8a, 0x80, 0x5a, 0x74, 0xf4, 0x98, 0x4b, 0xca, 0x0f, 0x81, 0x13,
-	0x12, 0x32, 0xa4, 0xda, 0x24, 0x19, 0xc0, 0x70, 0x78, 0x54, 0xea, 0xac, 0x0d, 0xf3, 0xc7, 0xb2,
-	0xdb, 0xb1, 0x95, 0x24, 0x04, 0x1f, 0x23, 0x69, 0x3e, 0x81, 0xf9, 0x1e, 0x26, 0x8f, 0x09, 0xf4,
-	0xc3, 0x38, 0x78, 0xf1, 0xf6, 0x19, 0x91, 0x5c, 0xb6, 0x2b, 0xea, 0x84, 0xd2, 0x0a, 0xfc, 0x65,
-	0x71, 0x67, 0x3f, 0x0a, 0x3f, 0x1b, 0x86, 0x7e, 0xc8, 0x4e, 0x0f, 0x30, 0x6e, 0x3a, 0x7c, 0x2f,
-	0x81, 0x19, 0x4f, 0xdd, 0x11, 0xd5, 0x9d, 0xd7, 0x13, 0x77, 0x44, 0x5e, 0xdb, 0x0d, 0x60, 0x0f,
-	0xa5, 0xcd, 0x1a, 0x39, 0x90, 0x3d, 0x4c, 0xca, 0x60, 0xcc, 0x42, 0xc8, 0x90, 0x1b, 0xd1, 0x40,
-	0xed, 0xe7, 0x52, 0x0e, 0xbc, 0x4f, 0x83, 0x86, 0x7d, 0x28, 0x48, 0xa8, 0xd5, 0xf8, 0xcf, 0x34,
-	0x9e, 0x44, 0xd7, 0x57, 0xaa, 0xfc, 0x69, 0xc8, 0xfa, 0x3e, 0x81, 0x27, 0xb5, 0x75, 0xe8, 0x0d,
-	0xb0, 0x30, 0xa4, 0x88, 0xb8, 0xc5, 0xae, 0xd3, 0x3c, 0x87, 0xa5, 0xde, 0x97, 0x25, 0xe8, 0x56,
-	0x21, 0x41, 0x6f, 0x80, 0x0b, 0x3e, 0xa2, 0x2c, 0x8c, 0x65, 0xd1, 0x04, 0x0b, 0xa7, 0x80, 0x9d,
-	0x9b, 0x4a, 0x19, 0xfd, 0x00, 0x74, 0xf2, 0x04, 0xf2, 0x69, 0x52, 0xd3, 0x49, 0x37, 0x6e, 0xe7,
-	0x30, 0x0a, 0xd1, 0x58, 0x3a, 0xed, 0x7f, 0x66, 0xa9, 0xc0, 0xad, 0x54, 0x58, 0x67, 0xeb, 0x6b,
-	0x00, 0xa4, 0x8d, 0x7a, 0x9d, 0xb5, 0xe7, 0x14, 0x64, 0xcf, 0x6f, 0xbe, 0x2c, 0xbc, 0x02, 0x96,
-	0x7a, 0x03, 0xea, 0xe6, 0x78, 0xa8, 0x1e, 0x6f, 0x6f, 0x40, 0x9d, 0x94, 0x4d, 0xf7, 0x4b, 0x0b,
-	0xac, 0x94, 0x85, 0xd9, 0x0f, 0x6b, 0x1b, 0x7d, 0x99, 0x51, 0x27, 0xc6, 0x31, 0x6a, 0xcb, 0x68,
-	0xd4, 0xcb, 0x60, 0x56, 0x04, 0x0c, 0x97, 0x6d, 0xb2, 0x18, 0x40, 0xdf, 0xa6, 0xbd, 0x7f, 0xc7,
-	0x02, 0x57, 0xab, 0x54, 0xfc, 0x5f, 0xb6, 0x34, 0x14, 0xd1, 0xba, 0xc3, 0xab, 0xd8, 0x81, 0x14,
-	0xe2, 0x51, 0x82, 0x48, 0x53, 0x0b, 0xbb, 0x28, 0xdb, 0x44, 0x49, 0xb6, 0x92, 0xa6, 0x32, 0xdc,
-	0x2a, 0x97, 0xd0, 0xe1, 0xf6, 0x8f, 0x13, 0xc2, 0xfb, 0xb2, 0x92, 0xba, 0x5a, 0xa2, 0xe7, 0x7d,
-	0xe4, 0xae, 0x97, 0xd7, 0x7e, 0x1f, 0xd8, 0x7c, 0x61, 0x12, 0xfa, 0xc8, 0x25, 0xc8, 0x0b, 0x93,
-	0x10, 0xa5, 0xc1, 0x59, 0xc3, 0xff, 0x7c, 0x4a, 0xe3, 0xa4, 0x24, 0xf6, 0x63, 0x70, 0x59, 0x33,
-	0x3a, 0x21, 0x30, 0x49, 0x90, 0xef, 0xa6, 0xb9, 0x55, 0x35, 0xec, 0xcd, 0xfc, 0x2e, 0xa5, 0xa4,
-	0x9f, 0x4a, 0xca, 0x1d, 0x45, 0x28, 0x5b, 0x81, 0x90, 0x97, 0xba, 0x53, 0x69, 0x2b, 0x10, 0x56,
-	0x55, 0xb8, 0xb2, 0x62, 0x68, 0xb0, 0xa1, 0x36, 0xf9, 0x4f, 0xe4, 0x49, 0x93, 0xa6, 0x41, 0xb5,
-	0xa8, 0x7a, 0xdb, 0x53, 0x2b, 0x3f, 0xaf, 0xbd, 0x4b, 0x99, 0x7c, 0x32, 0xcd, 0xe4, 0x86, 0x83,
-	0xa5, 0x4e, 0x06, 0x2d, 0xef, 0x3f, 0xcb, 0x8c, 0xbc, 0x1f, 0x06, 0x04, 0x32, 0xb4, 0x35, 0x18,
-	0xe4, 0xb1, 0x9f, 0xff, 0xfb, 0x87, 0x55, 0x30, 0x1f, 0xa3, 0x13, 0xb7, 0x28, 0xee, 0x5c, 0x8c,
-	0x4e, 0x76, 0xe4, 0xd9, 0xb3, 0x0e, 0x96, 0x23, 0xb9, 0x24, 0x3f, 0x61, 0xdc, 0x1f, 0x51, 0x7d,
-	0x2f, 0x59, 0x52, 0xf0, 0x7d, 0x1a, 0xf0, 0x0b, 0x87, 0x38, 0xa5, 0x42, 0x7e, 0xe3, 0x9e, 0x14,
-	0x55, 0x82, 0x1c, 0x8c, 0x68, 0xbc, 0x2d, 0x1c, 0xdd, 0xa0, 0x85, 0x0e, 0x7e, 0x7e, 0x50, 0x32,
-	0x86, 0xa2, 0x84, 0x21, 0x19, 0xfb, 0x8b, 0x4e, 0x06, 0xe0, 0x5b, 0x77, 0x35, 0x3b, 0x8f, 0xf7,
-	0x7a, 0xde, 0xb7, 0x55, 0x21, 0x74, 0xc0, 0x6c, 0xd8, 0xf3, 0x76, 0x51, 0x8c, 0x23, 0xa5, 0xa4,
-	0x1e, 0x8f, 0x28, 0xf2, 0x2a, 0x78, 0xa5, 0x4e, 0x06, 0xbd, 0x6f, 0xcf, 0x2c, 0xd1, 0xa2, 0x4b,
-	0xf7, 0x38, 0xc5, 0xfc, 0xc6, 0xd5, 0x5e, 0x8d, 0xac, 0xff, 0x47, 0xf5, 0x9d, 0xec, 0xbd, 0x99,
-	0x14, 0xd5, 0x06, 0x61, 0xb9, 0x5b, 0xf3, 0xae, 0xfa, 0x12, 0xe8, 0x5d, 0xf1, 0x21, 0xd0, 0xd8,
-	0xc7, 0x5b, 0xf6, 0x4c, 0x70, 0x19, 0xcc, 0xca, 0x6e, 0x4e, 0xd6, 0x9e, 0x17, 0xe3, 0x91, 0x2c,
-	0xfc, 0x76, 0xee, 0xfa, 0x5b, 0x5c, 0x55, 0x3b, 0xdd, 0x15, 0x30, 0x27, 0x3f, 0x48, 0x4a, 0x0f,
-	0x9c, 0x49, 0x67, 0x56, 0x02, 0xf6, 0xfc, 0xee, 0x5f, 0xb7, 0xe4, 0x1b, 0x2f, 0x62, 0x6c, 0x50,
-	0x21, 0x36, 0x15, 0x70, 0x2d, 0xb6, 0x1a, 0x16, 0x59, 0x4e, 0x14, 0x59, 0xda, 0xbb, 0xe0, 0x3a,
-	0x65, 0x3c, 0xb0, 0x44, 0x47, 0x19, 0xc6, 0xbe, 0xfc, 0x00, 0xcc, 0xc3, 0x83, 0xd2, 0xf7, 0x2f,
-	0x57, 0x04, 0x1a, 0xbf, 0x5a, 0x6e, 0xc5, 0xfe, 0x81, 0xc2, 0xc9, 0x7d, 0x0f, 0x93, 0x71, 0x11,
-	0x36, 0x58, 0x70, 0xe6, 0x34, 0x01, 0x8f, 0x4a, 0xd9, 0xab, 0x92, 0xbd, 0x34, 0x39, 0xe0, 0x72,
-	0x11, 0x7e, 0x1a, 0xe8, 0xd7, 0xd1, 0x05, 0x67, 0x96, 0x03, 0x44, 0x0b, 0xfb, 0x11, 0x00, 0x7d,
-	0x4c, 0x99, 0xcb, 0x99, 0x70, 0x9f, 0x68, 0xad, 0xcf, 0x6f, 0xbe, 0x6e, 0xe8, 0x58, 0x49, 0x3b,
-	0x48, 0xab, 0x44, 0x28, 0x66, 0x1f, 0x60, 0xca, 0x0e, 0x39, 0x9d, 0x33, 0xd7, 0x4f, 0x7f, 0xda,
-	0x3f, 0x04, 0x40, 0x37, 0x44, 0x65, 0xcb, 0x6d, 0x7e, 0xf3, 0x4e, 0x3d, 0xc3, 0x01, 0x66, 0xfa,
-	0x93, 0x04, 0x27, 0x47, 0xcd, 0x5d, 0xfb, 0x08, 0x21, 0x9a, 0xb6, 0xe7, 0xf8, 0x6f, 0xb5, 0xd3,
-	0xca, 0xe6, 0xaa, 0xd1, 0x51, 0xb5, 0x51, 0xda, 0x05, 0x03, 0xd9, 0xda, 0x41, 0x2c, 0x9d, 0x57,
-	0x05, 0x01, 0x7d, 0x37, 0x86, 0xbd, 0x01, 0xf2, 0x9b, 0x83, 0x12, 0x49, 0x44, 0xb1, 0xa7, 0xb3,
-	0x4e, 0x3a, 0x34, 0xdc, 0xaf, 0xcd, 0x0b, 0xa5, 0x12, 0x6d, 0xfe, 0xc5, 0x2d, 0xd0, 0xda, 0xa7,
-	0x81, 0xdd, 0x03, 0x0b, 0x85, 0xcf, 0xda, 0x5e, 0xa9, 0x6e, 0x8a, 0x17, 0xbf, 0x1b, 0xeb, 0xbc,
-	0x36, 0x0e, 0x96, 0xf6, 0xf3, 0x3e, 0x58, 0x2a, 0x7d, 0x59, 0xf6, 0xaa, 0x89, 0xbe, 0x88, 0xd7,
-	0xb9, 0x3f, 0x1e, 0x9e, 0x5e, 0xe9, 0x09, 0x38, 0x57, 0xfe, 0x4c, 0xe8, 0x96, 0x89, 0x45, 0x09,
-	0xb1, 0xb3, 0x31, 0x26, 0xa2, 0x5e, 0xec, 0x37, 0xc1, 0x4a, 0xe5, 0x17, 0x18, 0x46, 0xe3, 0x54,
-	0x61, 0x77, 0xde, 0x3c, 0x0b, 0xb6, 0x5e, 0xfb, 0x37, 0x00, 0xc8, 0x7d, 0xfb, 0xd0, 0x35, 0xf1,
-	0xc8, 0x70, 0x3a, 0x77, 0x9a, 0x71, 0x34, 0xf7, 0x3f, 0xb2, 0xc0, 0xd5, 0xda, 0xf7, 0xff, 0x66,
-	0xa1, 0x2b, 0xa8, 0x3a, 0x3f, 0x78, 0x1e, 0x2a, 0x2d, 0xd4, 0x09, 0xb8, 0x50, 0xf5, 0x26, 0x7f,
-	0xd7, 0xc4, 0xb4, 0x02, 0xb9, 0xf3, 0xdd, 0x33, 0x20, 0xe7, 0x17, 0xae, 0x7a, 0x62, 0x37, 0x2e,
-	0x5c, 0x81, 0x6c, 0x5e, 0xb8, 0xe6, 0xd5, 0x9c, 0xc7, 0x66, 0xe1, 0xc9, 0xdc, 0x18, 0x9b, 0x79,
-	0x2c, 0x73, 0x6c, 0x56, 0x3e, 0x87, 0xf3, 0xd8, 0x2c, 0x3e, 0x6d, 0xbf, 0x5a, 0xbf, 0x4b, 0x29,
-	0x5e, 0x4d, 0x6c, 0x56, 0xbe, 0x26, 0xdb, 0x3f, 0xb6, 0xc0, 0x45, 0xc3, 0x53, 0x72, 0x33, 0xab,
-	0x02, 0x7e, 0xe7, 0xfb, 0x67, 0xc3, 0xd7, 0x22, 0xc4, 0x60, 0x79, 0xe4, 0x51, 0x77, 0xdd, 0xc4,
-	0xab, 0x8c, 0xd9, 0x79, 0x7d, 0x5c, 0x4c, 0xbd, 0xde, 0x4f, 0x2d, 0xd0, 0x36, 0x3e, 0x95, 0x1a,
-	0xd9, 0x99, 0x28, 0x3a, 0x6f, 0x9d, 0x95, 0x22, 0x9f, 0x2e, 0x72, 0x6f, 0x8f, 0xdd, 0x7a, 0xf3,
-	0x71, 0x1c, 0x73, 0xba, 0x18, 0x7d, 0x4b, 0xb4, 0xff, 0xdc, 0x02, 0x6b, 0x8d, 0x2f, 0x89, 0x6f,
-	0xd5, 0x33, 0x34, 0x53, 0x76, 0x7e, 0xf5, 0x79, 0x29, 0xb5, 0x80, 0x08, 0x2c, 0x16, 0x1f, 0x15,
-	0x6f, 0x9a, 0xc3, 0x31, 0x87, 0xd6, 0xb9, 0x37, 0x16, 0x9a, 0x5e, 0xe6, 0xb7, 0xc0, 0x77, 0xaa,
-	0xdf, 0xc0, 0x8c, 0x7c, 0x2a, 0xd1, 0x3b, 0xdf, 0x3b, 0x13, 0xba, 0x5e, 0x9e, 0x01, 0xbb, 0xe2,
-	0x0d, 0xac, 0x61, 0x23, 0xf3, 0xb8, 0x9d, 0xcd, 0xf1, 0x71, 0xf3, 0xa7, 0x60, 0xe5, 0x83, 0x94,
-	0x39, 0x0d, 0x55, 0x60, 0x9b, 0x4f, 0xc1, 0xba, 0xf7, 0x23, 0x9e, 0xbc, 0x4a, 0x6f, 0x47, 0xc6,
-	0xe4, 0x55, 0xc4, 0x33, 0x27, 0x2f, 0xc3, 0xa3, 0xc9, 0x6f, 0x5b, 0xe0, 0x92, 0xa9, 0xd7, 0xbf,
-	0xd1, 0xe4, 0x25, 0x25, 0x82, 0xce, 0x2f, 0x9d, 0x91, 0x20, 0xef, 0x60, 0xd5, 0x7d, 0xde, 0x46,
-	0x47, 0x2d, 0xa0, 0x9b, 0x1d, 0xac, 0xb6, 0x47, 0x9b, 0x5f, 0xbe, 0x78, 0xa5, 0x6c, 0x5c, 0xbe,
-	0x80, 0xde, 0xbc, 0x7c, 0xe5, 0x3d, 0x4e, 0x54, 0x25, 0xb5, 0x7d, 0x7a, 0xa3, 0x13, 0xd5, 0x51,
-	0x99, 0xab, 0x92, 0x71, 0xda, 0xef, 0xca, 0x31, 0xaa, 0x9b, 0xd6, 0x35, 0x8e, 0x51, 0x49, 0x50,
-	0xe7, 0x18, 0xf5, 0x5d, 0xe2, 0xcf, 0xc0, 0xf9, 0xd1, 0xde, 0xed, 0xed, 0xb1, 0xb8, 0x71, 0xd4,
-	0xce, 0x1b, 0x63, 0xa3, 0xe6, 0x9d, 0xa1, 0xba, 0x67, 0x68, 0x74, 0x86, 0x4a, 0x74, 0xb3, 0x33,
-	0xd4, 0x76, 0xd3, 0xec, 0x3f, 0xb3, 0xc0, 0xf5, 0xa6, 0xee, 0xa5, 0xd1, 0x9c, 0x0d, 0x84, 0x9d,
-	0x77, 0x9e, 0x93, 0xb0, 0xe0, 0xaa, 0xb5, 0x8d, 0xbe, 0x37, 0x9b, 0x42, 0xa0, 0x8a, 0xca, 0xec,
-	0xaa, 0xe3, 0x34, 0xf4, 0x84, 0xab, 0x9a, 0xba, 0x79, 0x46, 0x57, 0x35, 0x10, 0x98, 0x5d, 0xb5,
-	0xa9, 0xd3, 0xf6, 0xfb, 0x16, 0xe8, 0xd4, 0x3c, 0x36, 0x1b, 0x8f, 0x20, 0x33, 0x4d, 0xe7, 0xc1,
-	0xd9, 0x69, 0x0a, 0x7e, 0xd4, 0xf4, 0xca, 0x5c, 0x13, 0x96, 0xb5, 0x84, 0x66, 0x3f, 0x1a, 0xf3,
-	0x95, 0xd9, 0xfe, 0x3d, 0x0b, 0x5c, 0x36, 0x77, 0x1d, 0xdf, 0x68, 0xc8, 0x5c, 0xa3, 0x24, 0x9d,
-	0x5f, 0x3e, 0x33, 0x49, 0xa1, 0x98, 0x35, 0x36, 0x15, 0x5f, 0x6f, 0xf2, 0xcc, 0x32, 0x85, 0xb9,
-	0x98, 0x6d, 0xea, 0xe7, 0x65, 0x15, 0x47, 0xa9, 0x2b, 0xd6, 0x50, 0x71, 0x14, 0xb1, 0x9b, 0x2a,
-	0x0e, 0x43, 0xcb, 0x8e, 0xdf, 0xf9, 0xab, 0x3a, 0x72, 0xe6, 0x3b, 0x7f, 0x05, 0x76, 0xcd, 0x9d,
-	0xbf, 0xa6, 0x89, 0x24, 0x22, 0xa7, 0xa6, 0x85, 0xb4, 0x59, 0xc3, 0xd4, 0x40, 0x63, 0x8e, 0x9c,
-	0xe6, 0x0e, 0x12, 0xbf, 0x4c, 0x1d, 0x22, 0x76, 0x80, 0x77, 0x76, 0xf5, 0x9f, 0x4b, 0x9a, 0x2f,
-	0x53, 0x65, 0x4c, 0xf3, 0x65, 0xaa, 0x8c, 0x59, 0xbc, 0x86, 0x1f, 0x0d, 0x29, 0x2a, 0x2e, 0x59,
-	0x73, 0x0d, 0x1f, 0x41, 0xae, 0xbb, 0x86, 0x8f, 0x20, 0xe7, 0x15, 0xdd, 0x45, 0xde, 0x00, 0x12,
-	0x3e, 0xbf, 0x17, 0x33, 0x14, 0xd7, 0xdc, 0x1a, 0xcb, 0x98, 0x66, 0x45, 0xcb, 0x98, 0xe9, 0x7a,
-	0x9d, 0xa9, 0x1f, 0x3f, 0xfb, 0xfc, 0x8e, 0xb5, 0xfd, 0xe8, 0xe7, 0x5f, 0xad, 0x5a, 0x5f, 0x7c,
-	0xb5, 0x6a, 0x7d, 0xf9, 0xd5, 0xaa, 0xf5, 0x87, 0x5f, 0xaf, 0xbe, 0xf4, 0xc5, 0xd7, 0xab, 0x2f,
-	0xfd, 0xdb, 0xd7, 0xab, 0x2f, 0xfd, 0xfa, 0xf7, 0x82, 0x90, 0xf5, 0x87, 0xbd, 0xfb, 0x1e, 0x8e,
-	0x36, 0x12, 0x82, 0xfd, 0xa1, 0xc7, 0xa8, 0x17, 0x96, 0xfe, 0x90, 0x35, 0xff, 0x97, 0xa0, 0xec,
-	0x34, 0x41, 0xb4, 0x37, 0x2d, 0xba, 0xbd, 0xdf, 0xfd, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4b,
-	0xca, 0xd6, 0x2d, 0x5d, 0x3c, 0x00, 0x00,
+func (m *MsgScheduleMaintenance) Reset()         { *m = MsgScheduleMaintenance{} }
+func (m *MsgScheduleMaintenance) String() string { return proto.CompactTextString(m) }
+func (*MsgScheduleMaintenance) ProtoMessage()    {}
+func (*MsgScheduleMaintenance) Descriptor() ([]byte, []int) {
+	return fileDescriptor_09b36d0241b9acd5, []int{76}
 }
-
-// Reference imports to suppress errors if they are not otherwise used.
+func (m *MsgScheduleMaintenance) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgScheduleMaintenance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgScheduleMaintenance.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 *MsgScheduleMaintenance) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgScheduleMaintenance.Merge(m, src)
+}
+func (m *MsgScheduleMaintenance) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgScheduleMaintenance) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgScheduleMaintenance.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgScheduleMaintenance proto.InternalMessageInfo
+
+func (m *MsgScheduleMaintenance) GetCreator() string {
+	if m != nil {
+		return m.Creator
+	}
+	return ""
+}
+
+func (m *MsgScheduleMaintenance) GetParticipant() string {
+	if m != nil {
+		return m.Participant
+	}
+	return ""
+}
+
+func (m *MsgScheduleMaintenance) GetStartHeight() int64 {
+	if m != nil {
+		return m.StartHeight
+	}
+	return 0
+}
+
+func (m *MsgScheduleMaintenance) GetDurationBlocks() uint64 {
+	if m != nil {
+		return m.DurationBlocks
+	}
+	return 0
+}
+
+type MsgScheduleMaintenanceResponse struct {
+	ReservationId uint64 `protobuf:"varint,1,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+}
+
+func (m *MsgScheduleMaintenanceResponse) Reset()         { *m = MsgScheduleMaintenanceResponse{} }
+func (m *MsgScheduleMaintenanceResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgScheduleMaintenanceResponse) ProtoMessage()    {}
+func (*MsgScheduleMaintenanceResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_09b36d0241b9acd5, []int{77}
+}
+func (m *MsgScheduleMaintenanceResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgScheduleMaintenanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgScheduleMaintenanceResponse.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 *MsgScheduleMaintenanceResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgScheduleMaintenanceResponse.Merge(m, src)
+}
+func (m *MsgScheduleMaintenanceResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgScheduleMaintenanceResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgScheduleMaintenanceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgScheduleMaintenanceResponse proto.InternalMessageInfo
+
+func (m *MsgScheduleMaintenanceResponse) GetReservationId() uint64 {
+	if m != nil {
+		return m.ReservationId
+	}
+	return 0
+}
+
+// MsgCancelMaintenance cancels a not-yet-active maintenance reservation.
+type MsgCancelMaintenance struct {
+	Creator       string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
+	ReservationId uint64 `protobuf:"varint,2,opt,name=reservation_id,json=reservationId,proto3" json:"reservation_id,omitempty"`
+}
+
+func (m *MsgCancelMaintenance) Reset()         { *m = MsgCancelMaintenance{} }
+func (m *MsgCancelMaintenance) String() string { return proto.CompactTextString(m) }
+func (*MsgCancelMaintenance) ProtoMessage()    {}
+func (*MsgCancelMaintenance) Descriptor() ([]byte, []int) {
+	return fileDescriptor_09b36d0241b9acd5, []int{78}
+}
+func (m *MsgCancelMaintenance) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgCancelMaintenance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgCancelMaintenance.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 *MsgCancelMaintenance) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgCancelMaintenance.Merge(m, src)
+}
+func (m *MsgCancelMaintenance) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgCancelMaintenance) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgCancelMaintenance.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgCancelMaintenance proto.InternalMessageInfo
+
+func (m *MsgCancelMaintenance) GetCreator() string {
+	if m != nil {
+		return m.Creator
+	}
+	return ""
+}
+
+func (m *MsgCancelMaintenance) GetReservationId() uint64 {
+	if m != nil {
+		return m.ReservationId
+	}
+	return 0
+}
+
+type MsgCancelMaintenanceResponse struct {
+}
+
+func (m *MsgCancelMaintenanceResponse) Reset()         { *m = MsgCancelMaintenanceResponse{} }
+func (m *MsgCancelMaintenanceResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgCancelMaintenanceResponse) ProtoMessage()    {}
+func (*MsgCancelMaintenanceResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_09b36d0241b9acd5, []int{79}
+}
+func (m *MsgCancelMaintenanceResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgCancelMaintenanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgCancelMaintenanceResponse.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 *MsgCancelMaintenanceResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgCancelMaintenanceResponse.Merge(m, src)
+}
+func (m *MsgCancelMaintenanceResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgCancelMaintenanceResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgCancelMaintenanceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgCancelMaintenanceResponse proto.InternalMessageInfo
+
+func init() {
+	proto.RegisterType((*MsgUpdateParams)(nil), "inference.inference.MsgUpdateParams")
+	proto.RegisterType((*MsgUpdateParamsResponse)(nil), "inference.inference.MsgUpdateParamsResponse")
+	proto.RegisterType((*MsgStartInference)(nil), "inference.inference.MsgStartInference")
+	proto.RegisterType((*MsgStartInferenceResponse)(nil), "inference.inference.MsgStartInferenceResponse")
+	proto.RegisterType((*MsgFinishInference)(nil), "inference.inference.MsgFinishInference")
+	proto.RegisterType((*MsgFinishInferenceResponse)(nil), "inference.inference.MsgFinishInferenceResponse")
+	proto.RegisterType((*MsgSubmitNewParticipant)(nil), "inference.inference.MsgSubmitNewParticipant")
+	proto.RegisterType((*MsgSubmitNewParticipantResponse)(nil), "inference.inference.MsgSubmitNewParticipantResponse")
+	proto.RegisterType((*MsgValidation)(nil), "inference.inference.MsgValidation")
+	proto.RegisterType((*MsgValidationResponse)(nil), "inference.inference.MsgValidationResponse")
+	proto.RegisterType((*MsgSubmitNewUnfundedParticipant)(nil), "inference.inference.MsgSubmitNewUnfundedParticipant")
+	proto.RegisterType((*MsgSubmitNewUnfundedParticipantResponse)(nil), "inference.inference.MsgSubmitNewUnfundedParticipantResponse")
+	proto.RegisterType((*MsgInvalidateInference)(nil), "inference.inference.MsgInvalidateInference")
+	proto.RegisterType((*MsgInvalidateInferenceResponse)(nil), "inference.inference.MsgInvalidateInferenceResponse")
+	proto.RegisterType((*MsgRevalidateInference)(nil), "inference.inference.MsgRevalidateInference")
+	proto.RegisterType((*MsgRevalidateInferenceResponse)(nil), "inference.inference.MsgRevalidateInferenceResponse")
+	proto.RegisterType((*MsgClaimRewards)(nil), "inference.inference.MsgClaimRewards")
+	proto.RegisterType((*MsgClaimRewardsResponse)(nil), "inference.inference.MsgClaimRewardsResponse")
+	proto.RegisterType((*MsgSetClaimRecipients)(nil), "inference.inference.MsgSetClaimRecipients")
+	proto.RegisterType((*MsgSetClaimRecipientsResponse)(nil), "inference.inference.MsgSetClaimRecipientsResponse")
+	proto.RegisterType((*MsgSubmitPocBatch)(nil), "inference.inference.MsgSubmitPocBatch")
+	proto.RegisterType((*MsgSubmitPocBatchResponse)(nil), "inference.inference.MsgSubmitPocBatchResponse")
+	proto.RegisterType((*MsgSubmitPocValidationsV2)(nil), "inference.inference.MsgSubmitPocValidationsV2")
+	proto.RegisterType((*MsgSubmitPocValidationsV2Response)(nil), "inference.inference.MsgSubmitPocValidationsV2Response")
+	proto.RegisterType((*MsgPoCV2StoreCommit)(nil), "inference.inference.MsgPoCV2StoreCommit")
+	proto.RegisterType((*MsgPoCV2StoreCommitResponse)(nil), "inference.inference.MsgPoCV2StoreCommitResponse")
+	proto.RegisterType((*MsgMLNodeWeightDistribution)(nil), "inference.inference.MsgMLNodeWeightDistribution")
+	proto.RegisterType((*MsgMLNodeWeightDistributionResponse)(nil), "inference.inference.MsgMLNodeWeightDistributionResponse")
+	proto.RegisterType((*MsgSubmitSeed)(nil), "inference.inference.MsgSubmitSeed")
+	proto.RegisterType((*MsgSubmitSeedResponse)(nil), "inference.inference.MsgSubmitSeedResponse")
+	proto.RegisterType((*MsgSubmitUnitOfComputePriceProposal)(nil), "inference.inference.MsgSubmitUnitOfComputePriceProposal")
+	proto.RegisterType((*MsgSubmitUnitOfComputePriceProposalResponse)(nil), "inference.inference.MsgSubmitUnitOfComputePriceProposalResponse")
+	proto.RegisterType((*MsgRegisterModel)(nil), "inference.inference.MsgRegisterModel")
+	proto.RegisterType((*MsgRegisterModelResponse)(nil), "inference.inference.MsgRegisterModelResponse")
+	proto.RegisterType((*MsgDeleteGovernanceModel)(nil), "inference.inference.MsgDeleteGovernanceModel")
+	proto.RegisterType((*MsgDeleteGovernanceModelResponse)(nil), "inference.inference.MsgDeleteGovernanceModelResponse")
+	proto.RegisterType((*MsgSubmitHardwareDiff)(nil), "inference.inference.MsgSubmitHardwareDiff")
+	proto.RegisterType((*MsgSubmitHardwareDiffResponse)(nil), "inference.inference.MsgSubmitHardwareDiffResponse")
+	proto.RegisterType((*MsgCreatePartialUpgrade)(nil), "inference.inference.MsgCreatePartialUpgrade")
+	proto.RegisterType((*MsgCreatePartialUpgradeResponse)(nil), "inference.inference.MsgCreatePartialUpgradeResponse")
+	proto.RegisterType((*MsgBridgeExchange)(nil), "inference.inference.MsgBridgeExchange")
+	proto.RegisterType((*MsgBridgeExchangeResponse)(nil), "inference.inference.MsgBridgeExchangeResponse")
+	proto.RegisterType((*MsgAddParticipantsToAllowList)(nil), "inference.inference.MsgAddParticipantsToAllowList")
+	proto.RegisterType((*MsgAddParticipantsToAllowListResponse)(nil), "inference.inference.MsgAddParticipantsToAllowListResponse")
+	proto.RegisterType((*MsgRemoveParticipantsFromAllowList)(nil), "inference.inference.MsgRemoveParticipantsFromAllowList")
+	proto.RegisterType((*MsgRemoveParticipantsFromAllowListResponse)(nil), "inference.inference.MsgRemoveParticipantsFromAllowListResponse")
+	proto.RegisterType((*MsgRegisterBridgeAddresses)(nil), "inference.inference.MsgRegisterBridgeAddresses")
+	proto.RegisterType((*MsgRegisterBridgeAddressesResponse)(nil), "inference.inference.MsgRegisterBridgeAddressesResponse")
+	proto.RegisterType((*MsgRegisterTokenMetadata)(nil), "inference.inference.MsgRegisterTokenMetadata")
+	proto.RegisterType((*MsgRegisterTokenMetadataResponse)(nil), "inference.inference.MsgRegisterTokenMetadataResponse")
+	proto.RegisterType((*MsgApproveBridgeTokenForTrading)(nil), "inference.inference.MsgApproveBridgeTokenForTrading")
+	proto.RegisterType((*MsgApproveBridgeTokenForTradingResponse)(nil), "inference.inference.MsgApproveBridgeTokenForTradingResponse")
+	proto.RegisterType((*MsgRegisterLiquidityPool)(nil), "inference.inference.MsgRegisterLiquidityPool")
+	proto.RegisterType((*MsgRegisterLiquidityPoolResponse)(nil), "inference.inference.MsgRegisterLiquidityPoolResponse")
+	proto.RegisterType((*MsgRequestBridgeWithdrawal)(nil), "inference.inference.MsgRequestBridgeWithdrawal")
+	proto.RegisterType((*MsgRequestBridgeWithdrawalResponse)(nil), "inference.inference.MsgRequestBridgeWithdrawalResponse")
+	proto.RegisterType((*MsgRequestBridgeMint)(nil), "inference.inference.MsgRequestBridgeMint")
+	proto.RegisterType((*MsgRequestBridgeMintResponse)(nil), "inference.inference.MsgRequestBridgeMintResponse")
+	proto.RegisterType((*MsgCancelBridgeOperation)(nil), "inference.inference.MsgCancelBridgeOperation")
+	proto.RegisterType((*MsgCancelBridgeOperationResponse)(nil), "inference.inference.MsgCancelBridgeOperationResponse")
+	proto.RegisterType((*MsgGovernanceCancelBridgeOperation)(nil), "inference.inference.MsgGovernanceCancelBridgeOperation")
+	proto.RegisterType((*MsgGovernanceCancelBridgeOperationResponse)(nil), "inference.inference.MsgGovernanceCancelBridgeOperationResponse")
+	proto.RegisterType((*MsgRegisterWrappedTokenContract)(nil), "inference.inference.MsgRegisterWrappedTokenContract")
+	proto.RegisterType((*MsgRegisterWrappedTokenContractResponse)(nil), "inference.inference.MsgRegisterWrappedTokenContractResponse")
+	proto.RegisterType((*MsgMigrateAllWrappedTokens)(nil), "inference.inference.MsgMigrateAllWrappedTokens")
+	proto.RegisterType((*MsgMigrateAllWrappedTokensResponse)(nil), "inference.inference.MsgMigrateAllWrappedTokensResponse")
+	proto.RegisterType((*MsgApproveIbcTokenForTrading)(nil), "inference.inference.MsgApproveIbcTokenForTrading")
+	proto.RegisterType((*MsgApproveIbcTokenForTradingResponse)(nil), "inference.inference.MsgApproveIbcTokenForTradingResponse")
+	proto.RegisterType((*MsgRegisterIbcTokenMetadata)(nil), "inference.inference.MsgRegisterIbcTokenMetadata")
+	proto.RegisterType((*MsgRegisterIbcTokenMetadataResponse)(nil), "inference.inference.MsgRegisterIbcTokenMetadataResponse")
+	proto.RegisterType((*MsgCreateDevshardEscrow)(nil), "inference.inference.MsgCreateDevshardEscrow")
+	proto.RegisterType((*MsgCreateDevshardEscrowResponse)(nil), "inference.inference.MsgCreateDevshardEscrowResponse")
+	proto.RegisterType((*MsgSettleDevshardEscrow)(nil), "inference.inference.MsgSettleDevshardEscrow")
+	proto.RegisterType((*MsgSettleDevshardEscrowResponse)(nil), "inference.inference.MsgSettleDevshardEscrowResponse")
+	proto.RegisterType((*MsgSetDevshardRequestsEnabled)(nil), "inference.inference.MsgSetDevshardRequestsEnabled")
+	proto.RegisterType((*MsgSetDevshardRequestsEnabledResponse)(nil), "inference.inference.MsgSetDevshardRequestsEnabledResponse")
+	proto.RegisterType((*MsgScheduleMaintenance)(nil), "inference.inference.MsgScheduleMaintenance")
+	proto.RegisterType((*MsgScheduleMaintenanceResponse)(nil), "inference.inference.MsgScheduleMaintenanceResponse")
+	proto.RegisterType((*MsgCancelMaintenance)(nil), "inference.inference.MsgCancelMaintenance")
+	proto.RegisterType((*MsgCancelMaintenanceResponse)(nil), "inference.inference.MsgCancelMaintenanceResponse")
+}
+
+func init() { proto.RegisterFile("inference/inference/tx.proto", fileDescriptor_09b36d0241b9acd5) }
+
+var fileDescriptor_09b36d0241b9acd5 = []byte{
+	// 4062 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3b, 0x5d, 0x8b, 0x1c, 0x49,
+	0x72, 0x5b, 0xd3, 0xf3, 0x19, 0xf3, 0x21, 0xa9, 0x34, 0x27, 0xb5, 0x5a, 0x5f, 0xa3, 0x5e, 0x69,
+	0x35, 0xfa, 0x9c, 0xdd, 0xb9, 0xbd, 0xf3, 0x5a, 0x3e, 0x76, 0x3d, 0x1f, 0xbb, 0xab, 0xb9, 0xdd,
+	0x91, 0x86, 0x1a, 0xed, 0xae, 0x31, 0x86, 0xa6, 0xba, 0x2a, 0xa7, 0xbb, 0xac, 0xae, 0xca, 0xda,
+	0xcc, 0xec, 0x19, 0xcd, 0x71, 0x86, 0xe3, 0x6c, 0xce, 0xbe, 0xc3, 0x18, 0x63, 0x3f, 0x18, 0xce,
+	0x60, 0xfc, 0x62, 0x6c, 0x30, 0x98, 0x35, 0xf8, 0x0f, 0xf8, 0x0b, 0xee, 0x71, 0x39, 0x30, 0x18,
+	0x0c, 0xe6, 0xd8, 0x7d, 0xd0, 0x9b, 0x1f, 0xfc, 0xe6, 0x37, 0x93, 0x1f, 0x95, 0xf5, 0xd1, 0x95,
+	0x55, 0x3d, 0xda, 0x95, 0x7d, 0x2f, 0x52, 0x57, 0x64, 0x64, 0x64, 0x44, 0x64, 0x44, 0x64, 0x44,
+	0x64, 0x0e, 0x5c, 0x0a, 0xa2, 0x03, 0x44, 0x50, 0xe4, 0xa1, 0xb5, 0xf4, 0x17, 0x7b, 0x76, 0x3f,
+	0x26, 0x98, 0x61, 0xfb, 0xac, 0x86, 0xdd, 0xd7, 0xbf, 0x5a, 0x67, 0xdc, 0x30, 0x88, 0xf0, 0x9a,
+	0xf8, 0x57, 0xe2, 0xb5, 0xce, 0x7b, 0x98, 0x86, 0x98, 0xae, 0x85, 0xb4, 0xb7, 0x76, 0xf8, 0x06,
+	0xff, 0x4f, 0x0d, 0x5c, 0x90, 0x03, 0x1d, 0xf1, 0xb5, 0x26, 0x3f, 0xd4, 0xd0, 0x72, 0x0f, 0xf7,
+	0xb0, 0x84, 0xf3, 0x5f, 0xc9, 0x84, 0x1e, 0xc6, 0xbd, 0x01, 0x5a, 0x13, 0x5f, 0xdd, 0xe1, 0xc1,
+	0x9a, 0x1b, 0x1d, 0xab, 0xa1, 0x95, 0x32, 0x56, 0x63, 0x97, 0xb8, 0x61, 0x42, 0xf2, 0x66, 0x19,
+	0x46, 0xdf, 0x25, 0xfe, 0x91, 0x4b, 0x50, 0x27, 0xc2, 0x3e, 0xaa, 0x22, 0xd5, 0x25, 0x81, 0xdf,
+	0xab, 0xc4, 0x88, 0xb1, 0xd7, 0x39, 0x5c, 0x57, 0x18, 0xb7, 0xca, 0x30, 0x7c, 0x74, 0x48, 0xf9,
+	0x82, 0x1d, 0x44, 0x3d, 0x82, 0x8f, 0x14, 0xea, 0x8d, 0x32, 0xd4, 0xd0, 0x0d, 0x22, 0x86, 0x22,
+	0x97, 0x2b, 0x57, 0xa2, 0xad, 0x9a, 0xd6, 0xf4, 0xd1, 0x00, 0xf5, 0x5c, 0x16, 0xe0, 0xa8, 0x6a,
+	0x6d, 0x6f, 0xe0, 0x06, 0x61, 0x87, 0x20, 0x2f, 0x88, 0x03, 0x14, 0x31, 0x89, 0xda, 0xfe, 0x67,
+	0x0b, 0x4e, 0xed, 0xd2, 0xde, 0x47, 0xb1, 0xef, 0x32, 0xb4, 0x27, 0xb4, 0x65, 0x7f, 0x1b, 0xe6,
+	0xdc, 0x21, 0xeb, 0x63, 0x12, 0xb0, 0xe3, 0xa6, 0xb5, 0x62, 0xad, 0xce, 0x6d, 0x36, 0x7f, 0xfe,
+	0x0f, 0xf7, 0x96, 0xd5, 0xfe, 0x6c, 0xf8, 0x3e, 0x41, 0x94, 0xee, 0x33, 0x12, 0x44, 0x3d, 0x27,
+	0x45, 0xb5, 0xdf, 0x86, 0x69, 0xa9, 0xef, 0xe6, 0xc4, 0x8a, 0xb5, 0x3a, 0xbf, 0x7e, 0xf1, 0x7e,
+	0x89, 0x7d, 0xdc, 0x97, 0x8b, 0x6c, 0xce, 0xfd, 0xec, 0x3f, 0xaf, 0xbe, 0xf2, 0x37, 0xcf, 0x3f,
+	0xbb, 0x6d, 0x39, 0x6a, 0xd6, 0x83, 0xb7, 0x7e, 0xf8, 0xfc, 0xb3, 0xdb, 0x29, 0xbd, 0x9f, 0x3c,
+	0xff, 0xec, 0x76, 0x46, 0x35, 0xcf, 0x32, 0xb2, 0x14, 0x38, 0x6e, 0x5f, 0x80, 0xf3, 0x05, 0x90,
+	0x83, 0x68, 0x8c, 0x23, 0x8a, 0xda, 0x7f, 0x3f, 0x09, 0x67, 0x76, 0x69, 0x6f, 0x9f, 0xb9, 0x84,
+	0xed, 0x24, 0x04, 0xec, 0x26, 0xcc, 0x78, 0x04, 0xb9, 0x0c, 0x13, 0x29, 0xa0, 0x93, 0x7c, 0xda,
+	0xd7, 0x60, 0x41, 0xaf, 0xd3, 0x09, 0x7c, 0x21, 0xca, 0x9c, 0x33, 0xaf, 0x61, 0x3b, 0xbe, 0x7d,
+	0x15, 0xe6, 0x63, 0x82, 0xc3, 0x98, 0x75, 0xfa, 0x2e, 0xed, 0x37, 0x1b, 0x02, 0x03, 0x24, 0xe8,
+	0xa1, 0x4b, 0xfb, 0xf6, 0x2d, 0x58, 0x52, 0x08, 0xb1, 0x7b, 0x3c, 0xc0, 0xae, 0xdf, 0x9c, 0x14,
+	0x5a, 0x9c, 0x68, 0x5a, 0xce, 0xa2, 0x1c, 0xd9, 0x93, 0x03, 0xf6, 0x32, 0x4c, 0x85, 0xd8, 0x47,
+	0x83, 0xe6, 0xb4, 0xa0, 0x22, 0x3f, 0x38, 0x13, 0x04, 0x7d, 0x3a, 0x44, 0x94, 0x21, 0xbf, 0xd3,
+	0x3d, 0x6e, 0xce, 0x48, 0x26, 0x34, 0x6c, 0xf3, 0x98, 0x33, 0xe1, 0x52, 0x1a, 0xf4, 0x22, 0xe4,
+	0x77, 0x18, 0x6e, 0xce, 0x4a, 0x26, 0x12, 0xd0, 0x13, 0xcc, 0x69, 0x70, 0x93, 0xee, 0x1c, 0x22,
+	0x42, 0x03, 0x1c, 0x35, 0xe7, 0x24, 0x0d, 0x0e, 0xfb, 0x58, 0x82, 0xec, 0xcb, 0x00, 0xa1, 0xfb,
+	0xac, 0xc3, 0xf0, 0x53, 0x14, 0xd1, 0x26, 0xac, 0x58, 0xab, 0x93, 0xce, 0x5c, 0xe8, 0x3e, 0x7b,
+	0x22, 0x00, 0xf6, 0x5d, 0xb0, 0x95, 0x18, 0x02, 0xa3, 0xe3, 0xe1, 0x61, 0xc4, 0x9a, 0xf3, 0x02,
+	0xed, 0xb4, 0x1c, 0x11, 0x98, 0x5b, 0x1c, 0x6e, 0xdf, 0x81, 0x33, 0x8a, 0xbf, 0x0e, 0x0b, 0x42,
+	0x44, 0x99, 0x1b, 0xc6, 0xcd, 0x85, 0x15, 0x6b, 0xb5, 0xe1, 0x9c, 0x56, 0x03, 0x4f, 0x12, 0xb8,
+	0x7d, 0x0f, 0x6c, 0x46, 0xdc, 0x88, 0x1e, 0x20, 0xd2, 0xe1, 0x1c, 0xbb, 0x6c, 0x48, 0x50, 0x73,
+	0x49, 0xb0, 0x78, 0x26, 0x19, 0xd9, 0x4f, 0x06, 0xec, 0x3b, 0x70, 0x0a, 0x93, 0xa0, 0x17, 0x44,
+	0xee, 0xa0, 0x23, 0x17, 0x6e, 0x9e, 0xd2, 0x1a, 0x5d, 0x4a, 0x86, 0xf6, 0xc4, 0x88, 0xfd, 0x3a,
+	0x2c, 0x17, 0x90, 0xe5, 0x3e, 0x9d, 0x16, 0xd4, 0xed, 0x3c, 0x36, 0xdf, 0xaf, 0x07, 0x4b, 0xdc,
+	0xf0, 0x52, 0x83, 0x68, 0x87, 0x70, 0x61, 0xc4, 0x64, 0x12, 0x83, 0xb2, 0x6f, 0xc2, 0xa9, 0x8c,
+	0x81, 0x44, 0x3e, 0x7a, 0xa6, 0x4c, 0x68, 0x29, 0xb5, 0x11, 0x0e, 0xb5, 0x5f, 0x85, 0x45, 0x44,
+	0x08, 0x26, 0x9d, 0x10, 0x51, 0xea, 0xf6, 0x90, 0x32, 0xa5, 0x05, 0x01, 0xdc, 0x95, 0xb0, 0x07,
+	0x13, 0x4d, 0xab, 0xfd, 0x57, 0x53, 0x60, 0xef, 0xd2, 0xde, 0x7b, 0x41, 0x14, 0xd0, 0xfe, 0xd7,
+	0x64, 0xa3, 0xaf, 0xc2, 0x22, 0x51, 0x1c, 0x67, 0xad, 0x74, 0x21, 0x01, 0x0a, 0x3b, 0xbd, 0x07,
+	0xa7, 0x35, 0xd2, 0xa8, 0xa5, 0x9e, 0x4a, 0xc6, 0x12, 0x5b, 0x2d, 0xb7, 0x87, 0x29, 0x83, 0x3d,
+	0xbc, 0x09, 0xe7, 0x3c, 0x1c, 0xc6, 0x03, 0xc4, 0x03, 0x53, 0x6e, 0xc6, 0xb4, 0x98, 0xb1, 0x9c,
+	0x8e, 0x66, 0x66, 0x5d, 0x85, 0x79, 0xf4, 0x0c, 0x79, 0xc3, 0x9c, 0xe1, 0x43, 0x02, 0xda, 0x3c,
+	0xb6, 0x6f, 0xc0, 0x52, 0x62, 0x1f, 0x44, 0xe2, 0x48, 0xd3, 0x5f, 0xcc, 0x40, 0x37, 0x8f, 0xcb,
+	0xad, 0x71, 0xee, 0x44, 0xd6, 0x08, 0x26, 0x6b, 0xbc, 0x07, 0xb6, 0x64, 0x08, 0x67, 0xd1, 0xe7,
+	0x25, 0x7a, 0x32, 0x92, 0xa2, 0x17, 0x9d, 0x79, 0x61, 0xd4, 0x99, 0x4b, 0xec, 0x7b, 0xd1, 0x68,
+	0xdf, 0x3a, 0x64, 0x2c, 0x65, 0x43, 0x46, 0x21, 0x28, 0x9d, 0x1a, 0x09, 0x4a, 0x5f, 0xdd, 0x2d,
+	0x22, 0x68, 0x8d, 0x9a, 0xe9, 0x4b, 0xf4, 0x8b, 0x3f, 0xb3, 0x44, 0x58, 0xdf, 0x1f, 0x76, 0xc3,
+	0x80, 0x3d, 0x42, 0x47, 0x7b, 0x2e, 0x61, 0x81, 0x17, 0xc4, 0x6e, 0xc4, 0x2a, 0x9c, 0xe3, 0x34,
+	0x34, 0x86, 0x64, 0xa0, 0x88, 0xf2, 0x9f, 0x7c, 0xc1, 0x43, 0x77, 0x10, 0xf8, 0x7c, 0xb8, 0xf3,
+	0x14, 0x1d, 0x27, 0xbe, 0xa0, 0x81, 0x1f, 0xa0, 0x63, 0x1e, 0x0b, 0x8f, 0x30, 0x79, 0x8a, 0x24,
+	0x86, 0xf0, 0x02, 0x67, 0x4e, 0x42, 0x3e, 0x40, 0xc7, 0x0f, 0x16, 0xb2, 0xba, 0x68, 0x1f, 0xc0,
+	0x55, 0x03, 0x63, 0x5a, 0x1d, 0x77, 0xe0, 0x4c, 0x9c, 0x82, 0x73, 0x0a, 0x39, 0x9d, 0x19, 0x90,
+	0x2a, 0x39, 0x07, 0xd3, 0x94, 0xb9, 0x6c, 0x48, 0x15, 0xdb, 0xea, 0xab, 0xfd, 0x8f, 0x13, 0xb0,
+	0xb8, 0x4b, 0x7b, 0x1f, 0x4b, 0x46, 0x79, 0xc8, 0x36, 0xcb, 0xbd, 0x04, 0x13, 0x3a, 0x14, 0x4c,
+	0x04, 0xfe, 0x48, 0x90, 0x68, 0x8c, 0x06, 0x89, 0x13, 0xfa, 0xff, 0x48, 0x4c, 0x99, 0x2a, 0x89,
+	0x29, 0x4d, 0x98, 0x3a, 0x74, 0x07, 0x43, 0x24, 0xbc, 0xdc, 0x12, 0x84, 0x24, 0xc0, 0x6e, 0x73,
+	0x3f, 0x38, 0xd4, 0xa2, 0x08, 0xdf, 0x9e, 0x75, 0x72, 0x30, 0x7b, 0x43, 0x6c, 0xd5, 0x10, 0x75,
+	0x7c, 0xe4, 0x05, 0xa1, 0x3b, 0x10, 0xce, 0x3d, 0xbf, 0x7e, 0xa9, 0x34, 0x93, 0xd8, 0x96, 0x38,
+	0x62, 0x23, 0x87, 0x48, 0x7d, 0x8d, 0x58, 0xed, 0x45, 0xf8, 0x46, 0x4e, 0x85, 0xc9, 0x0e, 0x09,
+	0x13, 0xfb, 0xb9, 0x95, 0xdf, 0xc9, 0x8f, 0xa2, 0x83, 0x61, 0xe4, 0x23, 0x7f, 0x3c, 0x53, 0x6b,
+	0xc2, 0x8c, 0x2b, 0x93, 0x21, 0xa5, 0xf7, 0xe4, 0x33, 0x31, 0xc2, 0x46, 0x6a, 0x84, 0xe7, 0x61,
+	0x26, 0x1e, 0x76, 0x33, 0xc6, 0x35, 0x1d, 0x0f, 0xbb, 0xdc, 0xf0, 0x46, 0xac, 0x73, 0xaa, 0xd6,
+	0x3a, 0xa7, 0xab, 0xad, 0xf3, 0x16, 0xdc, 0xac, 0x91, 0x49, 0x67, 0x47, 0xbf, 0x6f, 0xc1, 0xb9,
+	0x5d, 0xda, 0xdb, 0x89, 0xd4, 0x6a, 0xe8, 0x6b, 0x3a, 0x7e, 0x56, 0x60, 0x3e, 0x88, 0xb4, 0x04,
+	0xa9, 0xed, 0x69, 0xd0, 0xc8, 0x36, 0x5d, 0x87, 0x2b, 0xe5, 0x8c, 0xe4, 0xf6, 0x4b, 0xf1, 0xeb,
+	0xa0, 0x5f, 0x12, 0x7e, 0x4b, 0x18, 0xc9, 0xf1, 0x1b, 0x89, 0xec, 0x7a, 0x8b, 0xa7, 0xde, 0x0e,
+	0x3a, 0x72, 0x89, 0x4f, 0x2b, 0xf8, 0xb4, 0x61, 0x92, 0x22, 0x24, 0xf9, 0x6b, 0x38, 0xe2, 0xb7,
+	0x38, 0x0f, 0x63, 0xec, 0xf5, 0x55, 0x00, 0x69, 0x88, 0xa3, 0x13, 0x04, 0x48, 0x84, 0x8e, 0xc2,
+	0xd6, 0xef, 0x88, 0x88, 0x99, 0x5d, 0x4f, 0x07, 0xa4, 0x73, 0x30, 0xed, 0x86, 0xe2, 0xfc, 0xb5,
+	0x04, 0x11, 0xf5, 0xc5, 0xe1, 0x04, 0xd1, 0xe1, 0x80, 0x25, 0xb1, 0x47, 0x7e, 0xb5, 0x7f, 0x6c,
+	0x09, 0xc7, 0xd9, 0x47, 0x4c, 0x91, 0x53, 0x85, 0x43, 0x95, 0x04, 0x0f, 0x61, 0x06, 0x45, 0x8c,
+	0x04, 0x88, 0x3b, 0x44, 0x63, 0x75, 0x7e, 0x7d, 0xb5, 0xd4, 0x71, 0xf3, 0x04, 0xdf, 0x8d, 0x18,
+	0x39, 0xde, 0x9c, 0xe4, 0xf5, 0x80, 0x93, 0x4c, 0x2f, 0x88, 0x75, 0x15, 0x2e, 0x97, 0xb2, 0xa2,
+	0xed, 0xf8, 0x3f, 0x2c, 0x99, 0xe5, 0x0b, 0x9b, 0xdf, 0xc3, 0xde, 0xa6, 0xcb, 0xbc, 0x7e, 0x05,
+	0xa3, 0x6f, 0xc3, 0x25, 0x5e, 0x39, 0x51, 0xe6, 0xf6, 0x10, 0xff, 0x97, 0xb0, 0x4e, 0x77, 0x80,
+	0xbd, 0xa7, 0x9d, 0x3e, 0x0a, 0x7a, 0x7d, 0xa6, 0xb6, 0xa0, 0x19, 0x63, 0x6f, 0x9f, 0xa3, 0x88,
+	0x54, 0x70, 0x93, 0x23, 0x3c, 0x14, 0xe3, 0xf6, 0x05, 0x98, 0xed, 0xf2, 0x25, 0xd2, 0xc0, 0x3a,
+	0x23, 0xbe, 0x77, 0x7c, 0xae, 0xcf, 0x08, 0x47, 0x1e, 0xa2, 0xcd, 0xc9, 0x95, 0xc6, 0x6a, 0xc3,
+	0x51, 0x5f, 0x7c, 0x77, 0xfd, 0x80, 0xf2, 0x7c, 0xa9, 0xb1, 0x6a, 0x39, 0xe2, 0x37, 0x0f, 0x0a,
+	0x22, 0x47, 0x0f, 0x7c, 0xe5, 0xd3, 0xd3, 0xfc, 0x73, 0xc7, 0x2f, 0x88, 0x7f, 0x51, 0xe6, 0xa3,
+	0x39, 0xe1, 0xb4, 0xe8, 0x9f, 0x5b, 0xf9, 0xd1, 0x34, 0xd2, 0xd1, 0x8f, 0xd7, 0x5f, 0xa2, 0x0a,
+	0x3e, 0x80, 0xf9, 0x34, 0x70, 0xd3, 0x66, 0x43, 0xec, 0xf7, 0xad, 0xf2, 0x92, 0x0f, 0x6f, 0xa5,
+	0x5c, 0x89, 0xed, 0xfe, 0x78, 0xdd, 0xc9, 0xce, 0x2e, 0xc8, 0xfb, 0x2a, 0x5c, 0x33, 0x4a, 0xa4,
+	0xe5, 0xfe, 0x1f, 0x0b, 0xce, 0xee, 0xd2, 0x1e, 0xa7, 0xbd, 0xbe, 0xcf, 0x30, 0x41, 0x5b, 0x38,
+	0x0c, 0x03, 0xf6, 0x12, 0x25, 0x6e, 0xc2, 0x94, 0x4c, 0x60, 0xf9, 0x8e, 0x2f, 0xca, 0xa3, 0xcd,
+	0x53, 0x59, 0xeb, 0x1c, 0xc1, 0x58, 0x25, 0x54, 0x3c, 0xbc, 0x2f, 0x88, 0xd1, 0x59, 0x0e, 0x14,
+	0xa7, 0xe2, 0x3b, 0xa9, 0x63, 0x4c, 0x09, 0x45, 0xdd, 0x30, 0x2a, 0x6a, 0x5d, 0xca, 0x21, 0xd4,
+	0x64, 0xf2, 0x87, 0xcb, 0x70, 0xb1, 0x44, 0x74, 0xad, 0x9a, 0x3f, 0x9a, 0x10, 0xe3, 0xbb, 0x1f,
+	0x3e, 0xc2, 0x3e, 0xfa, 0x44, 0x30, 0xbf, 0x1d, 0x50, 0x46, 0x82, 0xee, 0xb0, 0x26, 0x89, 0xf8,
+	0xaa, 0x2a, 0x7a, 0x07, 0x66, 0x8e, 0xc4, 0xaf, 0xc4, 0x20, 0xae, 0x95, 0xca, 0x99, 0xe5, 0x4c,
+	0x68, 0x2a, 0x99, 0x65, 0xbf, 0x97, 0x2a, 0x6a, 0x52, 0x10, 0xb8, 0x5b, 0x41, 0x20, 0x2b, 0x54,
+	0xa5, 0xbe, 0x6e, 0xc0, 0xab, 0x15, 0xfa, 0xd0, 0x7a, 0x3b, 0x14, 0xd9, 0x96, 0xb4, 0xbb, 0x7d,
+	0x1e, 0x7d, 0xcd, 0x8a, 0x2a, 0xc4, 0xe5, 0x89, 0x62, 0x5c, 0xb6, 0x2f, 0xc1, 0x5c, 0x5a, 0x1b,
+	0xc8, 0x10, 0x91, 0x02, 0x0a, 0xec, 0x9d, 0x97, 0x91, 0x56, 0xaf, 0xab, 0x19, 0xf2, 0x04, 0xdf,
+	0x72, 0xe0, 0xa3, 0x28, 0x60, 0x8f, 0x0f, 0xb6, 0x70, 0x18, 0x0f, 0x19, 0xda, 0x23, 0x81, 0x87,
+	0xf6, 0x08, 0x8e, 0x31, 0x75, 0x07, 0x15, 0x6c, 0x2e, 0xc3, 0x54, 0xcc, 0x51, 0x15, 0x83, 0xf2,
+	0xa3, 0xb0, 0xfa, 0x3d, 0xb8, 0x33, 0xc6, 0x22, 0x9a, 0xa7, 0x9f, 0x36, 0xe0, 0xb4, 0x38, 0xf9,
+	0x7a, 0x01, 0x65, 0x88, 0xec, 0x8a, 0xea, 0xe3, 0xd2, 0x48, 0xcb, 0x28, 0xdb, 0x18, 0x92, 0xb5,
+	0x49, 0x8c, 0xa9, 0x2c, 0x80, 0x26, 0x74, 0x6d, 0x22, 0x40, 0x9b, 0xc7, 0x2a, 0x77, 0x6d, 0xe8,
+	0xdc, 0xf5, 0x01, 0xb4, 0x86, 0x51, 0xc0, 0x68, 0x07, 0x1f, 0x74, 0x3c, 0xc9, 0x4c, 0x27, 0x46,
+	0x44, 0x56, 0x91, 0xc2, 0xc1, 0x26, 0x9d, 0x73, 0x02, 0x23, 0x65, 0x16, 0x11, 0x51, 0x46, 0xf2,
+	0x98, 0xda, 0x3f, 0xe8, 0x10, 0x14, 0x63, 0x95, 0x49, 0x4d, 0xf7, 0x0f, 0x1c, 0x14, 0x63, 0xfb,
+	0x22, 0xcc, 0xf5, 0x05, 0xb9, 0x30, 0x60, 0x2a, 0xdc, 0xce, 0xf6, 0x0f, 0x54, 0xd4, 0xb8, 0x0c,
+	0x20, 0xea, 0xa8, 0x8e, 0x4b, 0x7a, 0xb4, 0x39, 0xb3, 0xd2, 0xe0, 0x12, 0x08, 0xc8, 0x06, 0xe9,
+	0x51, 0xfb, 0x2c, 0x4c, 0x1d, 0x76, 0x88, 0x1b, 0x8a, 0x7c, 0x74, 0xd2, 0x99, 0x3c, 0x74, 0xdc,
+	0x90, 0x57, 0x54, 0xac, 0x4f, 0xf0, 0xb0, 0xd7, 0x8f, 0x87, 0x4c, 0xf0, 0x27, 0x42, 0xbd, 0x28,
+	0x33, 0x27, 0x1d, 0x3b, 0x1d, 0xdb, 0x43, 0xe4, 0x11, 0x1f, 0xb1, 0x1f, 0xc3, 0x72, 0x1a, 0xf5,
+	0x3a, 0xac, 0x4f, 0x10, 0xed, 0xe3, 0x81, 0x2f, 0x4a, 0xcd, 0xba, 0x2c, 0xf7, 0x6c, 0x3a, 0xf3,
+	0x49, 0x32, 0x51, 0x66, 0x25, 0xa9, 0xa6, 0xdb, 0x2d, 0x68, 0x16, 0xf7, 0x46, 0x6f, 0xdc, 0x6f,
+	0x88, 0xb1, 0x6d, 0x34, 0x40, 0x0c, 0xbd, 0x8f, 0x0f, 0x11, 0x11, 0xcd, 0xc5, 0x71, 0xf6, 0xaf,
+	0x50, 0x5a, 0x8c, 0xac, 0xda, 0x86, 0x15, 0x13, 0x65, 0xbd, 0xfa, 0xbf, 0x5a, 0x19, 0x23, 0x7f,
+	0xa8, 0x9a, 0xae, 0xdb, 0xc1, 0xc1, 0x41, 0x85, 0xf5, 0xbe, 0x0f, 0x8b, 0x11, 0x3a, 0x7a, 0xcc,
+	0xe5, 0x08, 0x0e, 0x02, 0x91, 0x19, 0x99, 0x63, 0x4a, 0x42, 0x93, 0xfb, 0xb8, 0x93, 0x9f, 0x67,
+	0xff, 0x1a, 0xcc, 0x10, 0x14, 0xe2, 0x43, 0xe4, 0x57, 0x86, 0xa5, 0x1c, 0x89, 0x64, 0x46, 0x79,
+	0x2a, 0x32, 0x22, 0x86, 0x16, 0xf4, 0x6f, 0x65, 0xd5, 0xba, 0xc5, 0xf1, 0x91, 0xc8, 0xb9, 0xdd,
+	0xc1, 0x47, 0x71, 0x8f, 0xb8, 0x3e, 0xaa, 0x51, 0xf3, 0x39, 0x98, 0xce, 0x84, 0xd9, 0x49, 0x47,
+	0x7d, 0xf1, 0xe4, 0x34, 0xd3, 0xb5, 0x4b, 0x92, 0xd3, 0x6c, 0x23, 0x6f, 0x15, 0x4e, 0xb9, 0x71,
+	0xb0, 0x19, 0x44, 0x2e, 0x0f, 0x7e, 0xdf, 0xa5, 0x38, 0x52, 0x45, 0x46, 0x11, 0x3c, 0xb2, 0x75,
+	0xd7, 0x44, 0xfd, 0x53, 0xc6, 0xac, 0x16, 0xe8, 0xdf, 0x26, 0x44, 0x6e, 0xb5, 0x29, 0xfa, 0xdf,
+	0xef, 0x3e, 0xf3, 0xfa, 0x6e, 0xd4, 0x13, 0xa2, 0xa4, 0xf9, 0xb2, 0x12, 0x45, 0x03, 0x38, 0xcb,
+	0xb2, 0xa1, 0xb0, 0xd5, 0x77, 0x83, 0x28, 0xc9, 0xb8, 0x33, 0x20, 0xce, 0xb2, 0x87, 0x23, 0x46,
+	0x5c, 0x8f, 0xa9, 0x86, 0xb2, 0x12, 0xac, 0x08, 0xe6, 0x75, 0x23, 0x3e, 0x8a, 0x10, 0x49, 0xd0,
+	0xa4, 0x64, 0x39, 0x98, 0x58, 0x8f, 0x7f, 0xef, 0x89, 0x9a, 0x4a, 0x39, 0x7e, 0x16, 0x94, 0x49,
+	0x7f, 0x55, 0xa6, 0xa5, 0xd2, 0xdf, 0x15, 0x98, 0x17, 0x27, 0xdc, 0xa3, 0x61, 0xd8, 0x45, 0x24,
+	0xe9, 0xb4, 0x66, 0x40, 0xb2, 0x6e, 0xf5, 0x50, 0x10, 0xcb, 0x62, 0x5d, 0xf5, 0x9b, 0x72, 0xb0,
+	0x0c, 0x0e, 0x75, 0x30, 0x66, 0xaa, 0xd9, 0x9a, 0x83, 0x29, 0xd5, 0x6b, 0x1d, 0xb5, 0xef, 0x88,
+	0xbc, 0x2d, 0xaf, 0x56, 0x9d, 0xad, 0x4b, 0x97, 0xb3, 0x12, 0x97, 0x6b, 0x3f, 0x15, 0x66, 0xb7,
+	0xe1, 0x67, 0xab, 0x38, 0xfa, 0x04, 0x6f, 0x0c, 0x06, 0xf8, 0xe8, 0x43, 0x9e, 0x4a, 0x56, 0x9b,
+	0x16, 0x1f, 0x95, 0xaa, 0x52, 0xa9, 0x39, 0x1f, 0x4d, 0x00, 0x23, 0x46, 0x71, 0x13, 0x6e, 0x54,
+	0x2e, 0xa6, 0x4d, 0x23, 0x86, 0xb6, 0x08, 0x37, 0xdc, 0x51, 0xb2, 0xb8, 0xef, 0x11, 0x1c, 0xbe,
+	0x1c, 0xd6, 0xee, 0xc2, 0xed, 0xfa, 0x15, 0x35, 0x7f, 0x3f, 0xb2, 0x44, 0xcb, 0x2a, 0x89, 0x87,
+	0x52, 0xd7, 0x1b, 0x09, 0xf1, 0x7a, 0xc6, 0x3c, 0x6e, 0xaa, 0x8f, 0xdc, 0x30, 0xe9, 0x51, 0xa5,
+	0x80, 0x3c, 0xdb, 0x8d, 0x3a, 0xb6, 0xaf, 0x2b, 0x45, 0x95, 0xf2, 0xa1, 0xd9, 0xfd, 0x6f, 0x2b,
+	0x17, 0xbe, 0xc5, 0x79, 0xb6, 0x8b, 0x98, 0xeb, 0xbb, 0xcc, 0xad, 0x61, 0x96, 0x07, 0x51, 0xce,
+	0xdb, 0x4e, 0x12, 0xa7, 0x93, 0xcf, 0x13, 0x38, 0x9a, 0x0d, 0x93, 0x11, 0x97, 0x55, 0x3a, 0x98,
+	0xf8, 0x2d, 0x3a, 0x53, 0xc7, 0x61, 0x17, 0x0f, 0x92, 0xc3, 0x54, 0x7e, 0xd9, 0x2d, 0x98, 0x55,
+	0x2d, 0x1a, 0x2a, 0x1c, 0x6a, 0xd1, 0xd1, 0xdf, 0x9c, 0x53, 0x7e, 0x08, 0x1c, 0x91, 0x80, 0x21,
+	0xd5, 0xe5, 0x49, 0x01, 0x86, 0xc3, 0xa3, 0x54, 0x66, 0xad, 0x98, 0x3f, 0x95, 0x6d, 0x9a, 0x8d,
+	0x38, 0x26, 0xf8, 0x10, 0x49, 0xf5, 0x09, 0xcc, 0xf7, 0x30, 0x79, 0x42, 0x5c, 0x3f, 0x88, 0x7a,
+	0x2f, 0x5f, 0x3f, 0x23, 0x9c, 0xcb, 0x3e, 0x4b, 0x15, 0x53, 0x5a, 0x80, 0xbf, 0xcc, 0xef, 0xec,
+	0x87, 0xc1, 0xa7, 0xc3, 0xc0, 0x0f, 0xd8, 0xf1, 0x1e, 0xc6, 0x75, 0x87, 0xef, 0x79, 0x98, 0xf1,
+	0x54, 0x8d, 0xa8, 0x0a, 0x74, 0x4f, 0xd4, 0x88, 0x3c, 0xb7, 0x1b, 0xb8, 0x5d, 0x94, 0x74, 0x99,
+	0xe4, 0x87, 0x6c, 0xc3, 0x52, 0xe6, 0x46, 0x2c, 0x70, 0x19, 0xea, 0x84, 0xb4, 0xa7, 0xf6, 0x73,
+	0x29, 0x03, 0xde, 0xa5, 0xbd, 0x9a, 0x7d, 0xc8, 0x71, 0xa8, 0xc5, 0xf8, 0xaf, 0xc4, 0x9f, 0x44,
+	0xeb, 0x5a, 0x8a, 0xfc, 0x49, 0xc0, 0xfa, 0x3e, 0x71, 0x8f, 0x2a, 0xf3, 0xd0, 0x6b, 0xb0, 0x30,
+	0xa4, 0x88, 0x74, 0xf2, 0xed, 0xb2, 0x79, 0x0e, 0x4b, 0xac, 0x2f, 0x0d, 0xd0, 0x8d, 0x5c, 0x80,
+	0x5e, 0x83, 0xb3, 0x3e, 0xa2, 0x2c, 0x88, 0x64, 0xd2, 0xe4, 0xe6, 0x4e, 0x01, 0x3b, 0x33, 0x94,
+	0x10, 0xfa, 0x0e, 0xb4, 0xb2, 0x13, 0xe4, 0xbd, 0xad, 0x9e, 0x27, 0xcd, 0xb8, 0x99, 0xc1, 0xc8,
+	0x79, 0x63, 0xe1, 0xb4, 0xff, 0x89, 0xa5, 0x1c, 0xb7, 0x54, 0x60, 0x1d, 0xad, 0x2f, 0x03, 0x24,
+	0xb7, 0x0d, 0x3a, 0x6a, 0xcf, 0x29, 0xc8, 0x8e, 0x5f, 0x5f, 0x2c, 0x5c, 0x87, 0xa5, 0xee, 0x80,
+	0x76, 0x32, 0x34, 0x54, 0x8b, 0xba, 0x3b, 0xa0, 0x4e, 0x42, 0xa6, 0xfd, 0x0b, 0x0b, 0x96, 0x8b,
+	0xcc, 0xec, 0x06, 0x95, 0x1d, 0xca, 0x54, 0xa9, 0x13, 0xe3, 0x28, 0xb5, 0x61, 0x54, 0xea, 0x05,
+	0x98, 0x15, 0x0e, 0xc3, 0x79, 0x9b, 0xcc, 0x3b, 0xd0, 0xd7, 0xa9, 0xef, 0xdf, 0xb3, 0xe0, 0x52,
+	0x99, 0x88, 0xff, 0xc7, 0x9a, 0x76, 0x85, 0xb7, 0x6e, 0xf1, 0x2c, 0x76, 0x20, 0x99, 0x78, 0x1c,
+	0x23, 0x52, 0xd7, 0x81, 0xcf, 0xf3, 0x36, 0x51, 0xe0, 0xad, 0x20, 0xa9, 0x74, 0xb7, 0xd2, 0x25,
+	0xb4, 0xbb, 0xfd, 0xd3, 0x84, 0xb0, 0xbe, 0x34, 0xa5, 0x2e, 0xe7, 0xe8, 0x45, 0xef, 0xeb, 0xab,
+	0xf9, 0xb5, 0xdf, 0x07, 0x9b, 0x2f, 0x4c, 0x02, 0x1f, 0xa5, 0xcf, 0x06, 0xa4, 0xba, 0x2a, 0xe8,
+	0x9f, 0x49, 0xe6, 0xe8, 0x2e, 0x9d, 0xfd, 0x04, 0x2e, 0x68, 0x42, 0x47, 0xc4, 0x8d, 0x63, 0xe4,
+	0x77, 0x92, 0xd8, 0xaa, 0xee, 0x1b, 0xcc, 0xf4, 0xce, 0x27, 0x53, 0x3f, 0x91, 0x33, 0xb7, 0xd4,
+	0x44, 0xd9, 0xb7, 0x74, 0x79, 0xaa, 0x3b, 0x95, 0xf4, 0x2d, 0xdd, 0xb2, 0x0c, 0x57, 0x66, 0x0c,
+	0x35, 0x3a, 0xd4, 0x2a, 0xff, 0xa1, 0x3c, 0x69, 0x92, 0x30, 0xa8, 0x16, 0x55, 0x17, 0x94, 0x6a,
+	0xe5, 0x17, 0xd5, 0x77, 0x21, 0x92, 0x4f, 0x26, 0x91, 0xdc, 0x70, 0xb0, 0x54, 0xf1, 0xa0, 0xf9,
+	0xfd, 0x17, 0x19, 0x91, 0x77, 0x83, 0x1e, 0x71, 0x19, 0xda, 0x18, 0x0c, 0xb2, 0xd8, 0x2f, 0xfe,
+	0x94, 0xe3, 0x0a, 0xcc, 0x47, 0xe8, 0xa8, 0x93, 0x67, 0x77, 0x2e, 0x42, 0x47, 0x5b, 0xf2, 0xec,
+	0x59, 0x85, 0xd3, 0xa1, 0x5c, 0x92, 0x9f, 0x30, 0x9d, 0xdf, 0xa6, 0xba, 0x2e, 0x59, 0x52, 0xf0,
+	0x5d, 0xda, 0xe3, 0x05, 0x87, 0x38, 0xa5, 0x02, 0x5e, 0x71, 0x4f, 0x8a, 0x2c, 0x41, 0x7e, 0x8c,
+	0x48, 0xbc, 0x29, 0x0c, 0xdd, 0x20, 0x85, 0x76, 0x7e, 0x7e, 0x50, 0x32, 0x86, 0xc2, 0x98, 0x21,
+	0xe9, 0xfb, 0x8b, 0x4e, 0x0a, 0xe0, 0x5b, 0x77, 0x29, 0x3d, 0x8f, 0x77, 0xba, 0xde, 0xd7, 0x95,
+	0x21, 0xb4, 0x60, 0x36, 0xe8, 0x7a, 0xdb, 0x28, 0xc2, 0xa1, 0x12, 0x52, 0x7f, 0x8f, 0x08, 0xf2,
+	0x1a, 0x5c, 0xaf, 0xe2, 0x41, 0xef, 0xdb, 0x73, 0x4b, 0xb4, 0xe8, 0x92, 0x3d, 0x4e, 0x30, 0xbf,
+	0x72, 0xb6, 0x57, 0xc1, 0xeb, 0xff, 0x53, 0x7e, 0x27, 0x7b, 0x6f, 0x26, 0x41, 0xb5, 0x42, 0x58,
+	0xa6, 0x6a, 0xde, 0x56, 0xcf, 0xa4, 0xde, 0x15, 0xaf, 0xa4, 0xc6, 0x3e, 0xde, 0xd2, 0x3b, 0x8d,
+	0x0b, 0x30, 0x2b, 0xbb, 0x39, 0x69, 0x7b, 0x5e, 0x7c, 0x8f, 0x44, 0xe1, 0xb7, 0x33, 0xe5, 0x6f,
+	0x7e, 0x55, 0x6d, 0x74, 0x17, 0x61, 0x4e, 0xbe, 0xd6, 0x4a, 0x0e, 0x9c, 0x49, 0x67, 0x56, 0x02,
+	0x76, 0xfc, 0xf6, 0x5f, 0x37, 0xe4, 0x15, 0x35, 0x62, 0x6c, 0x50, 0xc2, 0x36, 0x15, 0x70, 0xcd,
+	0xb6, 0xfa, 0xcc, 0x93, 0x9c, 0xc8, 0x93, 0xb4, 0xb7, 0xe1, 0x2a, 0x65, 0xdc, 0xb1, 0x44, 0x47,
+	0xd9, 0x8d, 0x7c, 0xf9, 0x3a, 0xce, 0xc3, 0x83, 0xc2, 0x53, 0x9e, 0x8b, 0x02, 0x8d, 0x97, 0x96,
+	0x1b, 0x91, 0xbf, 0xa7, 0x70, 0x32, 0x4f, 0x7b, 0x52, 0x2a, 0x42, 0x07, 0x0b, 0xce, 0x9c, 0x9e,
+	0xc0, 0xbd, 0x52, 0xf6, 0xaa, 0x64, 0x2f, 0x4d, 0x7e, 0x70, 0xbe, 0x08, 0x3f, 0x0d, 0xf4, 0xe5,
+	0xee, 0x82, 0x33, 0xcb, 0x01, 0xa2, 0x85, 0xfd, 0x18, 0xa0, 0x8f, 0x29, 0xeb, 0x70, 0x22, 0xdc,
+	0x26, 0x1a, 0xab, 0xf3, 0xeb, 0xaf, 0x1b, 0x3a, 0x56, 0x52, 0x0f, 0x52, 0x2b, 0x21, 0x8a, 0xd8,
+	0x43, 0x4c, 0xd9, 0x3e, 0x9f, 0xe7, 0xcc, 0xf5, 0x93, 0x9f, 0xf6, 0x77, 0x01, 0x74, 0x43, 0x54,
+	0xb6, 0xdc, 0xe6, 0xd7, 0x6f, 0x57, 0x13, 0x1c, 0x60, 0xa6, 0xdf, 0x55, 0x38, 0x99, 0xd9, 0xdc,
+	0xb4, 0x0f, 0x10, 0xa2, 0x49, 0x7b, 0x8e, 0xff, 0x56, 0x3b, 0xad, 0x74, 0xae, 0x1a, 0x1d, 0x65,
+	0x1b, 0xa5, 0x4d, 0xb0, 0x97, 0xdc, 0x32, 0x25, 0xe3, 0x2a, 0x21, 0xa0, 0xef, 0x46, 0x6e, 0x77,
+	0x80, 0xfc, 0x7a, 0xa7, 0x44, 0x12, 0x51, 0xec, 0xe9, 0xac, 0x93, 0x7c, 0x1a, 0xea, 0x6b, 0xf3,
+	0x42, 0x9a, 0xa3, 0xbf, 0x93, 0xd7, 0x9d, 0xfb, 0x5e, 0x1f, 0xf9, 0xc3, 0x01, 0xda, 0x4d, 0xdf,
+	0x04, 0x56, 0x38, 0xc5, 0x0a, 0xcc, 0x67, 0x1e, 0x18, 0x24, 0xa9, 0x76, 0x06, 0xc4, 0xb3, 0x71,
+	0xd9, 0xdb, 0x57, 0xed, 0xa6, 0x86, 0xe8, 0xea, 0xcf, 0x0b, 0x98, 0x6a, 0xe4, 0xdf, 0x84, 0x53,
+	0xfe, 0x90, 0xa8, 0x8c, 0x6e, 0x80, 0xbd, 0xa7, 0x54, 0x99, 0xca, 0x52, 0x02, 0x16, 0x6d, 0xff,
+	0x62, 0xfe, 0xf6, 0xbe, 0xb8, 0x15, 0x2d, 0xe1, 0x57, 0xbb, 0xd3, 0x0d, 0x58, 0x22, 0x88, 0x22,
+	0x72, 0x28, 0x69, 0x6b, 0x9f, 0x5a, 0xcc, 0x40, 0x77, 0xfc, 0x36, 0x12, 0xa9, 0xae, 0x3c, 0xab,
+	0xc7, 0x13, 0x7b, 0x94, 0xf0, 0x44, 0x09, 0xe1, 0x02, 0xbf, 0x57, 0xc4, 0x91, 0x31, 0xb2, 0x4c,
+	0xc2, 0xed, 0xfa, 0x4f, 0x6f, 0x43, 0x63, 0x97, 0xf6, 0xec, 0x2e, 0x2c, 0xe4, 0x9e, 0x48, 0x5e,
+	0x2f, 0xbf, 0x95, 0xc8, 0xbf, 0x41, 0x6c, 0xdd, 0x1d, 0x07, 0x4b, 0x6b, 0x26, 0x84, 0xa5, 0xc2,
+	0x2b, 0xc5, 0xd7, 0x4c, 0xf3, 0xf3, 0x78, 0xad, 0xfb, 0xe3, 0xe1, 0x69, 0xb3, 0x6a, 0xfc, 0xc1,
+	0x84, 0x65, 0xc7, 0x70, 0xaa, 0xf8, 0xe2, 0xec, 0xa6, 0x89, 0x4e, 0x01, 0xb1, 0xb5, 0x36, 0x26,
+	0x62, 0x7e, 0xc5, 0xef, 0xc1, 0x72, 0xe9, 0x5b, 0x1e, 0xa3, 0x9a, 0xca, 0xb0, 0x5b, 0x6f, 0x9e,
+	0x04, 0x5b, 0x2b, 0xd7, 0x05, 0xc8, 0xbc, 0xa2, 0x69, 0x9b, 0x68, 0xa4, 0x38, 0xad, 0xdb, 0xf5,
+	0x38, 0x79, 0xf1, 0xfe, 0xc4, 0x82, 0x4b, 0x95, 0x0f, 0x49, 0xea, 0x39, 0x2f, 0x99, 0xd5, 0xfa,
+	0xce, 0x8b, 0xcc, 0xd2, 0x72, 0x7f, 0x1f, 0xce, 0x96, 0x3d, 0xee, 0xb8, 0x63, 0x22, 0x5a, 0x82,
+	0xdc, 0xfa, 0xe6, 0x09, 0x90, 0xf3, 0x2a, 0xf9, 0x3e, 0x9c, 0x2d, 0x7b, 0xaa, 0x61, 0x5c, 0xbd,
+	0x04, 0xd9, 0xbc, 0x7a, 0xc5, 0xdb, 0x0b, 0xb9, 0x7a, 0x17, 0x16, 0x72, 0x2f, 0x2f, 0x8c, 0x4e,
+	0x9b, 0xc5, 0x32, 0x3b, 0x6d, 0xe9, 0xab, 0x0a, 0x06, 0x76, 0xc9, 0x0b, 0x09, 0xa3, 0xed, 0x8c,
+	0xe2, 0xb6, 0xd6, 0xc7, 0xc7, 0xd5, 0xab, 0xf6, 0x61, 0xa9, 0xf0, 0xd4, 0xe1, 0xb5, 0x6a, 0x2b,
+	0x49, 0xf0, 0x2a, 0x42, 0x45, 0xe9, 0xeb, 0x02, 0xfb, 0x07, 0x16, 0x9c, 0x33, 0x3c, 0x2d, 0xa8,
+	0x27, 0x95, 0xc3, 0x6f, 0x7d, 0xfb, 0x64, 0xf8, 0x9a, 0x85, 0x08, 0x4e, 0x8f, 0x5c, 0xf2, 0xaf,
+	0x9a, 0x68, 0x15, 0x31, 0x5b, 0xaf, 0x8f, 0x8b, 0xa9, 0xd7, 0xfb, 0x91, 0x05, 0x4d, 0xe3, 0xd5,
+	0xb9, 0x91, 0x9c, 0x69, 0x46, 0xeb, 0xad, 0x93, 0xce, 0xd0, 0x8c, 0xfc, 0x16, 0x40, 0xe6, 0x2e,
+	0xba, 0x5d, 0xad, 0x3e, 0x8e, 0x63, 0x8e, 0x59, 0xa3, 0x77, 0xcb, 0xf6, 0x5f, 0x58, 0xb0, 0x52,
+	0x7b, 0xb3, 0xfc, 0x56, 0x35, 0x41, 0xf3, 0xcc, 0xd6, 0xaf, 0xbf, 0xe8, 0x4c, 0xcd, 0x20, 0x82,
+	0xc5, 0xfc, 0x25, 0xf3, 0x0d, 0x73, 0x24, 0xc8, 0xa0, 0xb5, 0xee, 0x8d, 0x85, 0xa6, 0x97, 0xf9,
+	0x1d, 0xf8, 0x46, 0xf9, 0x9d, 0xa8, 0x91, 0x4e, 0x29, 0x7a, 0xeb, 0x5b, 0x27, 0x42, 0xcf, 0x05,
+	0x90, 0xd1, 0x3b, 0xd1, 0x9a, 0x8d, 0xcc, 0xe2, 0x56, 0x04, 0x10, 0xe3, 0x25, 0x25, 0x3f, 0x8a,
+	0x4b, 0x2f, 0x28, 0xcd, 0xc1, 0xaf, 0x04, 0xdb, 0x7c, 0x14, 0x57, 0xdd, 0x27, 0xf2, 0xe0, 0x55,
+	0xb8, 0x4b, 0x34, 0x06, 0xaf, 0x3c, 0x9e, 0x39, 0x78, 0x19, 0x2e, 0xd1, 0x7e, 0xd7, 0x82, 0xf3,
+	0xa6, 0xbb, 0x9f, 0xb5, 0x3a, 0x2b, 0x29, 0x4c, 0x68, 0xfd, 0xca, 0x09, 0x27, 0x64, 0x0d, 0xac,
+	0xbc, 0xef, 0x5f, 0x6b, 0xa8, 0x39, 0x74, 0xb3, 0x81, 0x55, 0xf6, 0xec, 0xb3, 0xcb, 0xe7, 0x5b,
+	0x0c, 0xb5, 0xcb, 0xe7, 0xd0, 0xeb, 0x97, 0x2f, 0xad, 0xeb, 0x45, 0x56, 0x54, 0x79, 0x6f, 0x63,
+	0x34, 0xa2, 0xaa, 0x59, 0xe6, 0xac, 0x68, 0x9c, 0xeb, 0x18, 0x65, 0x18, 0xe5, 0x97, 0x18, 0x15,
+	0x86, 0x51, 0x3a, 0xa1, 0xca, 0x30, 0xaa, 0x6f, 0x0d, 0x3e, 0x85, 0x33, 0xa3, 0xbd, 0xfc, 0x5b,
+	0x63, 0x51, 0xe3, 0xa8, 0xad, 0x37, 0xc6, 0x46, 0xcd, 0x1a, 0x43, 0x79, 0x0f, 0xd9, 0x68, 0x0c,
+	0xa5, 0xe8, 0x66, 0x63, 0xa8, 0xec, 0xae, 0xda, 0x7f, 0x6e, 0xc1, 0xd5, 0xba, 0x6e, 0xb6, 0x51,
+	0x9d, 0x35, 0x13, 0x5b, 0xef, 0xbc, 0xe0, 0xc4, 0x9c, 0xa9, 0x56, 0x36, 0x7e, 0xdf, 0xac, 0x73,
+	0x81, 0xb2, 0x59, 0x66, 0x53, 0x1d, 0xa7, 0xc1, 0x2b, 0x4c, 0xd5, 0xd4, 0xdd, 0x35, 0x9a, 0xaa,
+	0x61, 0x82, 0xd9, 0x54, 0xeb, 0x3a, 0xaf, 0x7f, 0x68, 0x41, 0xab, 0xe2, 0xf1, 0x81, 0xf1, 0x08,
+	0x32, 0xcf, 0x69, 0x3d, 0x38, 0xf9, 0x9c, 0x9c, 0x1d, 0xd5, 0xbd, 0x3a, 0xa8, 0x70, 0xcb, 0xca,
+	0x89, 0x66, 0x3b, 0x1a, 0xf3, 0xd5, 0x81, 0xfd, 0x63, 0x0b, 0x2e, 0x98, 0xbb, 0xd0, 0x6f, 0xd4,
+	0x44, 0xae, 0xd1, 0x29, 0xad, 0x5f, 0x3d, 0xf1, 0x94, 0x5c, 0x32, 0x6b, 0x6c, 0x32, 0xbf, 0x5e,
+	0x67, 0x99, 0xc5, 0x19, 0xe6, 0x64, 0xb6, 0xae, 0xbf, 0x9b, 0x66, 0x1c, 0x85, 0x2e, 0x69, 0x4d,
+	0xc6, 0x91, 0xc7, 0xae, 0xcb, 0x38, 0x0c, 0x2d, 0xdc, 0xef, 0xc1, 0x72, 0x69, 0x87, 0xf6, 0x6e,
+	0x45, 0xe9, 0x35, 0x82, 0x5d, 0xd1, 0x78, 0xa8, 0x68, 0x2a, 0x0a, 0xcf, 0xa9, 0x68, 0x29, 0x56,
+	0x55, 0x7f, 0x86, 0x39, 0x66, 0xcf, 0xa9, 0xef, 0x28, 0xda, 0x47, 0x70, 0xb6, 0xac, 0x9b, 0x68,
+	0xac, 0xc8, 0x4b, 0x90, 0xcd, 0x15, 0x79, 0x55, 0xdf, 0xef, 0x53, 0x38, 0x33, 0xda, 0xcd, 0xbb,
+	0x55, 0x7d, 0x8c, 0x64, 0x17, 0x7d, 0x63, 0x6c, 0xd4, 0x6c, 0xe1, 0xb8, 0x8f, 0xd8, 0x1e, 0xde,
+	0xda, 0xd6, 0x7f, 0x20, 0x6d, 0x2e, 0x1c, 0x8b, 0x98, 0xe6, 0xc2, 0xb1, 0x88, 0x99, 0xd5, 0xad,
+	0x83, 0x0e, 0x86, 0x14, 0xe5, 0x97, 0xac, 0xe8, 0x76, 0x8c, 0x20, 0x57, 0x75, 0x3b, 0x46, 0x90,
+	0xb3, 0x82, 0x6e, 0x23, 0x6f, 0xe0, 0x12, 0x3e, 0xbe, 0xc3, 0xf5, 0x50, 0x51, 0x21, 0x17, 0x31,
+	0xcd, 0x82, 0x16, 0x31, 0x93, 0xf5, 0x5a, 0x53, 0x3f, 0x78, 0xfe, 0xd9, 0x6d, 0x6b, 0xf3, 0xf1,
+	0xcf, 0xbe, 0xb8, 0x62, 0x7d, 0xfe, 0xc5, 0x15, 0xeb, 0x17, 0x5f, 0x5c, 0xb1, 0xfe, 0xf8, 0xcb,
+	0x2b, 0xaf, 0x7c, 0xfe, 0xe5, 0x95, 0x57, 0xfe, 0xfd, 0xcb, 0x2b, 0xaf, 0xfc, 0xe6, 0xb7, 0x7a,
+	0x01, 0xeb, 0x0f, 0xbb, 0xf7, 0x3d, 0x1c, 0xae, 0xc5, 0x04, 0xfb, 0x43, 0x8f, 0x51, 0x2f, 0x28,
+	0xfc, 0x41, 0x7a, 0xf6, 0x0f, 0xba, 0xd9, 0x71, 0x8c, 0x68, 0x77, 0x5a, 0xdc, 0x74, 0x7c, 0xf3,
+	0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xcb, 0x60, 0xf1, 0x76, 0x40, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
 var _ context.Context
 var _ grpc.ClientConn
 
@@ -4648,6 +4973,7 @@ type MsgClient interface {
 	InvalidateInference(ctx context.Context, in *MsgInvalidateInference, opts ...grpc.CallOption) (*MsgInvalidateInferenceResponse, error)
 	RevalidateInference(ctx context.Context, in *MsgRevalidateInference, opts ...grpc.CallOption) (*MsgRevalidateInferenceResponse, error)
 	ClaimRewards(ctx context.Context, in *MsgClaimRewards, opts ...grpc.CallOption) (*MsgClaimRewardsResponse, error)
+	SetClaimRecipients(ctx context.Context, in *MsgSetClaimRecipients, opts ...grpc.CallOption) (*MsgSetClaimRecipientsResponse, error)
 	SubmitPocBatch(ctx context.Context, in *MsgSubmitPocBatch, opts ...grpc.CallOption) (*MsgSubmitPocBatchResponse, error)
 	// PoC v2 validation messages
 	SubmitPocValidationsV2(ctx context.Context, in *MsgSubmitPocValidationsV2, opts ...grpc.CallOption) (*MsgSubmitPocValidationsV2Response, error)
@@ -4678,6 +5004,8 @@ type MsgClient interface {
 	CreateDevshardEscrow(ctx context.Context, in *MsgCreateDevshardEscrow, opts ...grpc.CallOption) (*MsgCreateDevshardEscrowResponse, error)
 	SettleDevshardEscrow(ctx context.Context, in *MsgSettleDevshardEscrow, opts ...grpc.CallOption) (*MsgSettleDevshardEscrowResponse, error)
 	SetDevshardRequestsEnabled(ctx context.Context, in *MsgSetDevshardRequestsEnabled, opts ...grpc.CallOption) (*MsgSetDevshardRequestsEnabledResponse, error)
+	ScheduleMaintenance(ctx context.Context, in *MsgScheduleMaintenance, opts ...grpc.CallOption) (*MsgScheduleMaintenanceResponse, error)
+	CancelMaintenance(ctx context.Context, in *MsgCancelMaintenance, opts ...grpc.CallOption) (*MsgCancelMaintenanceResponse, error)
 	SetPoCDelegation(ctx context.Context, in *MsgSetPoCDelegation, opts ...grpc.CallOption) (*MsgSetPoCDelegationResponse, error)
 	RefusePoCDelegation(ctx context.Context, in *MsgRefusePoCDelegation, opts ...grpc.CallOption) (*MsgRefusePoCDelegationResponse, error)
 	DeclarePoCIntent(ctx context.Context, in *MsgDeclarePoCIntent, opts ...grpc.CallOption) (*MsgDeclarePoCIntentResponse, error)
@@ -4700,6 +5028,7 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) StartInference(ctx context.Context, in *MsgStartInference, opts ...grpc.CallOption) (*MsgStartInferenceResponse, error) {
 	out := new(MsgStartInferenceResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/StartInference", in, out, opts...)
@@ -4709,6 +5038,7 @@ func (c *msgClient) StartInference(ctx context.Context, in *MsgStartInference, o
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) FinishInference(ctx context.Context, in *MsgFinishInference, opts ...grpc.CallOption) (*MsgFinishInferenceResponse, error) {
 	out := new(MsgFinishInferenceResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/FinishInference", in, out, opts...)
@@ -4727,6 +5057,7 @@ func (c *msgClient) SubmitNewParticipant(ctx context.Context, in *MsgSubmitNewPa
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) Validation(ctx context.Context, in *MsgValidation, opts ...grpc.CallOption) (*MsgValidationResponse, error) {
 	out := new(MsgValidationResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/Validation", in, out, opts...)
@@ -4745,6 +5076,7 @@ func (c *msgClient) SubmitNewUnfundedParticipant(ctx context.Context, in *MsgSub
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) InvalidateInference(ctx context.Context, in *MsgInvalidateInference, opts ...grpc.CallOption) (*MsgInvalidateInferenceResponse, error) {
 	out := new(MsgInvalidateInferenceResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/InvalidateInference", in, out, opts...)
@@ -4754,6 +5086,7 @@ func (c *msgClient) InvalidateInference(ctx context.Context, in *MsgInvalidateIn
 	return out, nil
 }
 
+// Deprecated: Do not use.
 func (c *msgClient) RevalidateInference(ctx context.Context, in *MsgRevalidateInference, opts ...grpc.CallOption) (*MsgRevalidateInferenceResponse, error) {
 	out := new(MsgRevalidateInferenceResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/RevalidateInference", in, out, opts...)
@@ -4772,6 +5105,15 @@ func (c *msgClient) ClaimRewards(ctx context.Context, in *MsgClaimRewards, opts
 	return out, nil
 }
 
+func (c *msgClient) SetClaimRecipients(ctx context.Context, in *MsgSetClaimRecipients, opts ...grpc.CallOption) (*MsgSetClaimRecipientsResponse, error) {
+	out := new(MsgSetClaimRecipientsResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Msg/SetClaimRecipients", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) SubmitPocBatch(ctx context.Context, in *MsgSubmitPocBatch, opts ...grpc.CallOption) (*MsgSubmitPocBatchResponse, error) {
 	out := new(MsgSubmitPocBatchResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/SubmitPocBatch", in, out, opts...)
@@ -5024,6 +5366,24 @@ func (c *msgClient) SetDevshardRequestsEnabled(ctx context.Context, in *MsgSetDe
 	return out, nil
 }
 
+func (c *msgClient) ScheduleMaintenance(ctx context.Context, in *MsgScheduleMaintenance, opts ...grpc.CallOption) (*MsgScheduleMaintenanceResponse, error) {
+	out := new(MsgScheduleMaintenanceResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Msg/ScheduleMaintenance", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *msgClient) CancelMaintenance(ctx context.Context, in *MsgCancelMaintenance, opts ...grpc.CallOption) (*MsgCancelMaintenanceResponse, error) {
+	out := new(MsgCancelMaintenanceResponse)
+	err := c.cc.Invoke(ctx, "/inference.inference.Msg/CancelMaintenance", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) SetPoCDelegation(ctx context.Context, in *MsgSetPoCDelegation, opts ...grpc.CallOption) (*MsgSetPoCDelegationResponse, error) {
 	out := new(MsgSetPoCDelegationResponse)
 	err := c.cc.Invoke(ctx, "/inference.inference.Msg/SetPoCDelegation", in, out, opts...)
@@ -5064,6 +5424,7 @@ type MsgServer interface {
 	InvalidateInference(context.Context, *MsgInvalidateInference) (*MsgInvalidateInferenceResponse, error)
 	RevalidateInference(context.Context, *MsgRevalidateInference) (*MsgRevalidateInferenceResponse, error)
 	ClaimRewards(context.Context, *MsgClaimRewards) (*MsgClaimRewardsResponse, error)
+	SetClaimRecipients(context.Context, *MsgSetClaimRecipients) (*MsgSetClaimRecipientsResponse, error)
 	SubmitPocBatch(context.Context, *MsgSubmitPocBatch) (*MsgSubmitPocBatchResponse, error)
 	// PoC v2 validation messages
 	SubmitPocValidationsV2(context.Context, *MsgSubmitPocValidationsV2) (*MsgSubmitPocValidationsV2Response, error)
@@ -5094,6 +5455,8 @@ type MsgServer interface {
 	CreateDevshardEscrow(context.Context, *MsgCreateDevshardEscrow) (*MsgCreateDevshardEscrowResponse, error)
 	SettleDevshardEscrow(context.Context, *MsgSettleDevshardEscrow) (*MsgSettleDevshardEscrowResponse, error)
 	SetDevshardRequestsEnabled(context.Context, *MsgSetDevshardRequestsEnabled) (*MsgSetDevshardRequestsEnabledResponse, error)
+	ScheduleMaintenance(context.Context, *MsgScheduleMaintenance) (*MsgScheduleMaintenanceResponse, error)
+	CancelMaintenance(context.Context, *MsgCancelMaintenance) (*MsgCancelMaintenanceResponse, error)
 	SetPoCDelegation(context.Context, *MsgSetPoCDelegation) (*MsgSetPoCDelegationResponse, error)
 	RefusePoCDelegation(context.Context, *MsgRefusePoCDelegation) (*MsgRefusePoCDelegationResponse, error)
 	DeclarePoCIntent(context.Context, *MsgDeclarePoCIntent) (*MsgDeclarePoCIntentResponse, error)
@@ -5130,6 +5493,9 @@ func (*UnimplementedMsgServer) RevalidateInference(ctx context.Context, req *Msg
 func (*UnimplementedMsgServer) ClaimRewards(ctx context.Context, req *MsgClaimRewards) (*MsgClaimRewardsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ClaimRewards not implemented")
 }
+func (*UnimplementedMsgServer) SetClaimRecipients(ctx context.Context, req *MsgSetClaimRecipients) (*MsgSetClaimRecipientsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SetClaimRecipients not implemented")
+}
 func (*UnimplementedMsgServer) SubmitPocBatch(ctx context.Context, req *MsgSubmitPocBatch) (*MsgSubmitPocBatchResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SubmitPocBatch not implemented")
 }
@@ -5214,6 +5580,12 @@ func (*UnimplementedMsgServer) SettleDevshardEscrow(ctx context.Context, req *Ms
 func (*UnimplementedMsgServer) SetDevshardRequestsEnabled(ctx context.Context, req *MsgSetDevshardRequestsEnabled) (*MsgSetDevshardRequestsEnabledResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SetDevshardRequestsEnabled not implemented")
 }
+func (*UnimplementedMsgServer) ScheduleMaintenance(ctx context.Context, req *MsgScheduleMaintenance) (*MsgScheduleMaintenanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ScheduleMaintenance not implemented")
+}
+func (*UnimplementedMsgServer) CancelMaintenance(ctx context.Context, req *MsgCancelMaintenance) (*MsgCancelMaintenanceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CancelMaintenance not implemented")
+}
 func (*UnimplementedMsgServer) SetPoCDelegation(ctx context.Context, req *MsgSetPoCDelegation) (*MsgSetPoCDelegationResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SetPoCDelegation not implemented")
 }
@@ -5390,6 +5762,24 @@ func _Msg_ClaimRewards_Handler(srv interface{}, ctx context.Context, dec func(in
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_SetClaimRecipients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgSetClaimRecipients)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).SetClaimRecipients(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Msg/SetClaimRecipients",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).SetClaimRecipients(ctx, req.(*MsgSetClaimRecipients))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_SubmitPocBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgSubmitPocBatch)
 	if err := dec(in); err != nil {
@@ -5894,49 +6284,85 @@ func _Msg_SetDevshardRequestsEnabled_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_SetPoCDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgSetPoCDelegation)
+func _Msg_ScheduleMaintenance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgScheduleMaintenance)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).SetPoCDelegation(ctx, in)
+		return srv.(MsgServer).ScheduleMaintenance(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/inference.inference.Msg/SetPoCDelegation",
+		FullMethod: "/inference.inference.Msg/ScheduleMaintenance",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).SetPoCDelegation(ctx, req.(*MsgSetPoCDelegation))
+		return srv.(MsgServer).ScheduleMaintenance(ctx, req.(*MsgScheduleMaintenance))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_RefusePoCDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgRefusePoCDelegation)
+func _Msg_CancelMaintenance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgCancelMaintenance)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).RefusePoCDelegation(ctx, in)
+		return srv.(MsgServer).CancelMaintenance(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/inference.inference.Msg/RefusePoCDelegation",
+		FullMethod: "/inference.inference.Msg/CancelMaintenance",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).RefusePoCDelegation(ctx, req.(*MsgRefusePoCDelegation))
+		return srv.(MsgServer).CancelMaintenance(ctx, req.(*MsgCancelMaintenance))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_DeclarePoCIntent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgDeclarePoCIntent)
+func _Msg_SetPoCDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgSetPoCDelegation)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).DeclarePoCIntent(ctx, in)
+		return srv.(MsgServer).SetPoCDelegation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Msg/SetPoCDelegation",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).SetPoCDelegation(ctx, req.(*MsgSetPoCDelegation))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_RefusePoCDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgRefusePoCDelegation)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).RefusePoCDelegation(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/inference.inference.Msg/RefusePoCDelegation",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).RefusePoCDelegation(ctx, req.(*MsgRefusePoCDelegation))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_DeclarePoCIntent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgDeclarePoCIntent)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).DeclarePoCIntent(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
@@ -5989,6 +6415,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "ClaimRewards",
 			Handler:    _Msg_ClaimRewards_Handler,
 		},
+		{
+			MethodName: "SetClaimRecipients",
+			Handler:    _Msg_SetClaimRecipients_Handler,
+		},
 		{
 			MethodName: "SubmitPocBatch",
 			Handler:    _Msg_SubmitPocBatch_Handler,
@@ -6101,6 +6531,14 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "SetDevshardRequestsEnabled",
 			Handler:    _Msg_SetDevshardRequestsEnabled_Handler,
 		},
+		{
+			MethodName: "ScheduleMaintenance",
+			Handler:    _Msg_ScheduleMaintenance_Handler,
+		},
+		{
+			MethodName: "CancelMaintenance",
+			Handler:    _Msg_CancelMaintenance_Handler,
+		},
 		{
 			MethodName: "SetPoCDelegation",
 			Handler:    _Msg_SetPoCDelegation_Handler,
@@ -6997,6 +7435,73 @@ func (m *MsgClaimRewardsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgSetClaimRecipients) 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 *MsgSetClaimRecipients) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgSetClaimRecipients) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Entries) > 0 {
+		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTx(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if len(m.Creator) > 0 {
+		i -= len(m.Creator)
+		copy(dAtA[i:], m.Creator)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgSetClaimRecipientsResponse) 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 *MsgSetClaimRecipientsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgSetClaimRecipientsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func (m *MsgSubmitPocBatch) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -9226,6 +9731,139 @@ func (m *MsgSetDevshardRequestsEnabledResponse) MarshalToSizedBuffer(dAtA []byte
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgScheduleMaintenance) 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 *MsgScheduleMaintenance) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgScheduleMaintenance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.DurationBlocks != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.DurationBlocks))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.StartHeight != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.StartHeight))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Participant) > 0 {
+		i -= len(m.Participant)
+		copy(dAtA[i:], m.Participant)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Participant)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Creator) > 0 {
+		i -= len(m.Creator)
+		copy(dAtA[i:], m.Creator)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgScheduleMaintenanceResponse) 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 *MsgScheduleMaintenanceResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgScheduleMaintenanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.ReservationId != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.ReservationId))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgCancelMaintenance) 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 *MsgCancelMaintenance) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgCancelMaintenance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.ReservationId != 0 {
+		i = encodeVarintTx(dAtA, i, uint64(m.ReservationId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Creator) > 0 {
+		i -= len(m.Creator)
+		copy(dAtA[i:], m.Creator)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgCancelMaintenanceResponse) 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 *MsgCancelMaintenanceResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgCancelMaintenanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTx(v)
 	base := offset
@@ -9654,6 +10292,34 @@ func (m *MsgClaimRewardsResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgSetClaimRecipients) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Creator)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if len(m.Entries) > 0 {
+		for _, e := range m.Entries {
+			l = e.Size()
+			n += 1 + l + sovTx(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MsgSetClaimRecipientsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func (m *MsgSubmitPocBatch) Size() (n int) {
 	if m == nil {
 		return 0
@@ -10669,10 +11335,70 @@ func (m *MsgSetDevshardRequestsEnabledResponse) Size() (n int) {
 	return n
 }
 
-func sovTx(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
+func (m *MsgScheduleMaintenance) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Creator)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.Participant)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.StartHeight != 0 {
+		n += 1 + sovTx(uint64(m.StartHeight))
+	}
+	if m.DurationBlocks != 0 {
+		n += 1 + sovTx(uint64(m.DurationBlocks))
+	}
+	return n
 }
-func sozTx(x uint64) (n int) {
+
+func (m *MsgScheduleMaintenanceResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ReservationId != 0 {
+		n += 1 + sovTx(uint64(m.ReservationId))
+	}
+	return n
+}
+
+func (m *MsgCancelMaintenance) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Creator)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.ReservationId != 0 {
+		n += 1 + sovTx(uint64(m.ReservationId))
+	}
+	return n
+}
+
+func (m *MsgCancelMaintenanceResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func sovTx(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTx(x uint64) (n int) {
 	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
 func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error {
@@ -13574,6 +14300,172 @@ func (m *MsgClaimRewardsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgSetClaimRecipients) 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 ErrIntOverflowTx
+			}
+			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: MsgSetClaimRecipients: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgSetClaimRecipients: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				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 ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Creator = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Entries = append(m.Entries, ClaimRecipientEntry{})
+			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgSetClaimRecipientsResponse) 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 ErrIntOverflowTx
+			}
+			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: MsgSetClaimRecipientsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgSetClaimRecipientsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *MsgSubmitPocBatch) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -20214,6 +21106,378 @@ func (m *MsgSetDevshardRequestsEnabledResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgScheduleMaintenance) 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 ErrIntOverflowTx
+			}
+			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: MsgScheduleMaintenance: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgScheduleMaintenance: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				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 ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Creator = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Participant", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				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 ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Participant = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
+			}
+			m.StartHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DurationBlocks", wireType)
+			}
+			m.DurationBlocks = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DurationBlocks |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgScheduleMaintenanceResponse) 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 ErrIntOverflowTx
+			}
+			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: MsgScheduleMaintenanceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgScheduleMaintenanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+			}
+			m.ReservationId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ReservationId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgCancelMaintenance) 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 ErrIntOverflowTx
+			}
+			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: MsgCancelMaintenance: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgCancelMaintenance: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				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 ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Creator = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReservationId", wireType)
+			}
+			m.ReservationId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ReservationId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgCancelMaintenanceResponse) 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 ErrIntOverflowTx
+			}
+			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: MsgCancelMaintenanceResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgCancelMaintenanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTx(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/local-test-net/Dockerfile.testapp-server b/local-test-net/Dockerfile.testapp-server
index 3d72e44e06..51b99897d0 100644
--- a/local-test-net/Dockerfile.testapp-server
+++ b/local-test-net/Dockerfile.testapp-server
@@ -1,4 +1,4 @@
-FROM golang:1.24.2-alpine3.20 AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 RUN apk add --no-cache zip
 
 WORKDIR /build
@@ -11,7 +11,7 @@ RUN mkdir -p /srv/files && \
     zip -j /srv/files/testapp.zip testapp && \
     sha256sum /srv/files/testapp.zip | cut -d' ' -f1 > /srv/files/testapp.zip.sha256
 
-FROM python:3.12-alpine
+FROM python:3.12-alpine3.21
 COPY --from=builder /srv/files /srv/files
 
 WORKDIR /srv/files
diff --git a/local-test-net/launch.sh b/local-test-net/launch.sh
index fb2c6e90ee..c3750b2ab5 100755
--- a/local-test-net/launch.sh
+++ b/local-test-net/launch.sh
@@ -37,7 +37,7 @@ sleep 40
 # seed node parameters for both joining nodes
 export SEED_API_URL="http://genesis-api:9000"
 export SEED_NODE_RPC_URL="http://genesis-node:26657"
-export SEED_NODE_P2P_URL="http://genesis-node:26656"
+export SEED_NODE_P2P_URL="tcp://genesis-node:26656"
 export IS_GENESIS=false
 
 # join node 'join1'
@@ -55,7 +55,7 @@ export P2P_PORT=8201
 export PROXY_PORT=$PUBLIC_SERVER_PORT
 export PUBLIC_URL="http://${KEY_NAME}-proxy"
 export POC_CALLBACK_URL="http://${KEY_NAME}-api:9100"
-export P2P_EXTERNAL_ADDRESS="http://${KEY_NAME}-node:26656"
+export P2P_EXTERNAL_ADDRESS="${KEY_NAME}-node:26656"
 ./launch_add_network_node.sh
 
 # join node 'join2'
@@ -72,5 +72,5 @@ export P2P_PORT=8202
 export PROXY_PORT=$PUBLIC_SERVER_PORT
 export PUBLIC_URL="http://${KEY_NAME}-proxy"
 export POC_CALLBACK_URL="http://${KEY_NAME}-api:9100"
-export P2P_EXTERNAL_ADDRESS="http://${KEY_NAME}-node:26656"
+export P2P_EXTERNAL_ADDRESS="${KEY_NAME}-node:26656"
 ./launch_add_network_node.sh
diff --git a/local-test-net/launch_full.sh b/local-test-net/launch_full.sh
index 97b06bce7d..76d1c5f0fa 100755
--- a/local-test-net/launch_full.sh
+++ b/local-test-net/launch_full.sh
@@ -46,7 +46,7 @@ sleep 40
 # seed node parameters for both joining nodes
 export SEED_API_URL="http://genesis-api:9000"
 export SEED_NODE_RPC_URL="http://genesis-node:26657"
-export SEED_NODE_P2P_URL="http://genesis-node:26656"
+export SEED_NODE_P2P_URL="tcp://genesis-node:26656"
 export IS_GENESIS=false
 
 # join node 'join1' with proxy
@@ -64,7 +64,7 @@ export PROXY_PORT=81
 export API_SSL_PORT=444
 export PUBLIC_URL="http://${KEY_NAME}-api:8080"
 export POC_CALLBACK_URL="http://${KEY_NAME}-api:9100"
-export P2P_EXTERNAL_ADDRESS="http://${KEY_NAME}-node:26656"
+export P2P_EXTERNAL_ADDRESS="${KEY_NAME}-node:26656"
 export PROXY_ACTIVE=true
 export BRIDGE_ACTIVE=true
 # Unique internal bridge ports for join1
@@ -92,7 +92,7 @@ export PROXY_PORT=82
 export API_SSL_PORT=445
 export PUBLIC_URL="http://${KEY_NAME}-api:8080"
 export POC_CALLBACK_URL="http://${KEY_NAME}-api:9100"
-export P2P_EXTERNAL_ADDRESS="http://${KEY_NAME}-node:26656"
+export P2P_EXTERNAL_ADDRESS="${KEY_NAME}-node:26656"
 export PROXY_ACTIVE=true
 export BRIDGE_ACTIVE=true
 # Unique internal bridge ports for join2
@@ -104,4 +104,4 @@ export PRYSM_P2P_TCP_PORT=13020
 export PRYSM_P2P_UDP_PORT=12020
 # Don't set DASHBOARD_PORT for join nodes - they don't have explorer
 unset DASHBOARD_PORT
-./launch_add_network_node.sh 
\ No newline at end of file
+./launch_add_network_node.sh
diff --git a/local-test-net/stop.sh b/local-test-net/stop.sh
index 415ae5de91..108bad8bf5 100755
--- a/local-test-net/stop.sh
+++ b/local-test-net/stop.sh
@@ -1,5 +1,24 @@
-docker compose -p genesis down -v
-docker compose -p join1 down -v
-docker compose -p join2 down -v
-docker compose -p join3 down -v
-docker compose -p join4 down -v
+#!/usr/bin/env bash
+set -euo pipefail
+
+compose_down() {
+  local project="$1"
+  shift
+
+  docker compose -p "${project}" "$@" down -v
+}
+
+compose_down genesis \
+  -f docker-compose-base.yml \
+  -f docker-compose.genesis.yml \
+  -f docker-compose.dns.yml \
+  -f docker-compose.dns-overrides.yml \
+  -f docker-compose.postgres.yml
+
+for project in join1 join2 join3 join4; do
+  compose_down "${project}" \
+    -f docker-compose-base.yml \
+    -f docker-compose.join.yml \
+    -f docker-compose.dns.yml \
+    -f docker-compose.dns-overrides.yml
+done
diff --git a/mlnode/packages/api/Dockerfile b/mlnode/packages/api/Dockerfile
index fd41fa43d8..7f072bcde8 100644
--- a/mlnode/packages/api/Dockerfile
+++ b/mlnode/packages/api/Dockerfile
@@ -1,6 +1,6 @@
 # syntax=docker/dockerfile:1.4
 ################################################################################
-FROM ghcr.io/gonka-ai/vllm:v0.15.1 AS base
+FROM ghcr.io/gonka-ai/vllm:v0.20.0-cu129-post2 AS base
 
 RUN --mount=type=cache,target=/var/lib/apt/lists \
     --mount=type=cache,target=/root/.cache/pip \
diff --git a/mlnode/packages/api/src/api/routes.py b/mlnode/packages/api/src/api/routes.py
index 0d41c167ba..b0dda004ec 100644
--- a/mlnode/packages/api/src/api/routes.py
+++ b/mlnode/packages/api/src/api/routes.py
@@ -27,12 +27,55 @@
 )
 
 
-class StateResponse(BaseModel):
-    state: ServiceState
+class VersionedResponse(BaseModel):
     version: str = _MLNODE_VERSION
+
+
+class StateResponse(VersionedResponse):
+    state: ServiceState
     poc_status: Optional[str] = None          # "IDLE" | "GENERATING" | "VALIDATING" | "MIXED" | "NO_BACKENDS"
     inference_healthy: Optional[bool] = None  # True when ≥1 vLLM backend is up
     loaded_model: Optional[str] = None        # Model the current vLLM process was started with
+    poc_validation_inference: bool = False
+
+
+class VersionsResponse(VersionedResponse):
+    vllm_version: Optional[str] = None
+    poc_validation_inference: bool = False
+
+
+_vllm_versions_cache: Optional[VersionsResponse] = None
+
+
+async def _query_vllm_versions(backends: Optional[list[int]] = None) -> VersionsResponse:
+    global _vllm_versions_cache
+
+    if _vllm_versions_cache is not None:
+        return _vllm_versions_cache
+
+    backend_ports = backends if backends is not None else proxy_module.get_healthy_backends()
+    if not backend_ports:
+        return VersionsResponse()
+
+    try:
+        response = await proxy_module.call_backend(backend_ports[0], "GET", "/api/v1/pow/versions")
+        if response.status_code >= 400:
+            logger.debug("vLLM /api/v1/pow/versions returned status %s", response.status_code)
+            return VersionsResponse()
+        data = response.json()
+        if not isinstance(data, dict):
+            logger.debug("vLLM /api/v1/pow/versions returned non-object response")
+            return VersionsResponse()
+    except Exception as exc:
+        logger.debug("failed to query vLLM versions endpoint: %s", exc)
+        return VersionsResponse()
+
+    vllm_version = data.get("vllm_version")
+    _vllm_versions_cache = VersionsResponse(
+        vllm_version=vllm_version if isinstance(vllm_version, str) else None,
+        poc_validation_inference=data.get("poc_validation_inference") is True,
+    )
+    return _vllm_versions_cache
 
 
 @router.get("/state")
@@ -64,14 +107,22 @@ async def state(request: Request) -> StateResponse:
 
     runner = getattr(request.app.state.inference_manager, "vllm_runner", None)
     loaded_model = getattr(runner, "model", None) if runner is not None else None
+    versions_response = await _query_vllm_versions(healthy_ports)
 
     return StateResponse(
         state=current_state,
         poc_status=poc_status,
         inference_healthy=True,
         loaded_model=loaded_model,
+        poc_validation_inference=versions_response.poc_validation_inference,
     )
 
+
+@router.get("/versions")
+async def versions() -> VersionsResponse:
+    return await _query_vllm_versions()
+
+
 @router.post("/stop")
 async def stop(request: Request):
     pow_manager: PowManager = request.app.state.pow_manager
diff --git a/mlnode/packages/api/tests/unit/test_state_endpoint.py b/mlnode/packages/api/tests/unit/test_state_endpoint.py
index cd3d2183bd..c70c534139 100644
--- a/mlnode/packages/api/tests/unit/test_state_endpoint.py
+++ b/mlnode/packages/api/tests/unit/test_state_endpoint.py
@@ -1,17 +1,27 @@
 """Tests for GET /api/v1/state — state endpoint."""
 
-from unittest.mock import Mock, AsyncMock, patch
+from unittest.mock import Mock, AsyncMock, MagicMock, patch
 
 import pytest
 from fastapi.testclient import TestClient
 
+import api.routes as api_routes
 from api.app import app
 from api.service_management import ServiceState
 
 
+def make_mock_response(status_code: int, json_data: dict):
+    response = MagicMock()
+    response.status_code = status_code
+    response.json.return_value = json_data
+    return response
+
+
 @pytest.fixture(autouse=True)
 def reset_app_state():
     """Each test starts with a clean slate: no services running, no vLLM backends."""
+    api_routes._vllm_versions_cache = None
+
     pow_manager = Mock()
     pow_manager.is_running.return_value = False
 
@@ -29,6 +39,7 @@ def reset_app_state():
     app.state.service_state = ServiceState.STOPPED
 
     yield
+    api_routes._vllm_versions_cache = None
 
 
 @pytest.fixture
@@ -57,6 +68,7 @@ def test_stopped_node_returns_only_state_field(client):
     assert data["poc_status"] is None
     assert data["inference_healthy"] is None
     assert data["loaded_model"] is None
+    assert data["poc_validation_inference"] is False
 
 
 def test_pow_mode_returns_only_state_field(client):
@@ -109,6 +121,7 @@ def test_inference_started_but_vllm_not_healthy_yet(client):
     assert data["inference_healthy"] is False
     assert data["poc_status"] == "NO_BACKENDS"
     assert data["loaded_model"] is None
+    assert data["poc_validation_inference"] is False
 
 
 def test_inference_healthy_poc_idle(client):
@@ -135,6 +148,47 @@ def test_inference_healthy_poc_idle(client):
     assert data["inference_healthy"] is True
     assert data["poc_status"] == "IDLE"
     assert data["loaded_model"] == "Qwen/Qwen3-0.6B"
+    assert data["poc_validation_inference"] is False
+
+
+def test_inference_state_includes_poc_validation_capability(client):
+    """The broker gets the validation-inference capability in the /state poll."""
+    app.state.inference_manager.is_running.return_value = True
+    backend_response = make_mock_response(200, {
+        "vllm_version": "0.0.1",
+        "poc_validation_inference": True,
+    })
+
+    with patch.dict("api.proxy.vllm_healthy", {8000: True}, clear=True), \
+         patch.dict("api.proxy.poc_status_by_port", {8000: "IDLE"}, clear=True), \
+         patch("api.proxy.call_backend", new=AsyncMock(return_value=backend_response)) as call_backend:
+        response = client.get("/api/v1/state")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["state"] == "INFERENCE"
+    assert data["poc_validation_inference"] is True
+    call_backend.assert_awaited_once_with(8000, "GET", "/api/v1/pow/versions")
+
+
+def test_inference_state_uses_cached_poc_validation_capability(client):
+    """Capability is static per vLLM build, so /state should not query every time."""
+    app.state.inference_manager.is_running.return_value = True
+    backend_response = make_mock_response(200, {
+        "vllm_version": "0.0.1",
+        "poc_validation_inference": True,
+    })
+
+    with patch.dict("api.proxy.vllm_healthy", {8000: True}, clear=True), \
+         patch.dict("api.proxy.poc_status_by_port", {8000: "IDLE"}, clear=True), \
+         patch("api.proxy.call_backend", new=AsyncMock(return_value=backend_response)) as call_backend:
+        first_response = client.get("/api/v1/state")
+        second_response = client.get("/api/v1/state")
+
+    assert first_response.status_code == 200
+    assert second_response.status_code == 200
+    assert second_response.json()["poc_validation_inference"] is True
+    call_backend.assert_awaited_once_with(8000, "GET", "/api/v1/pow/versions")
 
 
 def test_inference_healthy_poc_generating(client):
diff --git a/mlnode/packages/api/tests/unit/test_versions_endpoint.py b/mlnode/packages/api/tests/unit/test_versions_endpoint.py
new file mode 100644
index 0000000000..2fc2e81524
--- /dev/null
+++ b/mlnode/packages/api/tests/unit/test_versions_endpoint.py
@@ -0,0 +1,116 @@
+"""Tests for GET /api/v1/versions."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+import api.routes as api_routes
+from api.app import app
+
+
+@pytest.fixture(autouse=True)
+def reset_versions_cache():
+    api_routes._vllm_versions_cache = None
+    yield
+    api_routes._vllm_versions_cache = None
+
+
+def make_mock_response(status_code: int, json_data: dict):
+    response = MagicMock()
+    response.status_code = status_code
+    response.json.return_value = json_data
+    return response
+
+
+def test_versions_proxies_vllm_capability():
+    client = TestClient(app)
+    backend_response = make_mock_response(200, {
+        "vllm_version": "0.0.1",
+        "poc_validation_inference": True,
+    })
+
+    with patch("api.proxy.get_healthy_backends", return_value=[5001]), \
+         patch("api.proxy.call_backend", new=AsyncMock(return_value=backend_response)) as call_backend:
+        response = client.get("/api/v1/versions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["version"]
+    assert data["vllm_version"] == "0.0.1"
+    assert data["poc_validation_inference"] is True
+    call_backend.assert_awaited_once_with(5001, "GET", "/api/v1/pow/versions")
+
+
+def test_versions_uses_cached_capability_after_success():
+    client = TestClient(app)
+    backend_response = make_mock_response(200, {
+        "vllm_version": "0.0.1",
+        "poc_validation_inference": True,
+    })
+
+    with patch("api.proxy.get_healthy_backends", return_value=[5001]), \
+         patch("api.proxy.call_backend", new=AsyncMock(return_value=backend_response)) as call_backend:
+        first_response = client.get("/api/v1/versions")
+        second_response = client.get("/api/v1/versions")
+
+    assert first_response.status_code == 200
+    assert second_response.status_code == 200
+    assert second_response.json()["poc_validation_inference"] is True
+    call_backend.assert_awaited_once_with(5001, "GET", "/api/v1/pow/versions")
+
+
+def test_versions_no_backend_fails_closed():
+    client = TestClient(app)
+
+    with patch("api.proxy.get_healthy_backends", return_value=[]), \
+         patch("api.proxy.call_backend", new=AsyncMock()) as call_backend:
+        response = client.get("/api/v1/versions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["version"]
+    assert data["vllm_version"] is None
+    assert data["poc_validation_inference"] is False
+    call_backend.assert_not_awaited()
+
+
+def test_versions_backend_error_fails_closed():
+    client = TestClient(app)
+
+    with patch("api.proxy.get_healthy_backends", return_value=[5001]), \
+         patch("api.proxy.call_backend", new=AsyncMock(side_effect=RuntimeError("boom"))):
+        response = client.get("/api/v1/versions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["vllm_version"] is None
+    assert data["poc_validation_inference"] is False
+
+
+def test_versions_backend_404_fails_closed():
+    client = TestClient(app)
+    backend_response = make_mock_response(404, {"detail": "Not Found"})
+
+    with patch("api.proxy.get_healthy_backends", return_value=[5001]), \
+         patch("api.proxy.call_backend", new=AsyncMock(return_value=backend_response)):
+        response = client.get("/api/v1/versions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["vllm_version"] is None
+    assert data["poc_validation_inference"] is False
+
+
+def test_versions_malformed_backend_response_fails_closed():
+    client = TestClient(app)
+    backend_response = make_mock_response(200, ["not", "an", "object"])
+
+    with patch("api.proxy.get_healthy_backends", return_value=[5001]), \
+         patch("api.proxy.call_backend", new=AsyncMock(return_value=backend_response)):
+        response = client.get("/api/v1/versions")
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["vllm_version"] is None
+    assert data["poc_validation_inference"] is False
diff --git a/proposals/ethereum-bridge-contact/transfer-ownership.js b/proposals/ethereum-bridge-contact/transfer-ownership.js
index c0ff24fa29..2a37b0457c 100644
--- a/proposals/ethereum-bridge-contact/transfer-ownership.js
+++ b/proposals/ethereum-bridge-contact/transfer-ownership.js
@@ -29,6 +29,16 @@ async function getProviderAndSigner() {
     return { provider, signer, ethers };
 }
 
+async function buildTransferOwnershipOverrides(bridge, newOwnerAddress, feeData) {
+    const gasLimit = await bridge.transferOwnership.estimateGas(newOwnerAddress);
+
+    return {
+        gasLimit,
+        maxFeePerGas: feeData.maxFeePerGas,
+        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+    };
+}
+
 async function transferOwnership(contractAddress, newOwnerAddress) {
     console.log("=== Transfer Ownership of Bridge Contract ===\n");
     
@@ -93,15 +103,14 @@ async function transferOwnership(contractAddress, newOwnerAddress) {
     console.log("Gas fees:");
     console.log("- Max Fee:", ethers.formatUnits(feeData.maxFeePerGas, "gwei"), "gwei");
     console.log("- Priority Fee:", ethers.formatUnits(feeData.maxPriorityFeePerGas, "gwei"), "gwei");
+    const overrides = await buildTransferOwnershipOverrides(bridge, newOwnerAddress, feeData);
+    console.log("- Gas Limit:", overrides.gasLimit.toString());
     console.log();
     
     // Transfer ownership
     console.log(`Transferring ownership to ${newOwnerAddress}...`);
     console.log("(Confirm the transaction on your Ledger if using hardware wallet)");
-    const tx = await bridge.transferOwnership(newOwnerAddress, {
-        maxFeePerGas: feeData.maxFeePerGas,
-        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-    });
+    const tx = await bridge.transferOwnership(newOwnerAddress, overrides);
     
     console.log("✓ Transaction sent:", tx.hash);
     console.log("Waiting for confirmation...");
@@ -169,6 +178,7 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 }
 
 export {
+    buildTransferOwnershipOverrides,
     transferOwnership
 };
 
diff --git a/proposals/gateway-observability/observability.md b/proposals/gateway-observability/observability.md
new file mode 100644
index 0000000000..2b20ca3e2f
--- /dev/null
+++ b/proposals/gateway-observability/observability.md
@@ -0,0 +1,1094 @@
+# Proposal: Devshard Gateway Observability
+
+## Summary
+
+`devshardctl` gateway mode is the reliability layer in front of devshards. It
+selects escrows, routes user requests, starts extra participant attempts, hides
+loser failures, quarantines bad participants, burns ghost/probe slots, serves
+cache hits, and triggers timeout handling.
+
+That makes the final user experience better, but it also hides the evidence that
+devshard protocol developers need. A user request can succeed while several
+participant attempts failed, stalled, were skipped, were shadowed as no-winner,
+or forced extra timeout work. Host-side `devshardd` observability is useful, but
+it is not a trusted global source in a decentralized network. Hosts may be
+dishonest, offline, misconfigured, or unwilling to expose data. Gateway
+observability must therefore provide the gateway-owned outside view of what
+happened.
+
+The goal of this proposal is a metrics-first Grafana dashboard for protocol
+developers. It should show, per participant address, model, and sometimes
+escrow:
+
+- what the user saw,
+- what the gateway sent, skipped, or ghosted,
+- why each gateway-visible failure or policy decision happened,
+- how much overscheduling was needed to protect users,
+- which participants look unreliable, suspicious, slow, or costly,
+- which patterns should inform future protocol changes.
+
+This proposal does not add a lifecycle database, new request drilldown APIs, or
+long-term per-request storage. Each user request and gateway/devshard attempt is
+a lifecycle concept used to increment precise Prometheus metrics, then the raw
+event can disappear.
+
+## Implementation Status
+
+Core V1 is implemented as the first pass:
+
+- Gateway request outcome counters, critical user failure counters, hidden
+  failure counters, user-visible winner counters, slot decision counters,
+  attempt start/terminal/failure counters, no-winner attempt counters,
+  timeout action counters, and participant quarantine state/transition metrics
+  are emitted from the gateway's in-memory Prometheus registry.
+- Per-model capacity gauges expose current scale, current weight, and baseline
+  weight so the dashboard can show reduced capacity by model instead of only an
+  aggregate gateway scale.
+- The focused dashboard is
+  `deploy/join/observability/grafana/dashboards/gonka-gateway-observability.json`.
+  It is organized summary-first with top-N tables, minimum-volume filters, and
+  lower-level drilldown rows so high-cardinality participant and reason data
+  remains readable. The interaction flow is model-first: select a model, inspect
+  top reasons, then drill into participants for the selected reason.
+- Metrics are recorded at existing lifecycle boundaries in `gateway.go`,
+  `redundancy.go`, `session_picker.go` via `runGhostProbe`, and
+  `participant_limiter.go`.
+- The implementation does not add request persistence, new APIs, database
+  writes, or Grafana queries against functional stores.
+
+Deferred from Core V1:
+
+- Diagnostic V1 metric families not needed for the first dashboard.
+- Core inference performance metric families listed below. They are design
+  targets, not emitted metrics in the current implementation.
+- Decode-token histograms and token/s calculations that require actual output
+  token plumbing.
+- Lifecycle database, request drilldown APIs, OTEL/Jaeger traces,
+  Loki-derived panels, and offline protocol-analysis exports.
+
+TODO: review naming across gateway metrics, dashboard labels, and docs for
+`slot`, `nonce`, `diff`, `decision`, `attempt`, and `vote`. In particular,
+`devshard_gateway_slot_decisions_total` is currently displayed as gateway nonce
+consumption in the dashboard because it counts real sends and ghost/no-send
+nonce burns, not voting amount. A later cleanup should decide whether to rename
+the emitted metric or keep it as a compatibility name with clearer dashboard
+labels.
+
+## Goal
+
+Gateway observability must answer protocol-development questions without trusting
+host-owned metrics:
+
+1. Which participant addresses perform worse for each model?
+2. Why did each participant fail or get skipped: no receipt, empty stream,
+   transport error, timeout, quarantine, capability miss, state divergence, or
+   another bounded reason?
+3. Which user-visible successes hid participant failures?
+4. How often does the gateway need extra real sends, ghost burns, probes, or
+   skipped slots to keep user failures near zero?
+5. How many slots are skipped because of quarantine, and which quarantine mode
+   caused the skip?
+6. Which participants are no-winner because of shadow quarantine, probation, or
+   manual suspicion?
+7. Which timeout actions are expected, started, completed, skipped, or failed?
+8. Which metrics should protocol developers use to tune participant selection,
+   redundancy, timeout windows, quarantine thresholds, validation, and
+   incentives?
+
+The first result should be one clear gateway dashboard backed by bounded
+Prometheus counters, gauges, and histograms. The dashboard must preserve failure
+reasons everywhere it shows failures. A panel that says only "failed" is not
+enough.
+
+## Non-Goals
+
+- Do not add a lifecycle DB or any new request/attempt persistence.
+- Do not add new admin APIs or drilldown endpoints.
+- Do not write new observability data to `gateway.db`, `perf.db`, or devshard
+  session storage.
+- Do not make dashboards query hot functional stores.
+- Do not add OTEL, Jaeger, or tracing requirements in the first pass.
+- Do not expose request bodies, prompt hashes, response bodies, private key
+  material, raw errors, `request_id`, or `nonce` in Prometheus labels.
+- Do not use host-side `devshardd` metrics as the source of truth for gateway
+  accountability.
+- Do not try to prove semantic truthfulness of model output. The gateway can
+  observe transport, timing, stream, protocol, and policy behavior; it cannot
+  prove the answer content is honest.
+
+## Current Gateway Role
+
+The important gateway code paths are:
+
+| Area | Files | Current responsibility |
+| --- | --- | --- |
+| Gateway routing | `devshard/cmd/devshardctl/gateway.go` | Request admission, model access, capacity-aware runtime selection, cache hits, runtime skip reasons. |
+| Per-escrow HTTP | `devshard/cmd/devshardctl/proxy.go` | OpenAI-compatible request handling, request accounting/debug surfaces, response mapping. |
+| Redundancy | `devshard/cmd/devshardctl/redundancy.go` | Primary and extra attempts, winner selection, loser suppression, empty stream/stall detection, timeout actions. |
+| Slot selection | `devshard/cmd/devshardctl/session_picker.go` | Nonce/host selection, ghost/probe/no-send reasons, capability and quarantine skips. |
+| Participant health | `devshard/cmd/devshardctl/participant_limiter.go` | Probe quarantine, shadow quarantine, probation, manual no-winner, failure strikes. |
+| Performance scoring | `devshard/cmd/devshardctl/hostperf.go`, `devshard/cmd/devshardctl/pairwise.go` | Rolling responsiveness and pairwise latency signals used for speculative routing. |
+| Metrics | `devshard/cmd/devshardctl/metrics.go` | Existing Prometheus gateway metrics and the right extension point. |
+| Transport | `devshard/transport/client.go` | Upstream HTTP status, transport failures, SSE/receipt path, host connection tracking. |
+
+Existing gateway metrics already cover HTTP route health, limiter rejection,
+speculative decision counts, timeout summary counts, picker choices, host timing
+by `host_idx`, runtime capacity, and transport connection state. The current gap
+is participant-accountable, reason-complete gateway behavior.
+
+The existing devshardd dashboards cover host/protocol internals such as terminal
+outcomes, interruptions, ML-node execute/validate attempts, validation
+lifecycle, payload serving, mempool/queue depth, traces, and logs. Gateway
+observability is the complementary outside view. It must remain useful even when
+host-side devshardd data is absent or untrusted.
+
+## Terminology Alignment
+
+Metric names, labels, reasons, and lifecycle terms must align with existing
+devshard terminology wherever possible.
+
+Primary sources:
+
+- `devshard/` code, especially `devshard/cmd/devshardctl/`
+- `devshard/docs/`
+- `devshard/observability/` naming patterns
+- `proposals/inference/` as earlier design context, with caution because it is
+  partly outdated
+
+Do not invent parallel names when an existing devshard term exists. If gateway
+observability needs a new term, the proposal must explain why the existing term
+does not fit and how the new term maps back to devshard protocol concepts.
+
+## Request Hierarchy
+
+One user request can produce zero, one, or many gateway/devshard attempts or
+scheduling decisions.
+
+```mermaid
+flowchart TD
+    UserRequest["User request"] --> Gateway["Gateway admission, routing, cache"]
+    Gateway --> UserStatus["User request status"]
+    Gateway --> AttemptA["Gateway/devshard attempt: primary"]
+    Gateway --> AttemptB["Gateway/devshard attempt: extra"]
+    Gateway --> AttemptC["Gateway/devshard decision: probe, ghost, or skipped"]
+    AttemptA --> AttemptStatusA["Attempt status + reason"]
+    AttemptB --> AttemptStatusB["Attempt status + reason"]
+    AttemptC --> DecisionStatus["Decision status + reason"]
+    AttemptStatusA --> Aggregate["Aggregate by user request"]
+    AttemptStatusB --> Aggregate
+    DecisionStatus --> Aggregate
+    Aggregate --> Metrics["Metrics and dashboard"]
+```
+
+User request outcome answers whether the final user was served. Critical user
+failures should be close to zero.
+
+Gateway/devshard attempt status answers what happened to each participant
+communication or scheduling decision. Attempt failures may be non-zero even when
+the user request succeeded.
+
+Overscheduling is the ratio between user requests and gateway/devshard attempts
+or decisions. Hidden failure rate is the rate of successful user requests where
+one or more gateway/devshard attempts failed, stalled, timed out, were no-winner,
+or were skipped for policy/health reasons.
+
+Skipped-slot pressure is tracked separately because it changes protocol behavior
+even when no HTTP request is sent.
+
+## Dimensions And Labels
+
+Use these dimensions consistently:
+
+| Dimension | Meaning | Prometheus label? |
+| --- | --- | --- |
+| `participant_key` | Gonka validator address / participant identity. Primary accountability key. | Yes, bounded by fewer than 100 participant keys in the target deployment. |
+| `model` | Requested model id. Required for capability and performance comparison. | Yes. |
+| `escrow_id` / `devshard_id` | On-chain devshard escrow/session. Existing gateway metrics usually call this `devshard_id`; this proposal uses `escrow_id` for the same logical id unless referencing existing metrics. Required for localized routing, skipped-slot, and timeout diagnosis. Not part of the default participant-quality view. | Sometimes. Use on counters where per-escrow attribution matters. Avoid it on default performance histograms. |
+| `host_idx` | Escrow-local slot index. Useful only with escrow membership mapping. | Existing host-index metrics may keep it; new accountability metrics should prefer `participant_key`. |
+| `role` | Why this attempt exists: primary, extra, ghost, skipped, cache alias. | Yes. |
+| `visibility` | Whether an attempt was user-visible, suppressed, no-winner, or failed before usable output. | Yes. |
+| `outcome` | Terminal result for a specific metric family. Each metric must define its own legal outcome enum. | Yes. |
+| `reason` | Bounded explanation from code path/log stage. | Yes. Required on failure and policy counters. |
+| `input_token_bucket` | Coarse gateway-side request input estimate. It is not guaranteed to be exact model-tokenizer output. | Yes for performance metrics. |
+| `output_token_bucket` | Coarse output-token bucket. Only valid when actual output token count is known. | Yes for decode metrics. |
+| `stream` | Whether the request used streaming. | Only where streaming and non-streaming share a metric. |
+| `capability_reason` | Bounded subreason for capability no-send. | Only on capability-specific counters. |
+| `request_id` | Gateway request id for logs/debug lookup. | No. |
+| `nonce` | Devshard inference nonce. | No. |
+
+Forbidden labels: raw error text, request body data, prompt hash, response hash,
+private key material, URLs with unbounded ids, `request_id`, `nonce`, trace id.
+
+Reason values must be bounded. If a reason cannot be classified, emit
+`reason="unknown"` and make that rare enough to alert on.
+
+### Token Buckets, Visibility, And Hidden Failure Severity
+
+Use coarse token buckets in dashboards. Do not expose exact input tokens, output
+tokens, `max_tokens`, or `max_completion_tokens` as labels.
+
+`input_token_bucket` uses the best gateway-side estimate available at the metric
+emission point. It must not be treated as canonical model tokenization unless the
+implementation has actual tokenizer-backed input tokens.
+
+Input token buckets:
+
+| Bucket | Meaning |
+| --- | --- |
+| `lt_10k` | Fewer than 10,000 input tokens. |
+| `10k_50k` | At least 10,000 and fewer than 50,000 input tokens. |
+| `50k_100k` | At least 50,000 and fewer than 100,000 input tokens. |
+| `100k_256k` | At least 100,000 and fewer than 256,000 input tokens. |
+| `gte_256k` | At least 256,000 input tokens. |
+
+Output token buckets:
+
+| Bucket | Meaning |
+| --- | --- |
+| `lt_128` | Fewer than 128 output tokens. |
+| `128_512` | At least 128 and fewer than 512 output tokens. |
+| `512_2k` | At least 512 and fewer than 2,000 output tokens. |
+| `2k_8k` | At least 2,000 and fewer than 8,000 output tokens. |
+| `gte_8k` | At least 8,000 output tokens. |
+
+Attempt visibility values:
+
+| Visibility | Meaning |
+| --- | --- |
+| `user_visible_winner` | This attempt produced the content shown to the user. Use for SLO and final-user performance panels. |
+| `suppressed_loser` | The attempt produced or could have produced data, but another attempt won. Use for hidden cost and participant-quality analysis. |
+| `no_winner_candidate` | The participant was shadow-quarantined, probationary, or manually suspicious and could not win normally. |
+| `failed_not_finished` | The attempt failed or did not reach usable output. |
+
+Hidden failure severity values:
+
+| Severity | Meaning |
+| --- | --- |
+| `loser_pre_winner` | A non-winning attempt failed before the user-visible winner was selected. |
+| `loser_after_winner` | A non-winning attempt failed after another attempt already protected the user. |
+| `winner_post_content` | The user-visible winner produced content, then stalled or failed. |
+| `scheduling_only` | A ghost/no-send, queue, cache, or policy decision created overhead without an upstream participant failure. |
+
+## Reason Taxonomy
+
+The dashboard must show why failures happened. Reason values should map to
+existing code paths or log stages, not invented analytical guesses.
+
+### Admission And Routing Reasons
+
+| Reason | Meaning |
+| --- | --- |
+| `max_concurrent_requests` | Gateway concurrency cap rejected the user request. |
+| `max_input_tokens_in_flight` | Gateway input-token cap rejected the user request. |
+| `model_access_denied` | Model access mode rejected the caller. |
+| `unsupported_model` | No configured runtime supports the requested model. |
+| `model_temporarily_unavailable` | Model exists but policy temporarily blocks it. |
+| `no_runtime_for_model` | No active compatible runtime exists. |
+| `all_escrows_zero_capacity` | Candidate escrows exist but all have zero effective capacity. |
+| `high_nonce` | Candidate escrow is near or over its nonce limit. |
+| `inactive` | Candidate escrow is inactive. |
+| `finalizing` | Candidate escrow is finalizing. |
+| `settlement` | Candidate escrow is in settlement. |
+| `low_balance` | Escrow balance is low enough to affect routing or replacement. |
+| `balance_exhausted` | Escrow balance was exhausted. |
+| `escrow_missing` | Escrow lookup or upstream escrow state was missing. |
+| `insufficient_balance` | Escrow cannot pay for more work. |
+| `invalid_request` | Request parsing, normalization, or parameter validation failed. |
+| `body_required` | Request body was missing. |
+| `body_too_large` | Request body exceeded the gateway limit. |
+| `malformed_json` | Request body was not valid JSON. |
+| `unknown_parameter` | Request contained a rejected parameter. |
+| `messages_invalid` | Request messages were malformed or unsupported. |
+| `parameter_invalid` | Request parameter failed validation. |
+| `schema_invalid` | Structured schema validation failed. |
+| `structured_outputs_invalid` | Structured output settings were invalid. |
+| `operator_disabled` | Gateway disabled mode returned a configured response. |
+| `cache_hit` | User request was served from cache. |
+
+### Scheduling And Slot Reasons
+
+Use existing picker and redundancy strings where possible.
+
+| Reason | Meaning |
+| --- | --- |
+| `normal` | Primary path. |
+| `primary_unresponsive` | PerfTracker expects primary to be slow or failed. |
+| `receipt_timeout` | No receipt arrived in the expected window. |
+| `first_token_timeout` | Receipt arrived but first token lagged. |
+| `attempt_failed` | Prior attempt failed before winner selection. |
+| `primary_suspicious` | Primary is suspicious or shadow/no-winner. |
+| `suspicious_host` | Escalation caused by suspicious/no-winner host. |
+| `pairwise_budgeted_speedup` | Pairwise tracker expects another participant to be faster. |
+| `pairwise_ab_sample` | Intentional pairwise exploration sample. |
+| `pairwise_insufficient_data` | Pairwise mode lacks enough data and falls back. |
+| `secondary_faster` | Legacy/simple speed policy expects secondary advantage. |
+| `poc_probe` | PoC/probe path caused extra scheduling. |
+| `poc_unavailable_host` | Picker burned a ghost because PoC made the host unavailable. |
+| `participant_throttled_no_send` | Picker burned a ghost because the participant is probe-quarantined/throttled. |
+| `participant_capability_no_send` | Participant cannot serve the request shape/model. |
+| `no_compatible_request_after_stale` | Queued requests excluded this participant past the stale threshold. |
+| `all_hosts_excluded` | Request already tried every distinct participant in the escrow. |
+| `no_available_host` | Untried participants exist but none are currently usable. |
+| `stale_wait` | Picker held a queued request while waiting for a compatible slot. |
+| `context_cancelled` | Picker or request context was cancelled before dispatch. |
+| `picker_stopped` | Picker stopped before it could dispatch. |
+
+### Attempt Failure Reasons
+
+| Reason | Meaning |
+| --- | --- |
+| `no_receipt` | No receipt was observed. |
+| `receipt_but_no_content` | Receipt arrived but no content appeared. |
+| `empty_stream` | Stream produced no usable content chunks. |
+| `error_stream` | Host returned an OpenAI-style streamed error. |
+| `content_but_not_finished` | Content appeared but finish was missing. |
+| `winner_stalled_after_content` | Winner emitted content then stalled. |
+| `inter_chunk_stall` | Stream stalled between chunks. |
+| `hard_timeout` | Attempt exceeded the hard timeout. |
+| `transport_error` | Connection, DNS, TLS, timeout, or non-HTTP transport failure. |
+| `eof_transport` | EOF-style stream/read failure. |
+| `sse_truncated` | SSE stream ended unexpectedly. |
+| `http_429` | Host returned HTTP 429. |
+| `http_503` | Host returned HTTP 503. |
+| `http_forbidden` | Host returned HTTP 403. |
+| `http_not_found` | Host returned HTTP 404. |
+| `http_timestamp_drift` | Host returned timestamp-related HTTP 401. |
+| `http_error` | Other non-success HTTP status. |
+| `phase_transition_aborted` | Phase changed and attempt was intentionally aborted. |
+| `state_divergence` | Local/session state diverged from expected state. |
+| `client_cancelled` | Client disconnected or cancelled. |
+
+### Policy And Participant-Health Reasons
+
+| Reason | Meaning |
+| --- | --- |
+| `probe_quarantine` | Participant is blocked from real traffic for the model. |
+| `shadow_quarantine` | Participant receives traffic but cannot win. |
+| `probation` | Participant is recovering but remains no-winner. |
+| `manual_suspicious` | Participant is on the manual suspicious list. |
+| `empty_stream_quarantine` | Empty-stream strike threshold caused shadow quarantine. |
+| `eof_transport_quarantine` | EOF strike threshold caused probe quarantine. |
+| `transport_failure_quarantine` | Non-EOF transport failure caused probe quarantine. |
+| `http_throttle_quarantine` | HTTP 429/503 caused probe quarantine. |
+| `stalled_winner_quarantine` | Stalled winner caused shadow quarantine. |
+
+### Timeout Taxonomy
+
+Timeout metrics use three separate label dimensions: `kind`, `action`, and
+`reason`. Do not duplicate `kind` or `action` values inside `reason`.
+
+Timeout kind values:
+
+| Kind | Meaning |
+| --- | --- |
+| `refused` | No receipt before refusal timeout. |
+| `execution` | Receipt exists but execution did not finish before execution timeout. |
+| `unknown` | Classified fallback. |
+
+Timeout action values:
+
+| Action | Meaning |
+| --- | --- |
+| `expected` | Attempt should need timeout handling. |
+| `started` | Timeout handling began. |
+| `completed` | Timeout handling completed. |
+| `skipped` | Timeout handling was intentionally skipped. |
+| `failed` | Timeout handling failed. |
+
+Timeout reason values:
+
+| Reason | Meaning |
+| --- | --- |
+| `none` | No additional reason applies. |
+| `nonce_already_finished` | Timeout skipped because nonce was already finished. |
+| `empty_stream_without_non_empty_winner` | Timeout skipped for empty stream without a non-empty winner. |
+| `long_response_after_content` | Timeout skipped/deferred because long content had already appeared. |
+| `timeout_insufficient_votes` | Timeout vote collection lacked enough accepted weight. |
+| `timeout_collection_error` | Timeout vote collection failed. |
+| `timeout_diff_send_failed` | Timeout diff could not be sent. |
+| `timeout_vote_rejected` | A contacted verifier rejected the timeout. |
+| `timeout_vote_error` | A contacted verifier errored while verifying timeout. |
+| `timeout_vote_queue_expired` | Verifier queue wait expired before the vote RPC. |
+
+Per-verifier timeout vote metrics are future work unless `user.Session` exposes
+structured verifier outcomes. Executor-level timeout actions are in scope.
+
+## Metric Taxonomy
+
+Metrics should be incremented at existing gateway lifecycle boundaries. Do not
+add a request ledger to derive them later.
+
+### Authoritative Metrics
+
+Use one authoritative metric for each dashboard question. Other metrics may add
+diagnostic detail, but they should not be mixed into the same ratio without an
+explicit reason.
+
+| Question | Authoritative metric |
+| --- | --- |
+| What happened to the user request? | `devshard_gateway_requests_total` |
+| Whose output did users see? | `devshard_gateway_user_visible_wins_total` |
+| Which user successes hid gateway-visible problems? | `devshard_gateway_user_requests_with_hidden_failure_total` |
+| Which slots were real sends, ghost/no-send burns, or exhausted? | `devshard_gateway_slot_decisions_total` |
+| Which real attempts started? | `devshard_gateway_attempts_started_total` |
+| How did real attempts terminate? | `devshard_gateway_attempts_terminal_total` and `devshard_gateway_attempt_failures_total` |
+| What is the current participant quarantine/no-winner state? | `devshard_gateway_participant_quarantine_state` |
+| What timeout work happened for a participant? | `devshard_gateway_timeout_actions_total` |
+| How fast was user-visible and attempt-level inference? | `devshard_gateway_user_visible_ttft_seconds`, `devshard_gateway_attempt_first_content_seconds`, and decode token/duration metrics |
+
+### Core V1 Metrics
+
+Core metrics drive the first dashboard and default participant-quality table.
+They avoid `escrow_id` unless the metric is specifically about slots.
+
+```text
+devshard_gateway_requests_total{model,outcome,reason}
+devshard_gateway_critical_user_failures_total{model,reason}
+devshard_gateway_user_requests_with_hidden_failure_total{model,severity,reason}
+devshard_gateway_user_visible_wins_total{participant_key,model}
+
+devshard_gateway_slot_decisions_total{
+  participant_key,
+  model,
+  escrow_id,
+  decision,
+  reason,
+  quarantine_mode
+}
+
+devshard_gateway_attempts_started_total{
+  participant_key,
+  model,
+  role,
+  reason,
+  quarantine_mode
+}
+
+devshard_gateway_attempts_terminal_total{
+  participant_key,
+  model,
+  role,
+  outcome,
+  visibility
+}
+
+devshard_gateway_attempt_failures_total{
+  participant_key,
+  model,
+  role,
+  reason,
+  visibility
+}
+
+devshard_gateway_participant_quarantine_state{participant_key,model,mode}
+devshard_gateway_participant_quarantine_transitions_total{participant_key,model,mode,reason}
+devshard_gateway_no_winner_attempts_total{participant_key,model,reason,quarantine_mode}
+
+devshard_gateway_timeout_actions_total{
+  participant_key,
+  model,
+  kind,
+  action,
+  reason
+}
+```
+
+User request `outcome` values:
+
+| Outcome | Meaning |
+| --- | --- |
+| `success` | User received a successful response or stream. |
+| `failed` | Gateway returned an error after trying or deciding no usable path exists. |
+| `cached` | Gateway served cached output without new participant traffic. |
+| `client_cancelled` | Client disconnected or cancelled. |
+| `model_rejected` | Model policy/access rejected the request. |
+| `gateway_limited` | Gateway-wide limit rejected the request. |
+| `runtime_unavailable` | No compatible runtime/escrow was available. |
+| `invalid_request` | Request failed parsing or validation. |
+| `gateway_disabled` | Gateway disabled mode returned a configured response. |
+| `unknown` | Classified fallback; should be rare. |
+
+Real attempt `role` values:
+
+| Role | Meaning |
+| --- | --- |
+| `primary` | First real attempt intended to serve the user request. |
+| `extra` | Additional real attempt caused by redundancy/fallback. |
+
+Ghost/no-send, skipped, and cache-alias decisions are counted by
+`slot_decisions_total`, `picker_queue_events_total`, or request/cache metrics,
+not by real attempt metrics. Do not use `role="probe"` for current gateway
+behavior; current probe-like paths are ghost/no-send burns unless a future
+implementation introduces a real HTTP probe.
+
+Real attempt `outcome` values:
+
+| Outcome | Meaning |
+| --- | --- |
+| `success` | Attempt completed and is usable. |
+| `failed` | Attempt ended with a communication, stream, protocol, or application failure. |
+| `not_finished` | Attempt started but did not reach expected finish state. |
+| `client_cancelled` | Client cancellation affected the attempt. |
+| `timeout_skipped` | Timeout was expected but intentionally skipped. |
+| `unknown` | Classified fallback; should be rare. |
+
+`attempt_failures_total` carries `reason`; `attempts_terminal_total` does not.
+This keeps high-cardinality failure reasons out of the main terminal counter.
+
+`visibility` is the single winner/loser/no-winner encoding for attempt metrics.
+Do not add parallel `winner`, `hidden_from_user`, or `no_winner` boolean labels.
+`attempts_started_total` does not include `visibility` because winner/loser state
+is only known later, after race settlement.
+
+`user_requests_with_hidden_failure_total` is emitted at user-request settlement,
+after the gateway knows the final user request outcome and whether another
+attempt protected the client.
+
+`critical_user_failures_total` is the small user-visible failure set that should
+stay near zero. It should include failed, runtime unavailable, gateway limited,
+invalid request, and model rejected when those are not intentional maintenance.
+
+`user_visible_wins_total` counts the participant whose output was actually shown
+to the user. It has no `escrow_id` label by default because the main question is
+which address users really see for each model. Cached requests should not
+increment this metric unless the gateway can safely attribute the cache source to
+the original winner.
+
+Route latency should use the existing gateway HTTP duration metric unless a
+model-aware duration is added later.
+
+### Core Inference Performance Metrics
+
+Status: not implemented in Core V1. These metric names are future
+instrumentation targets and should not be referenced by the current dashboard
+until `devshardctl` emits them.
+
+```text
+devshard_gateway_attempt_receipt_seconds{participant_key,model,outcome}
+devshard_gateway_attempt_total_seconds{participant_key,model,outcome}
+
+devshard_gateway_user_visible_ttft_seconds{
+  participant_key,
+  model,
+  input_token_bucket,
+  outcome
+}
+
+devshard_gateway_attempt_first_content_seconds{
+  participant_key,
+  model,
+  input_token_bucket,
+  visibility,
+  outcome
+}
+
+devshard_gateway_attempt_prefill_after_receipt_seconds{
+  participant_key,
+  model,
+  input_token_bucket,
+  visibility,
+  outcome
+}
+
+devshard_gateway_attempt_decode_duration_seconds{
+  participant_key,
+  model,
+  input_token_bucket,
+  output_token_bucket,
+  visibility,
+  outcome
+}
+
+devshard_gateway_attempt_decode_tokens_total{
+  participant_key,
+  model,
+  input_token_bucket,
+  output_token_bucket,
+  visibility,
+  outcome
+}
+```
+
+These metrics attribute inference performance to participant identity, not only
+escrow-local `host_idx`. Keep the default participant-quality performance view
+aggregated by `participant_key` and `model`. Escrow-specific performance belongs
+in diagnostics only.
+
+Definitions:
+
+| Metric | Meaning |
+| --- | --- |
+| `attempt_receipt_seconds` | Time from upstream send to devshard receipt. |
+| `attempt_total_seconds` | Time from upstream send to attempt completion. Do not include loser settlement after the attempt is done. |
+| `user_visible_ttft_seconds` | Time from gateway request acceptance to the first content-bearing chunk successfully written to the client for the user-visible winner. Cache hits and non-streaming requests do not increment it. |
+| `attempt_first_content_seconds` | Time from upstream attempt send to the first content-bearing chunk for that attempt. |
+| `attempt_prefill_after_receipt_seconds` | Time from receipt observed by the gateway to the first content-bearing chunk. |
+| `attempt_decode_duration_seconds` | Time from first content-bearing chunk to generation end for that attempt. Do not include timeout handling, loser settlement, or background drain. |
+| `attempt_decode_tokens_total` | Actual output tokens for the attempt, from `MsgFinishInference.OutputTokens` or final OpenAI usage when available. |
+
+Decode tokens/s is derived from `attempt_decode_tokens_total` and
+`attempt_decode_duration_seconds`. Do not add a separate
+`attempt_decode_tokens_per_second` metric in the first pass. Do not derive decode
+tokens/s from SSE chunk count. Chunks and bytes can be useful future diagnostics,
+but they are not tokens. If actual output tokens are unavailable, do not
+increment decode token metrics.
+
+For thinking/reasoning models, content-bearing chunks include visible assistant
+content, reasoning content, and tool-call content if those chunks are forwarded
+to the user. If a future dashboard needs "first visible answer token" separate
+from "first reasoning/tool token", add a new bounded `content_source` label or a
+separate metric.
+
+### Derived Ratios
+
+Do not add a separate required `devshard_gateway_overscheduled_attempts_total`
+counter. Overscheduling overlaps with request, slot, and attempt metrics and
+should be derived from authoritative counters.
+
+```text
+extra_real_sends_per_user_request =
+  rate(devshard_gateway_attempts_started_total{role="extra"}[$window])
+  / rate(devshard_gateway_requests_total[$window])
+
+ghost_no_send_per_user_request =
+  rate(devshard_gateway_slot_decisions_total{decision="ghost_no_send"}[$window])
+  / rate(devshard_gateway_requests_total[$window])
+
+suppressed_losers_per_user_request =
+  rate(devshard_gateway_attempts_terminal_total{visibility="suppressed_loser"}[$window])
+  / rate(devshard_gateway_requests_total[$window])
+
+failed_sent_attempts_per_successful_user_request =
+  rate(devshard_gateway_attempts_terminal_total{
+    outcome=~"failed|not_finished",
+    visibility="failed_not_finished"
+  }[$window])
+  / rate(devshard_gateway_requests_total{outcome="success"}[$window])
+```
+
+### Diagnostic V1 Metrics
+
+Diagnostic metrics explain localized or lower-level gateway behavior. They can
+appear in gateway mechanics, heatmaps, or drilldown panels, but should not drive
+the default participant-quality score unless explicitly stated.
+
+Status: not implemented in Core V1. Treat metric names in this section as future
+metric contracts. Dashboards should not reference them until implementation and
+dashboard lint confirm they are emitted.
+
+#### Runtime Selection
+
+```text
+devshard_gateway_runtime_selection_total{model,escrow_id,outcome,reason}
+```
+
+Runtime selection `outcome` values: `selected`, `skipped`, `unavailable`.
+
+#### Cache Lifecycle
+
+```text
+devshard_gateway_cache_events_total{model,stream,event,reason}
+```
+
+`event` values: `hit`, `miss`, `stored`, `store_skipped`, `expired`.
+
+`reason` should stay bounded: `cache_hit`, `cache_miss`,
+`noncacheable_status`, `noncacheable_error`, `write_error`, `request_error`,
+`expired`, `unknown`.
+
+#### Limiter And PoC Bypass
+
+```text
+devshard_gateway_limiter_bypass_total{model,reason}
+```
+
+`reason` values: `poc`, `confirmation_poc`, `unknown`.
+
+#### Picker Queue Events
+
+```text
+devshard_gateway_picker_queue_events_total{model,escrow_id,event,reason}
+```
+
+`event` values: `hold`, `drop`, `chooser_error`, `stopped`.
+
+`held` is not a slot decision because it does not consume a nonce. Use this
+metric for queue holds and drops, and `slot_decisions_total` for real sends or
+ghost/no-send nonce burns.
+
+#### Capability Subreasons
+
+```text
+devshard_gateway_capability_no_send_total{
+  participant_key,
+  model,
+  escrow_id,
+  capability_reason
+}
+```
+
+`capability_reason` values: `tool_choice_unsupported`,
+`context_limit_exceeded`, `escrow_state_root_diverged`, `unknown`.
+
+#### Escalation Starts And Skips
+
+```text
+devshard_gateway_escalations_total{
+  participant_key,
+  model,
+  stage,
+  action,
+  trigger_reason,
+  skip_reason
+}
+```
+
+`action` values: `started`, `skipped`.
+
+`skip_reason` values: `attempt_limit`, `race_decided`, `exhausted`,
+`client_cancelled`, `unknown`. Use `skip_reason="none"` when action is
+`started`.
+
+#### No-Winner Fallback Wins
+
+```text
+devshard_gateway_no_winner_fallback_wins_total{
+  participant_key,
+  model,
+  reason,
+  quarantine_mode
+}
+```
+
+This counts cases where a suspicious, shadow-quarantined, or probationary
+participant eventually becomes the fallback winner because no clean winner is
+available.
+
+#### Participant Strike And Manual Suspicion State
+
+```text
+devshard_gateway_participant_failure_strikes{participant_key,model,mode}
+devshard_gateway_manual_suspicion_state{participant_key}
+devshard_gateway_manual_suspicion_transitions_total{participant_key,action}
+```
+
+`action` values for manual suspicion: `added`, `removed`.
+
+#### Upstream Transport Attribution
+
+```text
+devshard_gateway_upstream_requests_total{
+  participant_key,
+  model,
+  path_kind,
+  outcome,
+  status_code,
+  error_class,
+  quarantine_action
+}
+```
+
+`path_kind` should reuse existing transport path kinds: `inference`,
+`verify_timeout`, `challenge_receipt`, `gossip`, `query`, `other`.
+
+`outcome` values: `success`, `http_error`, `transport_error`,
+`admission_rejected`, `cancelled`, `unknown`.
+
+`error_class` values should be bounded: `none`, `eof`, `sse_truncated`,
+`dial_timeout`, `connection_refused`, `connection_reset`, `dns`, `tls`,
+`context_cancelled`, `other`.
+
+`quarantine_action` values: `none`, `probe_quarantine`, `shadow_quarantine`,
+`strike_incremented`, `ignored_non_inference`.
+
+#### Stream Delivery Outcomes
+
+```text
+devshard_gateway_stream_delivery_total{model,outcome,reason}
+```
+
+`outcome` values: `ok`, `client_cancelled`, `write_failed`, `flush_failed`,
+`done_write_failed`, `host_error`, `error_after_done`, `unknown`.
+
+This tracks gateway-to-client delivery, not host execution. Client delivery
+failures matter because the gateway can continue background drain or protocol
+settlement after the user is gone. They should not be confused with participant
+execution quality.
+
+## Dashboard
+
+Add a gateway dashboard focused on protocol developers. The dashboard should have
+filters for `model`, `participant_key`, `escrow_id`, `reason`, and time window.
+
+Core rows should use the authoritative metrics listed above. Diagnostic rows can
+use more specialized metrics, but they should not change the default
+participant-quality score without an explicit dashboard note.
+
+### Row 1: User Health
+
+Purpose: show whether users are protected.
+
+Panels:
+
+- User requests by `outcome` and `reason`.
+- Critical user failures by `reason`.
+- User success rate.
+- Gateway p95 route latency.
+- Active requests and input tokens in flight from existing gateway metrics.
+- Limiter rejects by reason.
+- Runtime unavailable / model rejected / invalid request rates.
+- Cache hit rate.
+
+### Row 2: Devshard Attempt Health
+
+Purpose: show what happened behind each user request.
+
+Panels:
+
+- Attempts started by `role`.
+- Attempts terminal by `outcome`.
+- Attempt failures by `reason`.
+- Winner vs loser outcomes.
+- User-visible wins by participant and model.
+- Sent attempts per user request.
+- Failed sent attempts per successful user request.
+
+### Row 3: Inference Performance
+
+Purpose: compare user-visible latency and participant execution quality.
+
+Panels:
+
+- User-visible TTFT p50/p95/p99 by model and input token bucket.
+- User-visible TTFT p95 by participant and model.
+- Attempt first-content p95 by `visibility`, model, and input token bucket.
+- Prefill-after-receipt p95 by participant and input token bucket.
+- Decode tokens/s p50/p95 by participant, model, and input token bucket.
+- Decode tokens/s comparison for `user_visible_winner` vs `suppressed_loser`.
+- Slow-but-successful participants: high TTFT or decode latency with low failure
+  rate.
+- Fast-but-unreliable participants: low TTFT but high hidden failure, no-winner,
+  or timeout rate.
+
+### Row 4: Hidden Failures
+
+Purpose: show failures hidden by redundancy.
+
+Panels:
+
+- User requests with hidden failures by severity and reason.
+- Hidden loser failures before winner selection.
+- Hidden loser failures after winner selection.
+- Winner failures after content.
+- Top hidden failure participants by model.
+- Top hidden failure reasons by model.
+
+### Row 5: Overscheduling
+
+Purpose: show cost of protecting the user.
+
+Panels:
+
+- Extra real sends per user request.
+- Ghost/no-send slots per user request.
+- Suppressed losers per user request.
+- Overscheduling derived from authoritative request, slot, and attempt metrics.
+- Useful redundancy vs waste:
+  - useful: `receipt_timeout`, `first_token_timeout`,
+    `primary_unresponsive`, `attempt_failed`, `pairwise_budgeted_speedup`;
+  - exploration: `pairwise_ab_sample`, `poc_probe`;
+  - waste/policy pressure: `participant_throttled_no_send`,
+    `participant_capability_no_send`, `no_compatible_request_after_stale`,
+    `all_hosts_excluded`, `no_available_host`, `manual_suspicious`,
+    `shadow_quarantine`, `probation`.
+
+### Row 6: Skipped Slots And Quarantine Pressure
+
+Purpose: show how much protocol scheduling is changed before any HTTP send.
+
+Panels:
+
+- Slots skipped because of quarantine by participant, model, and escrow.
+- Ghost burns by reason.
+- Capability no-send by model and participant.
+- PoC unavailable host ghost burns.
+- No available host / all hosts excluded rates.
+- Current quarantine state by participant and model.
+- Quarantine transitions by reason.
+
+### Row 7: Participant Quality
+
+Purpose: make bad or suspicious addresses obvious.
+
+Default table dimensions: `participant_key`, `model`.
+
+Do not include `escrow_id` in the default participant quality table. Escrow views
+belong in the heatmaps and localized diagnostics, where the question is whether a
+specific escrow has routing, slot, or timeout problems.
+
+Columns:
+
+| Column | Meaning |
+| --- | --- |
+| sent attempts | Real communications sent upstream. |
+| success rate | `success / sent attempts`. |
+| hidden failure rate | Hidden failures on successful user requests. |
+| no receipt rate | `reason=no_receipt`. |
+| empty stream rate | `reason=empty_stream`. |
+| transport error rate | Transport and EOF reasons. |
+| timeout action rate | Timeout expected/started/completed/skipped/failed. |
+| p95 receipt | Receipt latency. |
+| p95 user-visible TTFT | Time until users see first content from this participant. |
+| p95 first content | Attempt first-content latency. |
+| p95 prefill after receipt | Time from receipt to first content. |
+| p95 total | Total attempt latency. |
+| decode tokens/s | Actual output tokens divided by decode duration, only when output tokens are known. |
+| user-visible wins | Participant outputs shown to final users. |
+| attempt wins | Winner attempts before cache/user-visible aggregation. |
+| no-winner attempts | Shadow/probation/manual suspicious sends that could not win. |
+| skipped quarantine slots | No-send slots caused by quarantine. |
+| quarantine mode | Current probe/shadow/probation/none state. |
+
+Tables should apply a minimum volume threshold, for example at least 20 sent
+attempts in the selected window, so low-sample noise does not dominate.
+
+### Row 8: Model And Escrow Heatmaps
+
+Purpose: find localized failures.
+
+Panels:
+
+- Participant x model failure heatmap by reason.
+- Participant x escrow failure heatmap by reason.
+- Model x escrow overscheduling heatmap.
+- Runtime selection skips by model and escrow.
+- Capability skips by model and participant.
+
+All escrow-specific heatmaps are diagnostic. They should explain localized
+routing, slot, or timeout problems, not replace the default participant+model
+quality view.
+
+### Row 9: Timeout Actions
+
+Purpose: understand timeout pressure and skipped/failed timeout handling.
+
+Panels:
+
+- Timeout expected vs started vs completed vs skipped vs failed.
+- Timeout kind breakdown: `refused`, `execution`, `unknown`.
+- Timeout skip reasons.
+- Timeout failures by participant and model.
+- Attempts with `not_finished` but no timeout action.
+- Executor-level insufficient vote or collection error rates, only if those
+  outcomes are structurally available.
+
+### Row 10: Diagnostic Gateway Mechanics
+
+Purpose: expose gateway behavior that changes request flow before or after
+participant execution.
+
+Panels:
+
+- Cache lifecycle events: hit, miss, stored, skipped, expired.
+- Picker queue holds, drops, chooser errors, and stopped events.
+- Stream delivery failures to the client by reason.
+- Participant strike distribution by model and mode.
+- Manual suspicion state and transitions.
+- Escalation started vs skipped by trigger and skip reason.
+- No-winner fallback wins by participant and model.
+- Upstream transport outcomes by path kind, status code, error class, and
+  quarantine action.
+
+### Row 11: Protocol Feedback
+
+Purpose: turn gateway data into protocol changes.
+
+Panels or saved queries:
+
+- Redundancy pressure by reason and model.
+- Participants that repeatedly require extra sends but avoid quarantine.
+- Quarantine threshold candidates: participants with 1, 2, and 3 strikes.
+- Timeout window candidates from receipt, first-content, and TTFT distributions.
+- Decode throughput candidates by model and input token bucket.
+- Capability gap by model.
+- Cache effectiveness and cache-induced winner attribution gaps.
+- Escrow sizing pressure from runtime skips, blocked participants, and
+  overscheduling.
+- Incentive inputs: hidden failures, no-winner sends, skipped quarantine slots,
+  timeout actions, and successful-but-protected user requests.
+
+## Performance And Data Isolation
+
+Gateway observability must never make the gateway slower or less reliable.
+
+Requirements:
+
+- Metrics are in-memory Prometheus counter/gauge/histogram updates only.
+- Do not perform synchronous disk writes for this proposal.
+- Do not add new writes to `gateway.db`, `perf.db`, or devshard session DBs.
+- Do not query functional DBs from Grafana panels.
+- Do not add locks around streaming or request forwarding for metrics.
+- Metrics must fail open. If metric recording panics or errors, the gateway path
+  must continue.
+- If a metric would create too many active series, remove labels in this order:
+  `escrow_id` from diagnostic metrics, `output_token_bucket` from decode
+  histograms, `visibility` from performance histograms, then rare reason detail
+  from histograms. Preserve `participant_key`, `model`, and `reason` on counters
+  where accountability depends on them.
+
+High-load observability data is not critical path state. Prometheus retention is
+the retention mechanism for first-pass metrics. Request capture remains a
+separate, optional forensic feature and must not feed dashboards.
+
+## Privacy And Safety
+
+- Do not expose prompts, response bodies, request captures, base64 payloads, raw
+  captured samples, private keys, or private-key environment variable names.
+- Do not use raw error text as a label. Log raw errors only for manual drilldown.
+- Do not add participant labels to public scrape targets. These metrics are for
+  trusted deployment observability.
+- Treat `participant_key` as accountability data. It is intentional in these
+  metrics, but it should stay inside authenticated observability surfaces.
+
+## Future Work
+
+The following are useful but out of scope for the first pass:
+
+- A durable lifecycle ledger for exact per-request forensic replay.
+- New admin APIs for request or participant drilldown.
+- Per-verifier timeout vote metrics after timeout code exposes structured
+  verifier outcomes.
+- Escrow rotation events, for example
+  `devshard_gateway_escrow_rotation_events_total{model,role,stage,outcome,reason}`.
+- Chain transaction metrics, for example
+  `devshard_gateway_chain_tx_total{operation,stage,outcome,code,codespace}`.
+- `X-Devshard-Error` code metrics after transport plumbing exposes response
+  headers to gateway metrics. Candidate values include `requests_disabled`,
+  `initializing`, and `not_implemented`.
+- Chain reconciliation dashboards that compare gateway-observed outcomes with
+  finalized chain state.
+- Offline protocol-analysis exports.
+- OTEL/Jaeger spans for gateway internals.
+- Loki-derived panels. Logs should remain drilldown evidence, not the primary
+  metric source.
+
+## References
+
+- Gateway routing: `devshard/cmd/devshardctl/gateway.go`
+- User request handling: `devshard/cmd/devshardctl/proxy.go`
+- Redundancy and hidden failures: `devshard/cmd/devshardctl/redundancy.go`
+- Session picker and ghost/probe behavior:
+  `devshard/cmd/devshardctl/session_picker.go`
+- Participant limiter and quarantine:
+  `devshard/cmd/devshardctl/participant_limiter.go`
+- Gateway metrics: `devshard/cmd/devshardctl/metrics.go`
+- Request accounting: `devshard/cmd/devshardctl/request_accounting.go`
+- Host performance and pairwise data:
+  `devshard/cmd/devshardctl/hostperf.go`,
+  `devshard/cmd/devshardctl/pairwise.go`
+- Transport observations: `devshard/transport/client.go`
+- Request capture: `devshard/cmd/devshardctl/request_capture.go`
+- Gateway architecture docs: `devshard/docs/proxy-architecture.md`
+- Host health docs: `devshard/docs/host-health.md`
+- Devshard observability overview: `docs/observability/observability-overview.md`
+- Existing dashboards: `deploy/join/observability/grafana/dashboards/`
diff --git a/proposals/governance-artifacts/update-v0.2.12/README.md b/proposals/governance-artifacts/update-v0.2.12/README.md
index 45b5e875c5..781f3d1d50 100644
--- a/proposals/governance-artifacts/update-v0.2.12/README.md
+++ b/proposals/governance-artifacts/update-v0.2.12/README.md
@@ -70,7 +70,7 @@ Previously, the devshard runtime lived inside the main DAPI process. Upgrading d
 To solve this, v0.2.12 decouples devshards into a standalone, versioned runtime managed by a new service called `versiond`.
 
 - `versiond` automatically downloads and runs devshard binaries approved by on-chain governance.
-- Multiple devshard versions can run side-by-side. Traffic to `/devshard/<version>/*` is routed to the corresponding binary, while the legacy `/v1/devshard/*` route remains active during the transition.
+- Multiple devshard versions can run side-by-side. Traffic to `/devshard/<version>/*` is routed to the corresponding binary.
 - The standalone devshard directly communicates with MLNodes during inference but does not manage their lifecycle, cleanly separating the roles of MLNode manager (DAPI) and client.
 - Each session is cryptographically bound to the specific binary version that served it. The settlement payload now includes a cleartext `version` field, ensuring a session cannot mix responses from different versions.
 - The term "subnet" is entirely replaced by "devshard" across the codebase. Additionally, float math in devshard settlement has been replaced with deterministic integer arithmetic to eliminate consensus-failure risks.
diff --git a/proposals/governance-artifacts/update-v0.2.13-devshard-v2/README.md b/proposals/governance-artifacts/update-v0.2.13-devshard-v2/README.md
index 2b39bb33c8..c515c2d835 100644
--- a/proposals/governance-artifacts/update-v0.2.13-devshard-v2/README.md
+++ b/proposals/governance-artifacts/update-v0.2.13-devshard-v2/README.md
@@ -18,7 +18,7 @@ The proposal registers a new entry in `DevshardEscrowParams.approved_versions`:
 
 The release publishes the `devshardd` binary as a Gonka release artifact. If the on-chain proposal is approved, `versiond` automatically downloads the binary, verifies the sha256 hash, and starts an additional `devshardd` process inside the existing `versiond` container.
 
-The new process is served under the `/devshard/v2` prefix. Existing v1 devshard traffic continues on `/devshard/v1` and `/v1/devshard`. No mainnet restart or manual host steps are expected during this type of upgrade.
+The new process is served under the `/devshard/v2` prefix. Existing v1 devshard traffic uses `/devshard/v1`. No mainnet restart or manual host steps are expected during this type of upgrade.
 
 ## Proposed Process
 
diff --git a/proposals/governance-artifacts/update-v0.2.13-devshard-v3/README.md b/proposals/governance-artifacts/update-v0.2.13-devshard-v3/README.md
new file mode 100644
index 0000000000..e397417536
--- /dev/null
+++ b/proposals/governance-artifacts/update-v0.2.13-devshard-v3/README.md
@@ -0,0 +1,56 @@
+# Upgrade Proposal: v0.2.13-devshard-v3
+
+This proposal covers the devshard v3 release.
+
+This is a devshard-only upgrade. It operates independently of full chain software upgrades. Once approved, v3 runs in parallel with the existing devshard runtimes.
+
+The v3 runtime prepares brokers to keep serving inference during the v0.2.14 chain upgrade without depending on the deprecated classic API path. It also improves RAM utilization, fixes gateway runtime behavior, and enables safe switching between SQLite and Postgres storage.
+
+## Upgrade Plan
+
+The devshard runtime is upgraded through an on-chain params proposal, not a full chain software upgrade.
+
+The proposal registers a new entry in `DevshardEscrowParams.approved_versions`:
+
+- `name`: `v3`
+- `binary`: `URL`
+- `sha256`: `SHA256`
+
+The release publishes the `devshardd` binary as a Gonka release artifact. If the on-chain proposal is approved, `versiond` automatically downloads the binary, verifies the sha256 hash, and starts an additional `devshardd` process inside the existing `versiond` container.
+
+The new process is served under the `/devshard/v3` prefix. Existing devshard traffic can continue using earlier runtime prefixes until brokers switch traffic to v3. No mainnet restart or manual host steps are expected during this type of upgrade.
+
+## Testing
+
+The devshard v3 runtime was deployed and verified first. During testing, `node` and `api` containers were stopped while devshard traffic was running; active requests were allowed to finish, and new requests were successfully created and executed through `/devshard/v3`.
+
+## Changes
+
+### devshard
+
+- Serve inference during the PoC validation phase on validation-inference-capable nodes [#1348](https://github.com/gonka-ai/gonka/pull/1348) by @qdanik, @gmorgachev.
+- Enable standalone `devshardd` to continue serving during DAPI outages using an ML-node cache [#1417](https://github.com/gonka-ai/gonka/pull/1417) by @akup.
+- Add per-escrow SQLite/Postgres storage routing and allow storage backend transitions without stopping existing sessions [#1417](https://github.com/gonka-ai/gonka/pull/1417) by @akup.
+- Snapshot `validation_rate` at escrow creation so all group members bind the same validation rate [#1417](https://github.com/gonka-ai/gonka/pull/1417) by @akup.
+- Fix a production host leak where failed session resolution left validation workers alive [#1417](https://github.com/gonka-ai/gonka/pull/1417) by @gmorgachev.
+
+### gateway
+
+- Collect gateway v3 runtime fixes, including runtime version stamping, request parameter validation, SSE handling, drain barriers, and gateway v2 cleanup [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @gmorgachev, @qdanik, @libermans, @a-kuprin.
+- Add gateway observability and Prometheus scrape configuration for runtime, session, and host diagnostics [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @gmorgachev.
+- Bound gateway runtime-build fan-out to avoid LCD 429 crash loops [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @qdanik.
+- Settle depleted escrows after in-flight requests drain and retire runtime escrows safely [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @qdanik.
+- Add MiniMax-M2.7 route support, per-model dispatch, tool-message handling, and reasoning-split support [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @qdanik.
+- Skip escrow rotation for models absent from the network and recover orphaned rotation escrows after DB persist failures [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @qdanik.
+- Validate and clamp chat-completion parameters at the gateway, including `n`, before forwarding to vLLM [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @qdanik.
+- Reassemble fragmented SSE events before race-writer content classification [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @qdanik.
+
+## Contributors (sorted alphabetically)
+
+- @a-kuprin
+- @akup
+- @d-bogdan-engenious (testing)
+- @gmorgachev
+- @libermans
+- @maria-mitina (testing)
+- @qdanik
diff --git a/proposals/governance-artifacts/update-v0.2.14/README.md b/proposals/governance-artifacts/update-v0.2.14/README.md
new file mode 100644
index 0000000000..6578df8050
--- /dev/null
+++ b/proposals/governance-artifacts/update-v0.2.14/README.md
@@ -0,0 +1,69 @@
+# Upgrade Proposal: v0.2.14
+
+This PR prepares the v0.2.14 release.
+
+The mainnet chain/API work focuses on PoC duplicate-artifact protection, early share detection, classic inference API deprecation (disabling `/v1/chat/completions` billing on mainnet and removing embedded `/v1/devshard` from the API binary), reward recipient routing, and upgrade-time safety fixes.
+
+The devshard part prepares the v3 runtime so brokers can serve inference during the chain upgrade without depending on the deprecated classic API path, improving RAM utilization and enabling safe switching between SQLite and Postgres storage.
+
+## Upgrade Plan
+
+The node binary is upgraded through an on-chain software upgrade proposal. Existing hosts are not required to manually update their `api` or `node` containers as part of the upgrade.
+
+A separate devshard v3 release from this branch will be proposed and rolled out before the mainnet chain upgrade. Brokers who switch inference traffic to `/devshard/v3` ahead of time can keep serving inference while the chain upgrade runs.
+
+## Proposed Process
+
+1. Active hosts review this proposal on GitHub.
+2. The devshard v3 release is proposed and rolled out before the mainnet chain upgrade.
+3. Brokers switch inference traffic to `/devshard/v3`.
+4. If the on-chain proposal is approved, this PR will be merged immediately after the upgrade is executed on-chain.
+
+## Changes
+
+### inference-chain / decentralized-api
+
+- Replace the PoC artifact store with SMST-based nonce indexing to prevent duplicate artifacts, with benchmarks, params, and snapshot rebuild fixes [`9a63468`](https://github.com/gonka-ai/gonka/commit/9a6346862e9b365db7994cfa2f07aa81a2a5f958), [`22a21b0`](https://github.com/gonka-ai/gonka/commit/22a21b0b6d893200af0a88f5bb551d238c64f556) by @gmorgachev, @DimaOrekhovPS, @0xMayoor.
+- Add DAPI-side early-share detection as an additional security layer, later reworked to check inclusion by nonce instead of dense index so it stays correct against the SMST store [#1382](https://github.com/gonka-ai/gonka/pull/1382), [#1416](https://github.com/gonka-ai/gonka/pull/1416) by @libermans, @DimaOrekhovPS, @gmorgachev.
+- Remove deprecated classic decentralized-api inference paths and bind devshard routes to runtime versions [#1386](https://github.com/gonka-ai/gonka/pull/1386) by @gmorgachev.
+- Track the last software upgrade height and fix disabling cPoC in the window around chain upgrades [#1268](https://github.com/gonka-ai/gonka/pull/1268) by @patimen.
+- Seed maintenance-window params in the v0.2.14 handler with maintenance disabled by default, so governance can enable it later [#998](https://github.com/gonka-ai/gonka/pull/998), [#1428](https://github.com/gonka-ai/gonka/pull/1428) by @Ryanchen911, @DimaOrekhovPS.
+- Zero mint inflation during upgrade, burn the fee collector base-denom balance, and add Dahl (@paranjko) to allowed devshard escrow creators [#1418](https://github.com/gonka-ai/gonka/pull/1418) by @gmorgachev.
+- Add on-chain configurable reward claim recipients and apply them to stale devshard escrow payouts [#889](https://github.com/gonka-ai/gonka/pull/889), [#1377](https://github.com/gonka-ai/gonka/pull/1377) by @alancapex, @DimaOrekhovPS.
+- Prevent reward payments for incoming delegations from excluded hosts [#1378](https://github.com/gonka-ai/gonka/pull/1378) by @gmorgachev.
+- Add a total supply endpoint for integrations that need plain-text GONKA supply [#1346](https://github.com/gonka-ai/gonka/pull/1346) by @DimaOrekhovPS.
+- Sync bridge block progress so Ethereum transactions are not lost if nodes restart during upgrade [#1376](https://github.com/gonka-ai/gonka/pull/1376) by @GLiberman.
+- Smaller settlement, validation, fee, and setup-report fixes: [#1100](https://github.com/gonka-ai/gonka/pull/1100), [#1101](https://github.com/gonka-ai/gonka/pull/1101), [#1129](https://github.com/gonka-ai/gonka/pull/1129), [#1160](https://github.com/gonka-ai/gonka/pull/1160), [#1253](https://github.com/gonka-ai/gonka/pull/1253), [#1255](https://github.com/gonka-ai/gonka/pull/1255), [#1278](https://github.com/gonka-ai/gonka/pull/1278), [#1307](https://github.com/gonka-ai/gonka/pull/1307), [#1383](https://github.com/gonka-ai/gonka/pull/1383), [#1413](https://github.com/gonka-ai/gonka/pull/1413) by @0xMayoor, @0xgonka, @ouicate, @redstartechno, @GLiberman, @DimaOrekhovPS.
+
+### devshard
+
+- Serve inference during the PoC validation phase on validation-inference-capable nodes [#1348](https://github.com/gonka-ai/gonka/pull/1348) by @qdanik, @gmorgachev.
+- Enable standalone `devshardd` to continue serving during DAPI outages using an ML-node cache, add per-escrow SQLite/Postgres storage routing, and snapshot `validation_rate` at escrow creation [#1417](https://github.com/gonka-ai/gonka/pull/1417) by @akup.
+- Fix a production host leak where failed session resolution left validation workers alive [#1417](https://github.com/gonka-ai/gonka/pull/1417) by @gmorgachev.
+- Collect gateway v3 fixes: runtime versioning, observability, escrow rotation, request parameter validation, SSE handling, drain barriers, and gateway v2 cleanup [#1427](https://github.com/gonka-ai/gonka/pull/1427) by @gmorgachev, @qdanik, @libermans, @a-kuprin.
+- Distribute unsettled devshard escrow by slot instead of unique address [#1347](https://github.com/gonka-ai/gonka/pull/1347) by @0xMayoor.
+
+## Testing
+
+The devshard v3 runtime was deployed and verified first. During testing, `node` and `api` containers were stopped while devshard traffic was running; active requests were allowed to finish, and new requests were successfully created and executed through `/devshard/v3`.
+
+After devshard v3 validation, the mainnet-style upgrade from `v0.2.13` to `v0.2.14` was tested.
+
+## Contributors (sorted alphabetically)
+
+- @0xgonka
+- @0xMayoor
+- @a-kuprin
+- @akup
+- @alancapex
+- @d-bogdan-engenious (testing)
+- @DimaOrekhovPS
+- @GLiberman
+- @gmorgachev
+- @libermans
+- @maria-mitina (testing)
+- @ouicate
+- @patimen
+- @qdanik
+- @redstartechno
+- @Ryanchen911
diff --git a/proposals/maintenance-windows/maintenance-windows-todo.md b/proposals/maintenance-windows/maintenance-windows-todo.md
new file mode 100644
index 0000000000..8a9213ba17
--- /dev/null
+++ b/proposals/maintenance-windows/maintenance-windows-todo.md
@@ -0,0 +1,547 @@
+# Mid-Epoch Participant Maintenance Windows - Task Plan
+
+## Prerequisite Reading
+
+Before starting implementation, please read the following documents to understand the full context of the changes:
+- The main proposal: `proposals/maintenance-windows/maintenance-windows.md`
+- The app wiring for staking/slashing ordering: `inference-chain/app/app_config.go`
+- The inference epoch transition and validator-set integration: `inference-chain/x/inference/module/module.go`
+- The collateral staking hooks: `inference-chain/x/collateral/module/hooks.go`
+- The participant model and reward flow in `x/inference`
+- The maintained Cosmos SDK fork branch: `https://github.com/gonka-ai/cosmos-sdk/tree/release/v0.53.x`
+
+## How to Use This Task List
+
+### Workflow
+- **Focus on a single task**: Please work on only one task at a time to ensure clarity and quality. Avoid implementing parts of future tasks.
+- **Request a review**: Once a task's implementation is complete, change its status to `[?] - Review` and wait for confirmation.
+- **Update all usages**: If a function, proto field, or type is renamed, find and update all references throughout the codebase.
+- **Build after each task**: After each task is completed, build the project to ensure there are no compilation errors.
+- **Test after each section**: After completing all tasks in a section, run the corresponding tests to verify the functionality.
+- **Wait for completion**: After review is confirmed, mark the task as `[x] - Finished`, add a **Result** section summarizing the changes, and then move on to the next one.
+
+### Build & Test Commands
+- **Build Inference Chain**: From the project root, run `make node-local-build`
+- **Build API Node**: From the project root, run `make api-local-build`
+- **Run Inference Chain Unit Tests**: From the project root, run `make node-test`
+- **Run API Node Unit Tests**: From the project root, run `make api-test`
+- **Generate Proto Go Code**: When modifying proto files, run `ignite generate proto-go` in the `inference-chain` folder
+- **Cosmos SDK Fork Tests**: Run targeted tests in the maintained Cosmos SDK fork for `x/slashing` and any touched staking/liveness code
+
+### Status Indicators
+- `[ ]` **Not Started** - Task has not been initiated
+- `[~]` **In Progress** - Task is currently being worked on
+- `[?]` **Review** - Task completed, requires review/testing
+- `[x]` **Finished** - Task completed and verified
+
+### Task Organization
+Tasks are organized by implementation area and numbered for easy reference. Dependencies are noted where critical. Complete tasks in order unless a task explicitly says it can be done in parallel.
+
+### Task Format
+Each task includes:
+- **What**: Clear description of work to be done
+- **Where**: Specific files/locations to modify
+- **Why**: Brief context of purpose when not obvious
+
+## Task List
+
+### Section 1: Maintenance Data Model and API Surface
+
+#### 1.1 Define Maintenance Proto Messages and Queries
+- **Task**: [?] Add maintenance-window message and query definitions
+- **What**:
+  - Define the message(s) and query surface for maintenance windows:
+    - `MsgScheduleMaintenance`
+    - `MsgCancelMaintenance`
+    - Query for current maintenance credit
+    - Query for scheduled maintenance windows
+    - Query for active maintenance windows
+    - Query for participant maintenance status
+    - Query for scheduling availability (`could I schedule this window now?`)
+  - Define request/response types with participant terminology
+  - Keep scheduling-availability query explicit so operators can preflight concurrency before sending a tx
+- **Where**:
+  - `inference-chain/proto/inference/inference/tx.proto`
+  - `inference-chain/proto/inference/inference/query.proto`
+  - Generated Go files under `inference-chain/x/inference/types/`
+- **Why**: The feature needs a first-class protocol API before keeper logic or testing can be implemented
+- **Dependencies**: None
+
+#### 1.2 Add Maintenance State Types
+- **Task**: [?] Define maintenance reservation state and per-participant `MaintenanceState`
+- **What**:
+  - Add a `MaintenanceReservation` state type with:
+    - reservation ID
+    - participant
+    - start height
+    - duration
+    - created by
+    - reservation status
+    - optional advisory activation-time warning / violation metadata
+  - Add a dedicated per-participant `MaintenanceState`, keyed by participant address, containing at least:
+    - maintenance credit in blocks
+    - last epoch in which maintenance was activated
+    - currently active reservation ID, if any
+    - next scheduled reservation ID, if any
+  - Add a dedicated transition schedule keyed by exact block height, storing:
+    - block height
+    - reservation ID
+    - transition type
+  - Add a dedicated scheduling-overlap index keyed by reservation start height
+  - Ensure all participants begin with zero credit from feature introduction onward
+  - Add validation helpers and enums/status constants as needed
+- **Where**:
+  - `inference-chain/proto/inference/inference/*.proto`
+  - `inference-chain/x/inference/types/`
+  - `inference-chain/x/inference/keeper/`
+- **Why**: The updated proposal now prefers a dedicated maintenance state object, separate from the hot participant object, while avoiding multiple fragmented per-participant maintenance buckets
+- **Dependencies**: 1.1
+
+#### 1.3 Add Governance Parameters
+- **Task**: [?] Introduce maintenance parameter group inside global inference params
+- **What**:
+  - Add a maintenance parameter group to global params with at least:
+    - enable/disable flag
+    - minimum schedule lead blocks
+    - max single window blocks
+    - max concurrent participants
+    - max concurrent power
+    - credit cap
+    - credit earned per successful epoch
+  - Add validation, defaults, and governance update support
+- **Where**:
+  - `inference-chain/proto/inference/inference/params.proto`
+  - `inference-chain/x/inference/types/params.go`
+  - `inference-chain/x/inference/keeper/params*.go`
+  - Any upgrade/default-genesis paths required
+- **Why**: Nearly every policy decision in the proposal is governance-controlled
+- **Dependencies**: 1.2
+
+#### 1.4 Add Keeper Storage for Reservations
+- **Task**: [?] Implement maintenance reservation persistence and indexes
+- **What**:
+  - Add keeper state for:
+    - reservation primary storage by reservation ID
+    - per-participant `MaintenanceState`
+    - exact-height transition schedule for `BeginBlock` lifecycle execution only
+    - reservation start-height overlap index for scheduling-time range scans only
+  - Use direct keyed Cosmos SDK collections lookups for all primary access paths
+  - Do not rely on broad iteration over reservations or unrelated participant state in `BeginBlock`
+  - Be explicit about the intended storage shape. Target layout:
+    - `Map[reservation_id] -> MaintenanceReservation`
+    - `Map[participant_address] -> MaintenanceState`
+    - `Map[(block_height, reservation_id)] -> transition_type`
+    - `Map[(start_height, reservation_id)] -> reservation_id` or equivalent start-height index entry for bounded overlap checks
+  - Keep pruning out of the first implementation, but structure storage so pruning can be added later
+- **Where**:
+  - `inference-chain/x/inference/keeper/`
+  - `inference-chain/x/inference/types/keys.go` or collections schema files
+- **Why**: Fast lookup is required both in slashing-path checks and in assignment suppression logic
+- **Dependencies**: 1.2
+
+#### 1.5 Add Reservation Lifecycle State Machine
+- **Task**: [?] Implement reservation lifecycle transitions in `BeginBlock`
+- **What**:
+  - Add a maintenance lifecycle state machine that transitions:
+    - `Scheduled -> Active` when `block_height == start_height`
+    - `Active -> Completed` when `block_height == start_height + duration_blocks`
+  - Ensure lifecycle transitions happen in a deterministic block-driven path
+  - Implement the exact `BeginBlock` access pattern:
+    - one lookup for transition rows at the exact current block height
+    - iterate only the rows returned for that exact height
+    - one direct reservation lookup per returned row
+    - apply transition
+    - update the participant's `MaintenanceState` active/scheduled reservation references as needed
+    - delete consumed transition row
+  - Do not use `<= current_height` scans or any inequality-based reservation search in the critical path
+- **Where**:
+  - `inference-chain/x/inference/module/`
+  - `inference-chain/x/inference/keeper/`
+  - App/module wiring as needed
+- **Why**: The proposal now explicitly requires a block-driven lifecycle owner; status changes cannot be implicit
+- **Dependencies**: 1.4
+
+### Section 2: Scheduling and Credit Logic
+
+#### 2.1 Implement Scheduling Validation
+- **Task**: [?] Implement `MsgScheduleMaintenance` validation and execution
+- **What**:
+  - Validate:
+    - caller is participant or AuthZ delegate
+    - sufficient lead time
+    - duration within limits
+    - enough maintenance credit
+    - participant has no other future scheduled maintenance window already recorded in `MaintenanceState`
+    - no overlap for same participant
+    - concurrency limits satisfied at scheduling time
+    - no overlap with restricted PoC commit / exchange phase
+    - no overlap with restricted DKG phase
+  - Deduct reserved maintenance credit when the reservation is accepted
+  - Persist the reservation in scheduled state
+  - Persist the participant's `next_scheduled_reservation_id`
+  - Add the exact start-height and exact transition-height index entries required for later lookups
+- **Where**:
+  - `inference-chain/x/inference/keeper/msg_server*.go`
+  - New maintenance-specific keeper files
+- **Why**: Scheduling is the main user action and the point where concurrency policy is enforced
+- **Dependencies**: 1.4
+
+#### 2.2 Implement Cancellation Logic
+- **Task**: [?] Implement `MsgCancelMaintenance`
+- **What**:
+  - Allow cancellation only while reservation is still scheduled
+  - Restore unspent maintenance credit
+  - Enforce AuthZ / participant authorization
+  - Emit clear events/logs
+- **Where**:
+  - `inference-chain/x/inference/keeper/msg_server*.go`
+  - New maintenance-specific keeper files
+- **Why**: Cancellation is part of the agreed feature semantics
+- **Dependencies**: 2.1
+
+#### 2.3 Implement Scheduling-Availability Query
+- **Task**: [?] Add preflight schedulability query
+- **What**:
+  - Add a query that takes proposed participant, start height, and duration
+  - Return whether the window is schedulable under current rules
+  - Include enough detail to tell the caller why it would fail:
+    - insufficient credit
+    - lead time failure
+    - participant already has a scheduled maintenance window
+    - overlap
+    - concurrent participant cap
+    - concurrent power cap
+  - Use the same scheduling-time concurrency logic as `MsgScheduleMaintenance`
+  - Include epoch-phase conflict answers for PoC commit / exchange and DKG overlap
+- **Where**:
+  - `inference-chain/x/inference/keeper/grpc_query*.go`
+  - `inference-chain/proto/inference/inference/query.proto`
+- **Why**: The proposal explicitly calls out avoiding wasted gas and failed tx construction
+- **Dependencies**: 2.1
+
+#### 2.4 Implement Credit Earning in Reward Claim Flow
+- **Task**: [?] Grant maintenance credit during successful reward claim
+- **What**:
+  - Identify the reward-claim path
+  - Add maintenance-credit accrual there
+  - Use the rule: if the participant would normally receive epoch rewards and successfully claims them, also grant the configured maintenance-credit amount
+  - Do not grant maintenance credit if maintenance was activated for that participant in the claimed epoch
+  - Enforce cap
+  - Make sure no retroactive credit is minted
+- **Where**:
+  - Reward claim / settlement logic under `inference-chain/x/inference/keeper/`
+  - Maintenance credit / maintenance epoch-usage persistence logic
+- **Why**: The proposal resolves credit earning as part of reward claim rather than a separate epoch transition pass
+- **Dependencies**: 1.3
+
+#### 2.5 Mark Maintenance Usage Per Epoch
+- **Task**: [?] Record maintenance activation usage for the current epoch
+- **What**:
+  - When a reservation transitions to active, mark that the participant used maintenance in that epoch
+  - Ensure the reward-claim path can check this cheaply
+  - Keep the state layout minimal and directly keyed
+- **Where**:
+  - `inference-chain/x/inference/keeper/`
+  - Lifecycle transition path in module begin block
+- **Why**: Credit suppression for maintenance-used epochs depends on a deterministic epoch-usage marker
+- **Dependencies**: 1.5
+
+#### 2.6 Implement Bounded Overlap Search
+- **Task**: [?] Implement bounded scheduling-overlap lookup
+- **What**:
+  - Use the reservation start-height overlap index, not the `BeginBlock` transition schedule
+  - Use the `max_window_blocks` parameter to bound overlap search
+  - For a candidate interval `[start, end]`, range-scan only reservation start heights in the bounded interval needed to detect overlaps
+  - Confirm actual overlap by reading the referenced reservations and comparing computed end heights
+  - Do not perform an unbounded full-state scan for scheduling checks
+- **Where**:
+  - `inference-chain/x/inference/keeper/`
+  - Scheduling validation and scheduling-availability query paths
+- **Why**: Scheduling is not as latency-sensitive as `BeginBlock`, but overlap checks still need an explicit bounded strategy rather than hand-wavy iteration
+- **Dependencies**: 1.4
+
+### Section 3: Consensus Liveness Exemption in Cosmos SDK Fork
+
+#### 3.1 Patch Slashing Liveness Path
+- **Task**: [?] Add maintenance-aware liveness exemption to the maintained Cosmos SDK fork
+- **What**:
+  - Identify the exact liveness handling path in the forked `x/slashing`
+  - Add a maintenance-window check so active maintenance:
+    - freezes missed-signature accounting
+    - prevents downtime jailing
+    - prevents downtime slashing
+  - Leave double-sign and evidence handling unchanged
+- **Where**:
+  - Maintained Cosmos SDK fork branch `release/v0.53.x`
+  - Likely `x/slashing/abci.go` and/or `x/slashing/keeper/infractions.go`
+- **Why**: Hook-only logic is not sufficient; protocol-level liveness enforcement must be patched directly
+- **Dependencies**: 1.4
+
+#### 3.2 Wire Maintenance State into Slashing Checks
+- **Task**: [?] Define the lookup boundary from SDK liveness code into chain maintenance state
+- **What**:
+  - Decide and implement how the slashing path checks whether a participant is in active maintenance
+  - Keep the lookup deterministic and cheap enough for begin-block usage
+  - Ensure height-based semantics match the proposal exactly
+  - Ensure the lookup path is direct-key based and does not require iteration
+- **Where**:
+  - Maintained Cosmos SDK fork
+  - Inference-chain app wiring if interfaces or keeper plumbing are required
+- **Why**: The maintenance exemption must be visible from the liveness path without ambiguous state access
+- **Dependencies**: 3.1
+
+#### 3.3 Add Defensive Hook Guards
+- **Task**: [?] Update collateral/staking-hook logic as defense in depth
+- **What**:
+  - Add secondary protection so maintenance-covered participants do not get collateral-side downtime fallout if slashing-related hooks fire unexpectedly
+  - Document clearly that this is secondary protection, not the primary enforcement mechanism
+- **Where**:
+  - `inference-chain/x/collateral/module/hooks.go`
+  - Related collateral keeper logic if needed
+- **Why**: The proposal explicitly calls out hooks as defense in depth
+- **Dependencies**: 3.1
+
+#### 3.4 Add Activation-Time Advisory Re-Check
+- **Task**: [?] Re-check concurrency caps at activation time and persist advisory warnings
+- **What**:
+  - During `Scheduled -> Active` transition, re-check concurrent participant count and power against current params
+  - If current caps would now reject the reservation:
+    - activate anyway
+    - emit warning event/log
+    - persist advisory warning / violation metadata on the reservation for queries
+  - Do not hard-cancel at activation time
+  - Update `MaintenanceState` so the active reservation reference is set even when activation carries an advisory warning
+- **Where**:
+  - `inference-chain/x/inference/module/`
+  - `inference-chain/x/inference/keeper/`
+  - Query/event paths as needed
+- **Why**: The proposal now grandfather-scheduled windows while still surfacing governance drift at activation time
+- **Dependencies**: 1.5
+
+### Section 4: Inference-Chain Duty Exemptions
+
+#### 4.1 Suppress Random Inference Assignment
+- **Task**: [?] Remove active-maintenance participants from new random assignment
+- **What**:
+  - Identify the assignment path(s) for new inference work
+  - Exclude participants with active maintenance from random assignment immediately at window start
+  - Keep participants in epoch groups; do not mutate epoch membership
+- **Where**:
+  - `inference-chain/x/inference/module/`
+  - `inference-chain/x/inference/keeper/`
+- **Why**: The proposal requires immediate assignment exclusion without epoch-group removal
+- **Dependencies**: 2.1
+
+#### 4.1a Enforce Epoch-Critical Phase Scheduling Rejections
+- **Task**: [?] Reject maintenance windows that overlap PoC commit / exchange or DKG phases
+- **What**:
+  - Compute overlap against the current scheduling target epoch(s)
+  - Reject windows overlapping:
+    - PoC commit / exchange window
+    - DKG phase
+  - Introduce explicit scheduling errors for both cases
+- **Where**:
+  - `inference-chain/x/inference/keeper/`
+  - Maintenance scheduling validation logic
+- **Why**: These overlaps can silently break next-epoch participation or next-epoch start safety
+- **Dependencies**: 2.1
+
+#### 4.2 Waive Maintenance-Covered Inference Penalties
+- **Task**: [?] Suppress downtime and expiry penalties during active maintenance
+- **What**:
+  - Identify downtime and expiry penalty paths
+  - Add maintenance checks so active windows waive these penalties
+  - Keep existing semantics once maintenance ends
+  - Be explicit about the still-open question of in-flight inference treatment
+- **Where**:
+  - `inference-chain/x/inference/keeper/`
+  - `inference-chain/x/inference/module/inference_expiry*.go`
+  - Related participant status / collateral integration files
+- **Why**: Penalty exemption is a core part of the feature promise
+- **Dependencies**: 2.1
+
+#### 4.3 Suppress Validation Duties
+- **Task**: [?] Exempt active-maintenance participants from validation duties
+- **What**:
+  - Identify where validation obligations are assigned or enforced
+  - Exclude maintenance-covered participants from validation duty expectations
+  - Ensure no follow-on penalties are applied due solely to maintenance-covered absence
+- **Where**:
+  - `inference-chain/app/ante_validation.go`
+  - `inference-chain/x/inference/module/`
+  - `inference-chain/x/inference/keeper/`
+- **Why**: The proposal now explicitly includes validation-duty exemption
+- **Dependencies**: 4.2
+
+#### 4.4 Suppress Confirmation PoC Duties
+- **Task**: [?] Exempt active-maintenance participants from CPoC duties
+- **What**:
+  - Identify where Confirmation PoC participation is expected and where its penalties or qualification logic are applied
+  - Exclude maintenance-covered participants from CPoC expectations during active windows
+  - Ensure maintenance does not accidentally create false CPoC failures
+- **Where**:
+  - `inference-chain/x/inference/module/confirmation_poc.go`
+  - Related CPoC keeper/module code
+- **Why**: This was added explicitly during proposal review and must be included from the beginning
+- **Dependencies**: 4.2
+
+### Section 5: Queries, Events, and Observability
+
+#### 5.1 Implement Maintenance Queries
+- **Task**: [?] Implement all agreed query endpoints
+- **What**:
+  - Current credit
+  - Scheduled windows
+  - Active windows
+  - Participant maintenance status
+  - Concurrent reserved participant count/power
+  - Scheduling availability
+  - Reservation advisory activation-time warning / violation status
+  - Consider whether participant maintenance status should surface the current active reservation ID and next scheduled reservation ID directly from `MaintenanceState`
+- **Where**:
+  - `inference-chain/x/inference/keeper/grpc_query*.go`
+  - Proto-generated query files
+- **Why**: The proposal relies on these queries for operator usability and debugging
+- **Dependencies**: Section 2
+
+#### 5.2 Add Events and Structured Logs
+- **Task**: [?] Add maintenance-specific logging and events
+- **What**:
+  - Emit logs/events for schedule, cancel, activate, complete
+  - Emit logs/events for liveness exemption application and duty suppression
+  - Emit logs/events for activation-time concurrency warnings
+  - Use the repo’s standard logging style
+- **Where**:
+  - `inference-chain/x/inference/keeper/`
+  - `inference-chain/x/inference/module/`
+  - Cosmos SDK fork if slashing-side logs are added
+- **Why**: Maintenance behavior needs to be observable during development and production operations
+- **Dependencies**: Section 4
+
+### Section 6: Upgrade and Genesis Handling
+
+#### 6.1 Add Upgrade Path for Maintenance Credit State and Params
+- **Task**: [?] Add upgrade handling for maintenance feature introduction
+- **What**:
+  - Initialize maintenance credit to zero for all existing participants
+  - Add new parameters with defaults
+  - Initialize maintenance epoch-usage state as empty
+  - Ensure feature introduction is clean for existing chains
+- **Where**:
+  - `inference-chain/app/upgrades*.go`
+  - Any migration or default-genesis code required
+- **Why**: The proposal explicitly says participants start at zero and only earn credit after feature introduction
+- **Dependencies**: 1.3
+
+#### 6.2 Verify Genesis / Export Behavior
+- **Task**: [?] Verify maintenance state exports and imports cleanly
+- **What**:
+  - Add reservation export/import if required
+  - Verify `MaintenanceState` is included correctly
+  - Confirm no unexpected interaction with existing export/reset logic
+- **Where**:
+  - `inference-chain/app/export.go`
+  - `inference-chain/x/inference/module/genesis.go`
+  - Related genesis files
+- **Why**: New state should survive export/import and testnet resets predictably
+- **Dependencies**: 6.1
+
+### Section 7: Testing
+
+#### 7.1 Unit Tests for Maintenance Scheduling and Credit
+- **Task**: [?] Add unit tests for maintenance keeper and message flows
+- **What**:
+  - Schedule success/failure cases
+  - Cancel success/failure cases
+  - Credit cap and deduction behavior
+  - Reward-claim credit accrual behavior
+  - No credit accrual in maintenance-used epochs
+  - Scheduling-availability query correctness
+  - Concurrency cap behavior by participant count and power
+  - Reservation advisory warning persistence
+  - Restricted PoC / DKG overlap rejection
+- **Where**:
+  - `inference-chain/x/inference/keeper/*test.go`
+- **Why**: Core logic needs strong unit-level confidence before E2E work
+- **Dependencies**: Sections 1-2
+
+#### 7.2 Unit Tests for Duty Exemptions
+- **Task**: [?] Add unit tests for assignment and penalty suppression
+- **What**:
+  - No new inference assignment during active maintenance
+  - No downtime/expiry penalty during active maintenance
+  - Validation-duty exemption
+  - CPoC-duty exemption
+  - Resume behavior immediately after window ends
+- **Where**:
+  - `inference-chain/x/inference/module/*test.go`
+  - `inference-chain/x/inference/keeper/*test.go`
+- **Why**: These behaviors are central user-facing guarantees
+- **Dependencies**: Section 4
+
+#### 7.3 Cosmos SDK Fork Tests
+- **Task**: [?] Add targeted tests in forked slashing/liveness code
+- **What**:
+  - Maintenance active: misses do not count
+  - Maintenance active: no downtime jail/slash
+  - Maintenance inactive: normal liveness enforcement still works
+  - Double-sign/evidence paths unaffected
+  - Resume behavior after maintenance end
+  - Activation-time advisory warning path does not affect liveness exemption correctness
+- **Where**:
+  - Maintained Cosmos SDK fork under `x/slashing/...`
+- **Why**: The most safety-critical change is in the protocol liveness path
+- **Dependencies**: Section 3
+
+#### 7.4 Testermint End-to-End Coverage
+- **Task**: [?] Add end-to-end maintenance-window tests in Testermint
+- **What**:
+  - Schedule a maintenance window
+  - Pause participant execution for the covered interval
+  - Verify:
+    - no jail during maintenance
+    - no maintenance-covered assignments/duties
+    - no maintenance-covered penalties
+    - normal behavior resumes after maintenance ends
+  - Include at least one test touching validation/CPoC expectations
+  - Include coverage that maintenance cannot be scheduled across restricted PoC / DKG phases
+- **Where**:
+  - `testermint/`
+  - Any orchestration scripts needed to pause participant execution cleanly
+- **Why**: The proposal explicitly calls out end-to-end testing as a major implementation risk and a requirement for confidence
+- **Dependencies**: Sections 3-4
+
+### Section 8: Deferred / Follow-Up Items
+
+#### 8.1 In-Flight Inference Semantics
+- **Task**: [?] Define and implement treatment of in-flight inferences
+- **What**:
+  - Decide whether maintenance start cancels in-flight work, allows grace handling, or uses a hybrid rule
+  - Update proposal and implementation accordingly
+- **Where**:
+  - Proposal document
+  - Inference assignment / expiry / execution code
+- **Why**: This remains an explicit open issue in the proposal
+- **Dependencies**: Section 4
+
+#### 8.2 Subnet Interaction Design
+- **Task**: [?] Specify how maintenance windows interact with subnets
+- **What**:
+  - Review subnet-specific duties and assumptions as that feature develops
+  - Decide whether maintenance affects subnet scheduling, duties, or settlement logic
+  - Update proposal and implementation plan when subnet semantics are clearer
+- **Where**:
+  - Proposal document
+  - Subnet-related code under `inference-chain/x/inference/keeper/`
+- **Why**: The proposal explicitly leaves subnet interaction open
+- **Dependencies**: None
+
+#### 8.3 Reservation Pruning
+- **Task**: [?] Add pruning for completed/canceled maintenance reservations
+- **What**:
+  - Add retention and pruning strategy for historical reservations
+  - Keep this out of the critical path unless state growth becomes noticeable
+- **Where**:
+  - Maintenance keeper state management
+- **Why**: Nice-to-have follow-up item, not required for the first version
+- **Dependencies**: Section 1
diff --git a/proposals/maintenance-windows/maintenance-windows.md b/proposals/maintenance-windows/maintenance-windows.md
new file mode 100644
index 0000000000..b71eb6beb6
--- /dev/null
+++ b/proposals/maintenance-windows/maintenance-windows.md
@@ -0,0 +1,562 @@
+# Mid-Epoch Participant Maintenance Windows
+
+## Overview
+
+This proposal introduces scheduled, block-height-based maintenance windows for participants. A maintenance window allows a participant to temporarily go offline mid-epoch without being penalized for downtime and without being expected to perform protocol or application-layer duties.
+
+The goal is to support real operational maintenance on participant infrastructure without forcing operators to miss an entire epoch or rely on ad hoc downtime tolerance in liveness windows.
+
+This proposal is intentionally designed as an exemption mechanism, not as a consensus-set membership churn mechanism. During maintenance, the participant remains part of the epoch structure, but liveness accounting and application duties are temporarily suspended for the scheduled interval.
+
+---
+
+## Motivation
+
+Gonka epochs are long-lived, typically on the order of a day. That creates a practical problem for operators who need short maintenance windows on underlying machines. Typical maintenance tasks such as host reboots, kernel upgrades, disk work, hypervisor work, or planned networking changes often require downtime measured in minutes, not in whole epochs.
+
+Without a mid-epoch maintenance feature, an operator currently has only bad options:
+
+1. Stay online and defer necessary maintenance.
+2. Go offline and risk protocol-level liveness penalties and application-level penalties.
+3. Sit out an entire epoch, which is far too coarse for a 10-20 minute operational task.
+
+The desired system should let participants schedule brief maintenance windows, go offline for that period, and return without being marked down for that scheduled downtime.
+
+---
+
+## Goals
+
+1. Allow participants to schedule short maintenance windows inside an epoch.
+2. Exempt scheduled maintenance from consensus downtime penalties.
+3. Exempt scheduled maintenance from application-layer duties and penalties.
+4. Preserve participant participation in epoch structure without removing the participant from epoch groups.
+5. Bound safety risk by limiting concurrent maintenance windows through governance-controlled parameters.
+6. Make all important operational policy knobs configurable by governance.
+
+---
+
+## Non-Goals
+
+1. This proposal does not relax double-sign or evidence enforcement.
+2. This proposal does not introduce a new admin-operated emergency pause mechanism.
+3. This proposal does not attempt to redesign epoch formation or PoC scheduling.
+4. This proposal does not require a new end-user UX beyond chain messages and queries.
+5. This proposal does not, in this first version, solve analytics/reporting beyond normal logs and query endpoints.
+
+---
+
+## High-Level Design
+
+The chain introduces scheduled maintenance reservations keyed by participant and block height range.
+
+Reservation lifecycle is block-driven and materialized on-chain. Reservations transition through the following statuses:
+
+1. Scheduled
+2. Active
+3. Completed
+4. Canceled
+
+The lifecycle transitions are driven by a maintenance state machine in `BeginBlock`:
+
+1. `Scheduled -> Active` when `block_height == start_height`
+2. `Active -> Completed` when `block_height == start_height + duration_blocks`
+
+The equality semantics are important. `BeginBlock` should process only transitions scheduled for the exact current block height. It should not scan for `<= current_height` or any other broader range.
+
+The proposal requires the following performance properties:
+
+1. `BeginBlock` must use exact-height transition lookup, not inequality scans.
+2. `BeginBlock` must not rely on broad iteration over unrelated participant or reservation state.
+3. The lifecycle path must be bounded by the number of transitions scheduled for the exact current height.
+
+When a participant enters an active maintenance window:
+
+1. Consensus liveness accounting is frozen for that participant.
+2. Downtime-related jailing/slashing from missed signatures is not triggered for that participant during the active window.
+3. The participant remains in epoch groups and is not removed from epoch structure.
+4. The participant stops receiving new inference assignments immediately.
+5. Application-layer penalties related to being unavailable are waived for the duration of the window.
+6. When the window ends, normal liveness accounting and application duties resume immediately.
+
+This design keeps the consensus set stable and avoids repeated mid-epoch removal and re-addition of participants for very short operational windows.
+
+---
+
+## User-Facing Semantics
+
+### What Maintenance Exempts
+
+During an active maintenance window, the participant is exempt from:
+
+1. Consensus downtime penalties derived from missed signatures.
+2. Application-layer service duties.
+3. Application-layer downtime and expiry penalties related to being unavailable.
+4. Random inference assignment.
+5. Confirmation PoC duties.
+6. Validation duties.
+
+### What Maintenance Does Not Exempt
+
+During an active maintenance window, the participant is still subject to:
+
+1. Double-sign enforcement.
+2. Evidence-based enforcement.
+3. Any non-downtime protocol rule unrelated to scheduled maintenance.
+
+### Rewards and Credit During Maintenance
+
+Maintenance does not pause ordinary reward eligibility. Participants may continue to receive the rewards they would otherwise receive under the protocol.
+
+However, maintenance-credit earning is paused for any epoch in which a maintenance window was activated for that participant.
+
+This means:
+
+1. A participant may still claim ordinary rewards for a maintenance-used epoch if otherwise eligible.
+2. A participant does not earn new maintenance credit for that epoch.
+
+This rule ensures that every use of maintenance has a net credit cost and prevents small repeated windows from becoming self-replenishing.
+
+---
+
+## Scheduling Semantics
+
+Maintenance windows are block-height-based.
+
+Each reservation specifies:
+
+1. Participant identity.
+2. Start block height.
+3. Duration in blocks.
+
+The window becomes active exactly at `start_height` and remains active through `start_height + duration_blocks - 1`.
+
+Maintenance windows:
+
+1. Must be scheduled sufficiently far in advance, according to a governance-controlled lead-time parameter.
+2. May be canceled before activation.
+3. May not be extended once active.
+4. Are bounded by a governance-controlled maximum duration.
+5. Must not overlap the epoch-critical PoC commit / exchange phase.
+6. Must not overlap the epoch-critical DKG phase.
+7. A participant may have at most one future scheduled maintenance window at a time.
+
+If a participant is already down, marked down, or jailed before the window begins, scheduling maintenance does not repair or alter that status. The maintenance reservation exists, but it does not undo existing protocol state.
+
+### Epoch-Critical Phase Restrictions
+
+The first version explicitly rejects maintenance windows that overlap the following critical ranges:
+
+1. PoC commit / exchange window
+2. DKG phase
+
+The rationale is operational and safety-oriented:
+
+1. A participant in maintenance during the PoC commit window can fail to submit the PoC data required for next-epoch inclusion.
+2. A participant in maintenance during DKG can create next-epoch start failures, because DKG currently has no recovery path.
+
+Suggested scheduling errors:
+
+1. `ErrMaintenanceOverlapsPoCPhase`
+2. `ErrMaintenanceOverlapsDKGPhase`
+
+---
+
+## Credit Model
+
+Maintenance credit is measured in blocks.
+
+Participants accumulate maintenance credit over time and spend that credit when scheduling a maintenance window. Credit policy is governance-controlled.
+
+This proposal assumes:
+
+1. Credit is capped.
+2. Credit is earned per successful epoch, unless maintenance was activated in that epoch.
+3. The earn amount per successful epoch is parameterized.
+4. The maximum stored credit is parameterized.
+
+For this proposal, a successful epoch is defined as an epoch for which the participant would normally receive epoch rewards.
+
+Maintenance credit should be granted in the reward-claim flow for that epoch. In other words, when a participant successfully claims normal epoch rewards, the participant also receives the configured maintenance-credit allotment for that epoch, unless the participant used maintenance in that epoch.
+
+All participants begin with zero maintenance credit when the feature is introduced. No retroactive credit is granted for epochs completed before the feature exists.
+
+The implementation should track whether maintenance was activated for the participant in the relevant epoch and suppress credit accrual accordingly.
+
+---
+
+## Concurrency and Safety Limits
+
+Concurrent maintenance must be limited so that the network does not lose too much active availability at once.
+
+This proposal includes two independent governance-controlled caps:
+
+1. A cap on the number of participants concurrently in maintenance.
+2. A cap on the total consensus power concurrently in maintenance.
+
+Both caps must be satisfied for a new reservation to be accepted.
+
+The count cap improves operator predictability and scheduling simplicity.
+
+The power cap protects network safety and avoids a situation where a small number of large participants consume too much concurrent maintenance budget.
+
+This proposal does not introduce a separate degraded-mode or outage-mode scheduler.
+
+---
+
+## Protocol-Level Changes
+
+### Consensus Liveness Exemption
+
+The key protocol change is in consensus downtime accounting.
+
+When a participant has an active maintenance window at the current block height:
+
+1. Missed-signature liveness accounting is frozen for that participant.
+2. Missed signatures during the maintenance window do not advance missed-block counters or bitmaps.
+3. Downtime-related jailing and downtime-related slashing are not triggered from liveness handling for that participant.
+
+This exemption applies only to scheduled maintenance and only to downtime-style liveness enforcement.
+
+Double-sign and evidence paths remain unchanged.
+
+### Resume Behavior
+
+When the maintenance window ends:
+
+1. Liveness accounting resumes immediately at the next block.
+2. The participant is evaluated from its pre-maintenance liveness state, as though accounting was paused during the maintenance interval.
+3. If the participant remains offline after maintenance ends, normal markdown / missed-signature accumulation resumes and the participant must bear the consequences.
+
+---
+
+## Application-Level Changes
+
+### Immediate Assignment Exclusion
+
+At the start of a maintenance window, the participant must stop receiving new random inference assignments immediately.
+
+The participant remains in epoch groups, but assignment logic must treat the participant as temporarily unavailable for the duration of the maintenance window.
+
+The same exemption applies to other application-layer duties, including:
+
+1. Confirmation PoC duties.
+2. Validation duties.
+
+### Penalty Exemptions
+
+During an active maintenance window:
+
+1. Downtime-related application penalties are waived.
+2. Expiry-related penalties caused by participant unavailability are waived.
+3. Participant-status degradation caused solely by maintenance-covered unavailability is suppressed.
+
+### Epoch Group Membership
+
+Participants in maintenance are not removed from epoch groups and are not removed from the epoch’s structural state. The proposal intentionally keeps epoch structure stable and only changes active service expectations.
+
+---
+
+## State
+
+The chain should store, at minimum, the following maintenance-related state.
+
+### Maintenance Reservation
+
+Each reservation record should include:
+
+1. Participant identity.
+2. Start block height.
+3. Duration in blocks.
+4. Creator / scheduler identity.
+5. Reservation status.
+6. Optional advisory activation-time warning / violation metadata
+
+Suggested statuses:
+
+1. Scheduled
+2. Active
+3. Completed
+4. Canceled
+
+Reservations should be addressable by a stable primary identifier so they can be updated, queried, and referenced from transition state without ambiguity.
+
+### Maintenance State
+
+Participant maintenance metadata should be stored in a dedicated `MaintenanceState`, keyed by participant address and separate from the hot participant record itself.
+
+`MaintenanceState` should contain at least:
+
+1. Current maintenance credit in blocks
+2. Last epoch in which maintenance was activated for that participant
+3. Reference to the participant's currently active reservation, if any
+4. Reference to the participant's next scheduled reservation, if any
+
+This preserves the main rationale for decoupling maintenance accounting from the participant object while avoiding fragmentation into multiple per-participant maintenance buckets.
+
+The `MaintenanceState` lookup must still use direct keyed Cosmos SDK collections access rather than any iterative access path.
+
+### Indexing
+
+The implementation should support efficient lookup by:
+
+1. Participant
+2. Reservation ID
+3. Exact transition block height
+4. Reservation start-time overlap for scheduling checks
+
+This is necessary for both slashing-path checks and query endpoints.
+
+---
+
+## Messages
+
+### `MsgScheduleMaintenance`
+
+Schedules a maintenance window for a participant.
+
+Fields should include:
+
+1. Participant identity.
+2. Start block height.
+3. Duration in blocks.
+
+Validation should include:
+
+1. Caller is the participant or an authorized delegate via AuthZ.
+2. Duration is positive.
+3. Duration does not exceed the configured maximum.
+4. Start height satisfies the minimum scheduling lead time.
+5. Participant has enough maintenance credit.
+6. Concurrent-count and concurrent-power caps are satisfied.
+7. Reservation does not overlap another active or scheduled reservation for the same participant.
+8. Reservation does not overlap the restricted PoC commit / exchange window.
+9. Reservation does not overlap the restricted DKG window.
+
+### `MsgCancelMaintenance`
+
+Cancels a not-yet-active maintenance window.
+
+Validation should include:
+
+1. Caller is the participant or an authorized delegate via AuthZ.
+2. Reservation is still in scheduled state.
+3. Cancellation satisfies any configured cancellation policy.
+
+Canceled windows restore the unspent maintenance credit associated with the reservation.
+
+### Authorization
+
+Maintenance scheduling is not treated as a monetary operation. Authorized delegates should be able to schedule and cancel maintenance on behalf of the participant, using the chain’s existing AuthZ mechanism.
+
+---
+
+## Queries
+
+The chain should expose dedicated query endpoints for maintenance state.
+
+Recommended queries:
+
+1. Current maintenance-credit balance for a participant.
+2. Scheduled maintenance windows for a participant.
+3. Active maintenance windows.
+4. Maintenance status for a participant at the current height.
+5. Concurrent reserved participant count and reserved power at a height.
+6. A scheduling-availability query that answers whether a maintenance window could be scheduled for a proposed participant, start height, and duration.
+7. Reservation warning / advisory status for windows that activated despite violating current caps after a governance change.
+
+The scheduling-availability query is important operationally. Participants should be able to query whether a requested maintenance window is currently schedulable before constructing and broadcasting `MsgScheduleMaintenance`, so they can avoid wasting gas on a request that would be rejected.
+
+Normal parameter queries remain sufficient for governance-controlled policy values.
+
+---
+
+## Parameters
+
+This proposal introduces a new maintenance-window parameter group inside the global parameter set, controlled by governance.
+
+Suggested parameters:
+
+| Parameter | Description |
+|-----------|-------------|
+| `maintenance_enabled` | Enables or disables scheduling and activation of maintenance windows. |
+| `maintenance_min_schedule_lead_blocks` | Minimum number of blocks between scheduling and start. |
+| `maintenance_max_window_blocks` | Maximum duration of a single maintenance window. |
+| `maintenance_max_concurrent_validators` | Maximum number of participants concurrently in maintenance. |
+| `maintenance_max_concurrent_power_bps` | Maximum consensus power concurrently in maintenance. |
+| `maintenance_credit_cap_blocks` | Maximum maintenance credit a participant may accumulate. |
+| `maintenance_credit_earn_per_successful_epoch_blocks` | Number of credit blocks earned per successful epoch. |
+
+Additional maintenance-related parameters may be added if implementation reveals a need for more explicit policy control.
+
+---
+
+## Reservation Acceptance Rules
+
+`MsgScheduleMaintenance` should be accepted only if both of the following checks succeed against existing scheduled reservations:
+
+1. The reservation does not cause the number of concurrent maintenance participants to exceed the configured count cap.
+2. The reservation does not cause the total concurrent maintenance power to exceed the configured power cap.
+
+The first version should evaluate concurrency only at scheduling time, not at activation time. This choice favors determinism and operator predictability.
+
+This creates one acknowledged limitation: power-based concurrency is evaluated using the participant power known at the time of scheduling, not the participant power that may exist at activation time. If a reservation is scheduled far in advance and participant power changes materially before activation, concurrency estimates may be inaccurate.
+
+This is a possible attack surface or policy edge case, but it is not expected to be a major issue in the first version and should be called out explicitly for later review.
+
+The same logic should be exposed through the scheduling-availability query so operators can preflight candidate windows before sending a transaction.
+
+### Activation-Time Advisory Re-Check
+
+The first version should also re-check concurrency caps at activation time in the `BeginBlock` lifecycle transition.
+
+This re-check exists to detect drift between:
+
+1. The caps that existed when the reservation was scheduled
+2. The caps that exist when the reservation activates
+3. The weight of the participant when they schedule vs when they activate the window
+
+This can happen if governance lowers concurrency limits after scheduling.
+
+If the activation-time re-check finds that the reservation would exceed current caps:
+
+1. The reservation should still activate
+2. A warning event should be emitted
+3. The reservation should persist queryable advisory metadata indicating that it activated despite violating current caps at activation time
+
+This preserves operator predictability while still making governance-policy drift visible to monitoring and query clients.
+
+---
+
+## Logging and Observability
+
+The implementation should emit standard structured logs through the existing logging framework for:
+
+1. Maintenance scheduled.
+2. Maintenance canceled.
+3. Maintenance activated.
+4. Maintenance completed.
+5. Consensus liveness exemption applied.
+6. Application-layer assignment suppression applied.
+7. Application-layer penalty waiver applied.
+8. Activation-time concurrency advisory warning emitted.
+
+This proposal does not require additional analytics/reporting systems in the first version.
+
+---
+
+## Implementation Notes
+
+### Primary Enforcement Point
+
+This feature must be implemented primarily in the protocol liveness path, not only in application hooks.
+
+The decisive protocol behavior is:
+
+1. Freeze missed-signature accounting during active maintenance.
+2. Skip downtime-driven jailing/slashing during active maintenance.
+
+The lifecycle transitions that make a reservation active or completed should also run in `BeginBlock`, so that consensus liveness checks and maintenance state are evaluated against the same block-height boundary.
+
+Application-layer changes then mirror that protocol exemption:
+
+1. No new inference assignments during maintenance.
+2. No maintenance-covered expiry or downtime penalties.
+
+### Hooks as Defense in Depth
+
+Existing collateral or staking hooks may still be updated as a secondary guardrail so that downtime-derived side effects are not accidentally applied to maintenance-covered participants. However, hook-only logic is not sufficient for this feature.
+
+The reason is that even if hook logic avoids collateral consequences, the participant can still be jailed by the underlying consensus-liveness logic if the primary slashing path is not patched. Hooks are therefore defense in depth, not the primary enforcement point.
+
+### Cross-Repository Implementation Work
+
+This feature will require implementation work in at least two places:
+
+1. The maintained Cosmos SDK fork, for protocol-level liveness exemption behavior.
+2. The core inference-chain codebase, for maintenance state, lifecycle transitions, assignment suppression, application-duty exemptions, and credit accounting.
+
+---
+
+## Risks and Tradeoffs
+
+### Safety Risk from Overlapping Maintenance
+
+If too many participants are simultaneously in maintenance, the network may lose too much availability even if no one is penalized. This is why the proposal includes both participant-count and participant-power caps.
+
+### Policy Risk from Preserved Rewards
+
+Ordinary rewards remain preserved during maintenance-used epochs. This may still require review, but maintenance-credit accrual is explicitly blocked in maintenance-used epochs to prevent self-replenishing maintenance usage.
+
+### Complexity in Duty Suspension
+
+Removing participants from new assignment while keeping them in epoch groups is intentionally lighter-weight than structural epoch mutation, but it requires careful handling in assignment code and penalty code.
+
+### BeginBlock Performance Risk
+
+Reservation lifecycle transitions and activation-time checks occur in `BeginBlock`, so the maintenance state layout must support targeted direct lookups and bounded scans over relevant reservations only. No broad iteration over unrelated participant state is acceptable in the critical path.
+
+Scheduling-time overlap checks must also be bounded. The implementation should take advantage of the governance-controlled maximum maintenance-window length so that overlap validation does not devolve into an unbounded full-state scan.
+
+### Testing and End-to-End Validation Risk
+
+This feature requires convincing end-to-end testing, not only unit testing.
+
+In particular, the Testermint framework will need to support:
+
+1. Pausing participant execution for an active maintenance window.
+2. Verifying that the participant is not jailed as a result of the scheduled downtime.
+3. Verifying that the participant does not receive maintenance-covered assignments or duties.
+4. Verifying that the participant resumes normal behavior after the window ends.
+
+This is a non-trivial testing requirement and should be treated as a significant implementation risk. The feature is not trustworthy without end-to-end validation of the full pause / exemption / resume flow.
+
+---
+
+## Open Issues
+
+### 1. In-Flight Inferences
+
+The proposal requires that participants stop receiving new random assignments immediately when maintenance begins. However, some inferences may already be in flight when the window starts.
+
+This proposal intentionally leaves the exact treatment of in-flight work as an open issue.
+
+Questions to resolve:
+
+1. Are in-flight inferences explicitly canceled when maintenance begins?
+2. Are they allowed to continue serving as a transitional state before going fully offline?
+3. Are there request classes that should be treated differently from others?
+
+Current direction:
+
+1. New assignments stop immediately.
+2. Penalties for work disrupted by the maintenance window are waived.
+3. Exact handling of in-flight requests needs explicit design and may require follow-up work.
+
+### 2. Incentive to Maximize Maintenance Usage
+
+Because maintenance-credit accrual is now blocked in maintenance-used epochs, the original self-replenishing-credit concern is substantially reduced. Remaining incentive review should focus on whether ordinary rewards during maintenance still create any undesirable edge-case behavior.
+
+### 3. Subnet Interaction
+
+Subnet functionality is still under development, and this proposal does not yet specify how maintenance windows interact with subnet-specific duties, scheduling, or availability assumptions.
+
+This should be treated as an explicit open issue so that subnet work does not accidentally bake in assumptions that conflict with maintenance exemptions.
+
+### 4. Reservation Pruning
+
+Completed and canceled maintenance reservations will accumulate over time unless they are pruned.
+
+This proposal does not require immediate pruning logic, because reservation volume is not expected to be large in the first version. However, maintenance reservation pruning should be kept as a nice-to-have follow-up item.
+
+---
+
+## Outcome
+
+This proposal adds a practical operational capability that long-epoch networks need: short, scheduled, mid-epoch maintenance windows. The design avoids consensus-set churn, preserves epoch structure, freezes consensus liveness accounting during scheduled downtime, and suppresses application duties during the maintenance interval.
+
+The remaining unresolved questions are narrow and explicit:
+
+1. How to handle in-flight inferences when maintenance begins.
+2. How maintenance windows should interact with subnet behavior.
+
+With those issues called out, this proposal is ready for technical review and refinement into an implementation plan.
diff --git a/proposals/poc/duplicate-attack.md b/proposals/poc/duplicate-attack.md
new file mode 100644
index 0000000000..763e33677f
--- /dev/null
+++ b/proposals/poc/duplicate-attack.md
@@ -0,0 +1,318 @@
+# Proposal: Duplicate Nonce Attack Mitigation
+
+This proposal addresses a vulnerability in the PoC v2 off-chain artifact system where a malicious participant could inflate their score by duplicating valid artifacts instead of performing honest computation.
+
+## Problem
+
+In PoC v2, participants generate artifacts off-chain and commit only a Merkle root + count to the chain. Validators sample a small random subset (e.g., 200 out of 100,000) to verify. The current MMR (Merkle Mountain Range) does not enforce any relationship between an artifact's position (leaf index) and its nonce.
+
+**Attack mechanism:**
+
+1. Generate fewer legitimate `(nonce, vector)` pairs than claimed (e.g., 90,000 instead of 100,000)
+2. Duplicate some pairs to fill the remaining slots
+3. Commit `(root_hash, 100000)` to chain
+4. Serve valid proofs when validators request artifacts
+
+Validators have no way to detect that the same `(nonce, vector)` exists at multiple indices unless they happen to sample both.
+
+### Why Duplicates Are Hard to Detect
+
+For comparison, consider invalid artifacts (wrong computation). If a validator samples any invalid artifact, it fails verification immediately. Detection probability follows:
+
+```
+P(invalid detected) = 1 - (1 - rate)^k
+```
+
+| Fraud Rate | Invalid Artifact Detection | Duplicate Detection |
+|:-----------|:---------------------------|:--------------------|
+| 1% | 86.6% | 0.2% |
+| 10% | ~100% | 2.0% |
+| 50% | ~100% | 9.5% |
+
+Invalid artifacts are detected independently when sampled. Duplicates require sampling *both* copies of the same nonce — a collision event with probability proportional to `k²/N`, not `k/N`. This makes duplicate detection fundamentally harder and motivates structural prevention.
+
+### Duplicate Detection Probability
+
+For N=100,000 artifacts with sample size k=200, probability that a single validator's sample contains at least one duplicate pair:
+
+| Duplicate Rate | Duplicate Pairs | Detection Probability |
+|:---------------|:----------------|:----------------------|
+| 10% | 5,000 | ~2.0% |
+| 20% | 10,000 | ~3.9% |
+| 30% | 15,000 | ~5.8% |
+| 50% | 25,000 | ~9.5% |
+
+Even with 50% of artifacts being duplicates, a single validator has less than 10% chance of detecting fraud.
+
+### Impact of Population Size
+
+The attack becomes more effective with larger artifact counts:
+
+| Total Artifacts | 10% Duplicates | 20% Duplicates | 30% Duplicates | 50% Duplicates |
+|:----------------|:---------------|:---------------|:---------------|:---------------|
+| 1,000 | 86.4% | 98.1% | 99.7% | 100.0% |
+| 5,000 | 32.8% | 54.9% | 69.7% | 86.3% |
+| 10,000 | 18.0% | 32.8% | 45.0% | 63.0% |
+| 100,000 | 2.0% | 3.9% | 5.8% | 9.5% |
+| 1,000,000 | 0.2% | 0.4% | 0.6% | 1.0% |
+
+With large artifact counts (100k+), detection probability drops below 10% even for aggressive duplication.
+
+### Multi-Validator Aggregation
+
+With multiple validators, detection improves but remains limited:
+
+```
+P(at least one detects) = 1 - (1 - P_single)^V
+```
+
+For 100k artifacts with 10% duplicates and 10 validators, where `P_single = 2.0%` from the table above:
+
+```
+P = 1 - (1 - 0.02)^10 ≈ 18%
+```
+
+Still an 82% chance of the attack going undetected.
+
+### Non-Response Evasion
+
+Even the low detection probability overstates the risk to attackers. A dishonest participant can evade detection entirely:
+
+1. Receive proof request for leaf index `I`
+2. Check if index `I` corresponds to a duplicated nonce
+3. If yes, refuse to respond (timeout)
+
+From the validator's perspective, this is indistinguishable from legitimate network issues. Without aggressive non-response penalties (which would punish honest nodes with connectivity problems), attackers can selectively hide evidence of duplication.
+
+This further motivates structural prevention over detection-based approaches.
+
+## Proposal
+
+**Goal**: Enforce `position == nonce` in the commitment structure. If each nonce can only occupy one specific slot, duplicates become impossible by design.
+
+Approach: use a **Sparse Merkle Sum Tree (SMST)** where nonce determines the tree path.
+
+### Constraints
+
+- Commits every 5 seconds during generation
+- Generation phase: ~5 minutes, ~5M artifacts
+- Max nonce: ~15M (tree depth D=24 optimization target). Larger nonces must work correctly with deeper tree - D is not a hard limit, just optimization target.
+- Validation happens after generation completes
+
+### SMST Overview
+
+**Structure**: Fixed-depth binary tree where nonce bits determine the path. Empty subtrees use precomputed "empty hash".
+
+**Sum property**: Each node stores `count = left.count + right.count`. Enables sampling dense index `[0, total_count)` in sparse tree:
+
+```
+At each node:
+  if index < left.count: go left
+  else: go right, index -= left.count
+```
+
+**Why duplicates are impossible**: Position determined by nonce value. One slot per nonce. Inserting same nonce overwrites, doesn't duplicate.
+
+### Option A: SMST During Generation (Selected)
+
+Maintain SMST incrementally. Commit root every 5 seconds.
+
+- Pro: Single structure, duplicates impossible at all times
+- Pro: No equivalence proof needed - SMST is the only structure
+- Con: Insert O(24) vs MMR O(1), needs snapshot handling for historical commits
+
+Insert overhead: ~100ms per 5-sec window at 83K inserts - acceptable.
+
+### Option B: MMR + Post-Generation SMST (Rejected)
+
+Rejected due to equivalence proof complexity. Would require proving MMR and SMST contain exactly the same artifacts, with no way to add nonces after last MMR commit. Option A avoids this entirely.
+
+### Complexity
+
+| Operation | Cost |
+|:----------|:-----|
+| Insert | O(D) = O(24) hashes per artifact |
+| 5-sec window (83K inserts) | ~2M hashes, ~100ms |
+| Proof generation | O(D) = O(24) |
+| Tree rebuild from disk (5M) | ~6s |
+
+## Implementation Plan
+
+### Goal
+
+Minimal changes. Keep existing messages and flows unchanged.
+
+### Scope
+
+**Unchanged**:
+- `MsgPoCV2StoreCommit` - same fields `(creator, poc_stage_start_block_height, count, root_hash)`
+- `MsgMLNodeWeightDistribution` - unchanged
+- `managed_store.go` - works with any store implementation
+
+**New/Modified**:
+- Extract `ArtifactStore` interface from current concrete type
+- Implement SMST store as the sole implementation
+- Remove MMR implementation (now obsolete)
+
+### Interface
+
+The interface enforces snapshot-aware reads. Unlike MMR where leaf positions were stable (artifact at position 5 was always the 5th inserted), SMST dense indices change as leaves are added. The mapping from dense index to nonce depends on sibling counts at each tree level.
+
+```go
+type ArtifactStore interface {
+    AddWithNode(nonce int32, vector []byte, nodeId string) error
+    GetRoot() []byte
+    GetRootAt(snapshotCount uint32) ([]byte, error)
+    GetFlushedRoot() (count uint32, root []byte)
+    Count() uint32
+    GetArtifactAndProof(denseIndex, snapshotCount uint32) (nonce int32, vector []byte, proof [][]byte, error)
+    GetNodeDistribution() map[string]uint32
+    Flush() error
+    Close() error
+    PrebuildSnapshot(count uint32) error
+}
+```
+
+`GetArtifactAndProof` is the only read method - it returns both artifact and proof from the same snapshot tree state. Separate `GetArtifact`/`GetProof` methods are intentionally omitted to prevent the bug where artifact comes from current tree but proof comes from snapshot tree.
+
+### Persistence
+
+Reuse current `artifacts.data` format - artifacts stored in arrival order. On load, extract nonces to rebuild SMST.
+
+```
+Per PoC stage directory:
+  artifacts.data    - [len][nonce][vector]... in arrival order (reuse current format!)
+  nodes.json        - {node_id: count} for ML node attribution (atomic writes)
+```
+
+Arrival-order is implicit in `artifacts.data` - no separate nonces file needed.
+
+Root hashes are computed on demand from tree state - no separate roots file needed. The `flushedRoots` in-memory cache stores roots at flush boundaries for fast lookup.
+
+### Snapshots
+
+**Why needed**: Multiple commits during generation (every 5 sec). We don't know which commit will be final on-chain. Validators query specific (root, count) pair.
+
+**Approach**:
+- Snapshot at count N = SMST built from first N artifacts in `artifacts.data`
+- `GetRootAt(count)`: O(1) lookup in `flushedRoots` cache, or rebuild tree
+- `GetProof(index, count)`: rebuild SMST from `artifacts[0:count]`, generate proof
+
+**Rebuild cost**: ~6s for 5M. Mitigations:
+- **Prebuild on distribution submit**: `submitWeightDistribution()` queries on-chain for final committed count. Trigger SMST build here - before validators request proofs.
+- All validators query same count, single prebuild serves all
+- Cache remains in memory until store pruned
+
+### Recovery
+
+On restart, rebuild state from `artifacts.data`:
+
+| Scenario | Recovery |
+|:---------|:---------|
+| During generation | Read artifacts, rebuild SMST, continue accepting inserts |
+| After generation, before prebuild | Read artifacts, wait for prebuild trigger |
+| After prebuild | Read artifacts, rebuild SMST at committed count |
+
+Load time: ~6s for 5M artifacts (matches current MMR approach).
+
+### Proof Format
+
+MMR and SMST proofs are structurally different. Verifier needs to know which type.
+
+Recommendation: At upgrade block, all new commits use SMST. Old commits already validated. No runtime switch needed - just code change at upgrade.
+
+### Files
+
+**DAPI (decentralized-api):**
+
+| File | Change |
+|:-----|:-------|
+| `artifacts/store.go` | Extract interface, rename to `mmr_store.go` |
+| `artifacts/smst.go` | New SMST tree implementation |
+| `artifacts/smst_verify.go` | Proof verification logic |
+| `artifacts/smst_store.go` | New store using SMST |
+| `artifacts/interface.go` | Interface definition |
+| `artifacts/managed_store.go` | Use SMST directly |
+| `poc/proof_client.go` | Call SMST `VerifyProof()` |
+| `poc/commit_worker.go` | Trigger SMST prebuild in `submitWeightDistribution()` |
+
+No chain or testermint changes required - SMST is the sole implementation.
+
+### Development Process
+
+**Phase 1: Benchmark current MMR**
+
+Create stress tests measuring:
+- Write throughput: inserts/sec (in-memory and with flush)
+- Read throughput: proofs/sec
+- Proof size: bytes per proof
+- Load from disk: time to rebuild tree from `artifacts.data`
+- Document results in `proposals/poc/duplicate-attack-perf.md`
+
+Expected proof sizes:
+- MMR (N=5M): ~1.5KB (path + peaks)
+- SMST (D=24): ~900 bytes (fixed depth, no peaks)
+- Artifact: ~28 bytes (nonce + vector)
+
+**Phase 2: Extract interface**
+
+- Create `interface.go` with `ArtifactStore` interface
+- Rename `store.go` -> `mmr_store.go`
+- Update `managed_store.go` to use interface
+- Verify existing tests pass
+
+**Phase 3: Implement SMST**
+
+- Create `smst.go` with core tree operations
+- Create `smst_store.go` implementing interface
+- Unit tests for correctness
+- **Dynamic depth**: Tree depth determined by max nonce seen, not hardcoded. D=24 covers nonces up to 16.7M. If nonce > 2^24, depth increases automatically. No failures, just slightly more hashes per operation.
+- **Verifier depth**: Verifier infers depth from proof length (number of sibling entries). No hardcoded depth needed for validation.
+
+**Phase 4: Benchmark SMST**
+
+- Run same stress tests as Phase 1
+- Additional SMST-specific tests:
+  - Load 5M tree from disk to memory (target: <10s)
+  - Reset 5M tree to 4.9M state by rebuild (measure time)
+- Compare throughput with MMR
+- Document results
+
+**Phase 5: Integration**
+
+- Remove MMR implementation
+- Integration tests with testermint
+
+### Expected Throughput
+
+Pure engine (in-memory, no disk):
+- MMR: millions of inserts/sec (O(1) append)
+- SMST: 100K-500K inserts/sec (O(24) per insert)
+
+With disk persistence, both bottleneck on I/O.
+
+## Design Notes
+
+### Why Index-Binding Prevents Count Inflation
+
+Suppose an attacker claims `count=N` but only stores `M < N` real artifacts.
+
+When a validator samples `denseIndex=i` (where `i < N`):
+- If `i` corresponds to one of the M real nonces, the attacker can provide a valid proof
+- If `i` falls in the "gap", the attacker is stuck - any other nonce will have `computedIndex != i`
+
+The dense index is determined by nonce ordering (sum of left sibling counts), not by insertion order. For example, with nonces {100, 200, 300}, the dense indices are always {0, 1, 2} regardless of insertion order.
+
+To answer any possible sampled index `i < N`, the attacker must have N distinct nonces. Duplicates are impossible (same nonce = same path = overwrite). The claimed count accurately reflects real work.
+
+### Proof Verification Location
+
+Proof verification is off-chain only, in DAPI. No on-chain verification needed - this simplifies the upgrade.
+
+### Migration
+
+No migration needed. At upgrade:
+- Old epochs: already validated, data pruned
+- New epochs: use SMST from start
+
+Implementation details (proof format, verification algorithms, snapshot handling) are documented in phase implementation files (`smst-phase-*.md`).
diff --git a/proposals/poc/early-share-guard-dapi-implementation-plan.md b/proposals/poc/early-share-guard-dapi-implementation-plan.md
new file mode 100644
index 0000000000..dc99c46af0
--- /dev/null
+++ b/proposals/poc/early-share-guard-dapi-implementation-plan.md
@@ -0,0 +1,148 @@
+# Implementation plan: DAPI-only early PoC share guard
+
+Steps are intentionally small and ordered. Each references the files/functions to
+touch. No code here — just what each step does. See `early-share-guard-dapi.md`
+for the design and rationale.
+
+All work is in `decentralized-api/` (DAPI). No chain changes.
+
+## Phase 1 — Configuration
+
+1. Add an `EarlyShareGuardConfig` struct in `decentralized-api/apiconfig/config.go`
+   with fields for `enabled`/mode, `first_fraction`, `threshold_ratio`, and
+   `require_prefix_proof`. Use `koanf`/`json` tags to match the other config
+   structs. No retention field — early-guard rows reuse the existing stage-based
+   PoC pruning (see Phase 7).
+2. Add that struct as a new field on `Config` in
+   `decentralized-api/apiconfig/config.go` (next to `PoCParams`).
+3. Set defaults (guard disabled, `first_fraction = 1/3`, `threshold_ratio = 0.5`,
+   `require_prefix_proof = true`) wherever config defaults are initialized in
+   `decentralized-api/apiconfig/config_manager.go`.
+4. Confirm the new config round-trips through load/save in
+   `decentralized-api/apiconfig/config_manager.go` (and its migration test if one
+   asserts the full struct).
+
+## Phase 2 — Local persistence
+
+5. Create a new local store package, e.g. `decentralized-api/poc/earlyshare/`,
+   following the existing local-DB pattern used by
+   `decentralized-api/apiconfig/sqlite_store.go` and
+   `decentralized-api/internal/bls` persistence.
+6. Define the three tables from the design (`poc_early_checkpoints`,
+   `poc_early_guard_state`, `poc_early_capture_runs`) and a schema/migration init
+   in that package.
+7. Add store methods: upsert/get early checkpoints by `(stage, model_id)`,
+   read/update guard state by `(participant_address, model_id)`, and
+   read/update capture-run status by `(stage, model_id)`.
+8. Add a `DeleteStage(stage_height)` method that removes the
+   `poc_early_checkpoints` and `poc_early_capture_runs` rows for a stage; leave
+   `poc_early_guard_state` unpruned except optional GC for unknown participants.
+   No retain-count of its own — pruning is driven by the existing PoC stage
+   pruning (see Phase 7).
+9. Instantiate the store in `decentralized-api/main.go`, next to where
+   `artifactStore` is created, and pass it into the dispatcher and validator.
+
+## Phase 3 — Early checkpoint capture worker
+
+10. Add a first-third target-height helper in `decentralized-api/poc/phase.go`,
+    next to `GetCurrentPocStageHeight`, computing
+    `first_third_height = poc_start + floor(PocStageDuration * first_fraction)`
+    for both regular PoC and CPoC (CPoC uses the confirmation event generation
+    start height).
+11. In `decentralized-api/internal/event_listener/new_block_dispatcher.go` (the
+    per-block stage handler that already checks `IsStartOfPocStage` /
+    `IsStartOfPoCValidationStage`), add a check that fires once when the block
+    height reaches the first-third target for the active stage.
+12. On that trigger, schedule a capture (background goroutine, mirroring the
+    existing `ValidateAll` goroutine pattern) only when the guard mode is not
+    `disabled`; make it idempotent against `poc_early_capture_runs` so a restart
+    does not recapture.
+13. In the capture path, query early commitments via the inference query client
+    `AllPoCV2StoreCommitsForStage` (same client used in
+    `decentralized-api/poc/validator.go`), using the cosmos client from
+    `decentralized-api/cosmosclient`.
+14. Store each returned commitment as a row in `poc_early_checkpoints` and write a
+    `poc_early_capture_runs` row with status `completed` and the captured count.
+15. On capture failure, retry until a deadline then mark the run skipped/failed so
+    the guard later treats the stage as not captured (fail open).
+
+## Phase 4 — Validation integration
+
+16. In `decentralized-api/poc/validator.go` `ValidateAll`, after loading final
+    commits and the `PoCValidationSnapshot`, load early checkpoints for the stage
+    from the store; if none exist for a `(stage, model_id)`, skip the guard for
+    that stage.
+17. Build the per-`(stage, model_id)` early-share distribution: for each
+    participant with a final commit, compute `early_count / final_count`, treating
+    a participant absent from the early snapshot (but present in final) as
+    `early_count = 0`.
+18. Add a weighted-median helper (new function in `decentralized-api/poc/`, near
+    the sampling helpers) that takes `(early_share, weight)` pairs and returns the
+    value where cumulative weight crosses half of the total.
+19. Compute `p50_share` using that helper, weighting each participant by its
+    per-model voting power from `snapshot.ModelVotingPowers[model_id]` (already
+    fetched in `ValidateAll` for sampling); if that model is absent from the
+    snapshot or its total voting power is `0`, skip the guard for that
+    `(stage, model_id)` — no unweighted fallback.
+20. Compute `threshold_share = p50_share * threshold_ratio` per
+    `(stage, model_id)`.
+
+## Phase 5 — Per-participant guard checks
+
+21. In `decentralized-api/poc/validator.go` `validateParticipant`, before the
+    MLNode statistical validation, run the guard for participants that have early
+    checkpoint data.
+22. Threshold check: compare the participant's `early_share` against
+    `threshold_share`.
+23. Miss-streak check: read/update `poc_early_guard_state` for
+    `(participant, model_id)` — track `consecutive_misses`, and
+    apply the one-miss grace rule (only vote no on the relevant repeated miss).
+24. Shared-leaf injection: when `require_prefix_proof` is set, ensure the
+    validation sample includes one deterministic `shared_leaf_index < early_count`
+    by adjusting the sampling step in `validateParticipant`.
+25. Prefix proof comparison: request the shared leaf against
+    `(early_root_hash, early_count)` using `decentralized-api/poc/proof_client.go`
+    `FetchAndVerifyProofs`, and compare `leaf_index`/`nonce`/`vector` with the
+    final-set proof for the same leaf.
+26. Decide the outcome: prefix-proof mismatch (or `early_root` cannot prove the
+    shared leaf) is an immediate vote-no, not subject to the grace rule; low early
+    share follows the miss-streak rule; `early_count > final_count` follows the
+    miss-streak rule and marks the prefix proof unavailable.
+
+## Phase 6 — Modes and vote submission
+
+27. Gate behavior by mode: `observe` runs all checks and logs pass/fail but never
+    changes the vote; `enforce` returns the failing result.
+28. On an enforced vote-no, return permanent validation failure and submit
+    `ValidatedWeight = -1` via the existing submission path in
+    `decentralized-api/poc/validator.go`.
+29. Ensure every "skip guard" branch (Phase 3/4 fail-open conditions) falls
+    through to normal PoC validation unchanged.
+
+## Phase 7 — Retention wiring
+
+30. Drive early-guard pruning off the existing artifact-store stage pruning so
+    there is no separate retention setting: when the artifact store prunes a
+    stage in `decentralized-api/poc/artifacts/managed_store.go` (`PruneStore` /
+    cleanup loop), also call the Phase 2 `DeleteStage(stage_height)` for the same
+    stage. This guarantees early-guard rows live exactly as long as that stage's
+    artifacts.
+
+## Phase 8 — Tests
+
+31. Unit-test the first-third height helper in `decentralized-api/poc/phase.go`
+    for regular PoC and CPoC.
+32. Unit-test the weighted-median helper (ties, zero weights, single dominant
+    weight, absent participants as zero).
+33. Unit-test the capture worker idempotency and fail-open paths against a stubbed
+    query client (mirror `decentralized-api/poc/commit_worker_test.go`).
+34. Unit-test the guard decision matrix in `validator.go` (pass, low-share with
+    grace, prefix mismatch immediate no, `early_count > final_count`, missing
+    snapshot voting power → skip) extending the existing validator tests.
+35. Add a persistence test for the store package (schema init, upsert/get, prune).
+
+## Phase 9 — Rollout
+
+36. Ship with the guard `disabled` by default.
+37. Enable `observe` on testnet/mainnet and review logged pass/fail decisions
+    against known-good participants before switching to `enforce`.
diff --git a/proposals/poc/early-share-guard-dapi.md b/proposals/poc/early-share-guard-dapi.md
new file mode 100644
index 0000000000..66cb0b58b7
--- /dev/null
+++ b/proposals/poc/early-share-guard-dapi.md
@@ -0,0 +1,333 @@
+# Proposal: DAPI-only early PoC share guard
+
+## Summary
+
+Add a DAPI-only validation guard for PoC v2 / CPoC v2 that detects participants who deliver too little of their final PoC output during the first third of the generation window.
+
+The guard does not require chain changes. DAPI captures an early checkpoint by querying current on-chain PoC v2 commitments near the first-third boundary, stores those checkpoints locally, and later compares them with the final commitments used for validation. If DAPI misses the early checkpoint for a `(stage, model_id)`, the guard is skipped for that whole stage and normal PoC v2 validation continues.
+
+## Motivation
+
+Current PoC v2 validation checks the final committed artifact store by sampling dense leaf indices, requesting SMST proofs, and validating the sampled artifacts. This confirms that the final commitment is internally valid, but it does not directly check whether a meaningful share of the final PoC work was already produced early in the PoC window.
+
+The additional guard is intended to make late burst production less attractive. A participant should have a reasonable fraction of its final work committed by the first third of the PoC window, relative to the rest of the network for the same model/stage.
+
+## Current behavior
+
+DAPI validation already queries final commitments in bulk:
+
+- `AllPoCV2StoreCommitsForStage(stage_height)` returns all latest commitments for that PoC/CPoC stage.
+- Each commitment is keyed on chain by `(stage_height, participant, model_id)`.
+- Later commits overwrite earlier commits in chain state.
+- Validators sample dense `leaf_index` values in `[0, final_count)`, request proofs from `POST /v1/poc/proofs`, verify SMST proofs, then run MLNode statistical validation.
+
+Because earlier commitments are overwritten, DAPI cannot recover an earlier checkpoint later unless it captured it locally at the time or uses historical node state. This proposal uses local DAPI capture and explicitly skips the guard for a whole `(stage, model_id)` when its early capture was missed.
+
+## Design
+
+### Early checkpoint capture
+
+For each active PoC/CPoC stage, DAPI calculates a first-third checkpoint height:
+
+- Regular PoC:
+  - `first_third_height = poc_start_height + floor(PocStageDuration / 3)`
+- CPoC:
+  - `first_third_height = confirmation_event.GenerationStartHeight + floor(PocStageDuration / 3)`
+
+At `first_third_height`, DAPI calls:
+
+```text
+AllPoCV2StoreCommitsForStage(stage_height)
+```
+
+DAPI stores each returned commitment locally as:
+
+```text
+stage_height
+participant_address
+model_id
+early_count
+early_root_hash
+checkpoint_block_height
+captured_at_block_height
+```
+
+The early capture has no pre-known participant list: a participant appears in the early snapshot only if an early commit exists for them (which implies `early_count >= 1`). "Missing" is therefore a stage-level condition — if DAPI did not capture the early checkpoint for a `(stage, model_id)` at all, the guard is skipped for every participant in that stage and normal PoC v2 validation continues.
+
+### Final comparison
+
+When validation starts, DAPI already queries the final latest commitments. The guard only runs for a `(stage, model_id)` whose early checkpoint was captured. For each participant with a final commitment in such a stage:
+
+```text
+early_share = early_count / final_count
+```
+
+where `early_count` is taken from the early snapshot, or `0` if the participant has no early commit (see below).
+
+The entire `(stage, model_id)` is excluded from the guard if no early checkpoint was captured for it. Within a captured stage, an individual participant entry is excluded from the early-share distribution if:
+
+- no final commitment exists
+- `final_count == 0`
+- `early_count > final_count`
+- `early_root_hash` is empty or invalid (for participants that do have an early commit)
+
+If the stage early checkpoint was captured but a participant appears in the final list and not in the early snapshot, they had no committed early work and are treated as:
+
+```text
+early_count = 0
+early_share = 0
+```
+
+Such a participant remains in the distribution and affects both the model/stage P50 and their own pass/fail result. Note that this zero comes from the absence of an early commit, not from a captured commit with `early_count == 0` (a commit always implies `early_count >= 1`). Only a stage with no captured early checkpoint is excluded from the guard entirely.
+
+For each `(stage, model_id)`, DAPI computes a weight-weighted median of `early_share` across participants:
+
+```text
+p50_share = weighted_median(early_share, weight = established_voting_power)
+threshold_share = p50_share * early_share_threshold_ratio
+```
+
+`weighted_median` sorts participants by `early_share`, accumulates their weights, and returns the `early_share` at which cumulative weight crosses half of the total weight.
+
+Initial parameter:
+
+```text
+early_share_threshold_ratio = 0.5
+```
+
+A participant passes the share check if:
+
+```text
+participant_early_share >= threshold_share
+```
+
+This makes the guard relative to the observed network behavior for the model/stage instead of using a fixed absolute count.
+
+#### Why the median is weighted, and by what
+
+An unweighted median over participants is trivially gameable: spinning up many cheap hosts that commit little early work drags the median down, lowers the threshold, and lets a genuine late-burst producer slip under it. The median must therefore be weighted by something an attacker cannot fabricate on demand.
+
+The weight is the participant's **established per-model voting power** — the delegation-resolved `voting_power` already used by PoC v2 / CPoC v2 validation for sampling and the on-chain 2/3 threshold. DAPI reads it from the `PoCValidationSnapshot` it already queries for sampling:
+
+```text
+weight = snapshot.ModelVotingPowers[model_id][participant_address]
+```
+
+(with `snapshot.TotalNetworkWeight` as the per-model denominator). Key properties:
+
+- **Not manipulable by the current submission.** It is the effective, previously-settled weight (effective epoch `N-1` while validating upcoming epoch `N`), frozen into the snapshot at the start of PoC validation. It is not the weight being claimed in the round under evaluation, so it cannot be inflated by the very commitment the guard is policing. This is what removes the circularity.
+- **Delegation-resolved.** It already includes PoC delegation directed at the participant for that model, matching the weight the rest of the protocol trusts.
+- **Sybil-resistant.** Freshly created hosts have zero established voting power and contribute nothing to the median. Such a participant is still *evaluated* against the threshold (its own weight is simply `0`), but it cannot *set* the threshold.
+
+Do not use `MLNodeWeightDistribution` for this weighting: that is the per-node artifact count for the current stage — the value being claimed and validated now — so weighting by it would be circular and manipulable.
+
+### Local miss streak state
+
+DAPI keeps local state per `(participant_address, model_id)`:
+
+```text
+consecutive_misses
+updated_stage_height
+```
+
+**PoC vs CPoC asymmetry.** Regular PoC early-share is cheap to fake, so a passing *regular PoC* round is not trusted to clear the streak. Only a passing *confirmation PoC (CPoC)* resets it. Failures count the same in either phase. The single streak is shared across PoC and CPoC for a `(participant, model)` (the state is not segmented by phase).
+
+State transition:
+
+- If the participant **passes** the early-share check:
+  - if this is a **CPoC** stage: `consecutive_misses = 0`
+  - if this is a **regular PoC** stage: no change (do not reset `consecutive_misses`); never vote no on a passing stage
+- If the participant **fails** the early-share check (either PoC or CPoC):
+  - `consecutive_misses += 1`
+  - if `consecutive_misses == 1`, allow this stage (grace)
+  - if `consecutive_misses >= 2`, vote no for this participant/model
+
+This allows one miss in a row before voting no. A passing regular PoC does not rescue an existing streak, because PoC output is easy to cheat; only a CPoC pass — which is ungameable — clears the streak.
+
+### Early inclusion check
+
+The early checkpoint must be tied to the same artifact stream as the final commitment. Otherwise a participant could submit an early commitment whose root is internally valid but unrelated to the work behind the final commitment.
+
+The SMST commitment has no notion of insertion order: the root commits a set of artifacts keyed by nonce, and a leaf's dense index is the rank of its nonce among all nonces in that snapshot. Dense indices shift as later artifacts arrive, so the same dense index refers to different nonces in the early and final trees, and no "prefix" relation between the two roots can be checked by index. The property that can be checked is inclusion: artifacts committed early must still be present, unchanged, in the final tree.
+
+For each participant/model with an early checkpoint, DAPI verifies inclusion of a sampled subset of early leaves:
+
+1. Deterministically sample `early_inclusion_sample_size` dense indices from `[0, early_count)` using the existing seeded sampling (validator pubkey + fresh block hash), with a distinct early-inclusion seed domain. All indices target one snapshot; the prover serves them through a batch store API so the snapshot tree is resolved once for the whole request.
+2. Request proofs for those indices against `(early_root_hash, early_count)` via the existing `POST /v1/poc/proofs` endpoint. Verify each proof; this yields `(nonce, vector)` pairs cryptographically bound to the early root.
+3. Request proofs for those nonces against `(final_root_hash, final_count)` via the by-nonce endpoint (below). Verify each proof and check that the returned nonce equals the requested nonce and the returned vector byte-equals the early vector.
+
+The normal final validation sample over `[0, final_count)` is unchanged and independent of this check.
+
+An honest participant can never fail this check: a nonce inserted before the checkpoint is still present in the final tree (same nonce maps to the same slot; duplicate inserts are rejected), and its vector is a deterministic function of the nonce. Any of the following is therefore a hard failure — vote no immediately, not subject to the one-miss grace rule used for low early share:
+
+- an early or final proof fails verification
+- the final proof returns a different nonce or vector
+- the by-nonce final proof response omits a nonce proven against the participant's own early root
+
+Network errors and timeouts are not hard failures. In enforce mode they return a retryable validation result and use the existing bounded retry queue; after retry exhaustion the participant is reported invalid through the normal validation path. In observe mode they are logged and validation continues.
+
+Retries use a slow-growing backoff: `3s * 1.5^attempt`, capped at `45s`, with 25 total attempts. This spreads retryable network failures over roughly 14 minutes, while still stopping early if the validation phase ends.
+
+### By-nonce proof endpoint
+
+The existing proofs endpoint is dense-index keyed, and the validator does not know a nonce's dense index in the final snapshot. Add:
+
+```text
+POST /v1/poc/proofs/by-nonce
+```
+
+Same auth scheme, snapshot binding (`root_hash` + `count` validated via `GetRootAt`), and batch limit as `POST /v1/poc/proofs`, but with `nonces` instead of `leaf_indices`. It gets its own request signing payload with a `poc-proofs-by-nonce-v1` domain tag; without the tag, a signature over a leaf-index request could replay as a nonce request because both carry lists of 32-bit integers. For each found nonce the response carries `dense_index`, `nonce`, `vector`, and `proof`. Missing nonces are omitted; the client treats any omitted requested nonce as `ErrNonceAbsent`, a permanent inclusion failure.
+
+The prover maps nonce to position: walking the nonce's bit path collects the proof siblings, and summing left-sibling counts on right turns yields the dense index. This is O(depth) and needs one new store method, `GetArtifactAndProofByNonce(nonce, snapshotCount)`.
+
+The prover-supplied mapping is trust-free. The proof path is derived from the nonce bits and sibling counts are committed by the root hash, so `VerifySMSTProofWithDenseIndex` binds `(nonce, vector, dense_index)` to the root; a lying prover cannot substitute a leaf or index without failing verification.
+
+SMST also supports non-membership proofs (empty-hash siblings along the nonce path), so "not found" could be made provable. This is deliberately omitted: a malicious prover preferring deniability would time out rather than omit the nonce, and timeouts already funnel into enforce-mode retry handling.
+
+### Snapshot cache and warm-up
+
+SMST snapshots are expensive to rebuild because later inserts mutate the tree. A count equal to the live tree is served directly from it (no rebuild, no cache entry). Historical counts go through a process-wide snapshot tree cache:
+
+- at most 4 snapshot trees in memory across the process
+- 20-minute idle eviction for unpinned entries
+- single-flight builds, with at most 2 concurrent rebuilds
+- final-count prebuilds and warmed early snapshots are pinned, so garbage-count requests cannot evict the hot trees
+
+Both `POST /v1/poc/proofs` and `POST /v1/poc/proofs/by-nonce` use batch store APIs, so a request resolves the snapshot tree once and serves all requested proofs from that tree.
+
+The prover also warms the likely early snapshot on the exact first-fraction block event. It does not infer the count from local flush state. Instead it queries its own on-chain `PoCV2StoreCommit` for each local model and warms that recorded count in the background. If the warm-up is missed or late, the demand-driven cache still builds the snapshot on the first proof request and later retries hit the finished cache entry.
+
+## Local storage
+
+Add a small DAPI-local persistent store, backed by the existing local DB mechanism or a dedicated SQLite file.
+
+Proposed tables:
+
+```sql
+CREATE TABLE IF NOT EXISTS poc_early_checkpoints (
+  stage_height INTEGER NOT NULL,
+  participant_address TEXT NOT NULL,
+  model_id TEXT NOT NULL,
+  early_count INTEGER NOT NULL,
+  early_root_hash BLOB NOT NULL,
+  checkpoint_block_height INTEGER NOT NULL,
+  captured_at_block_height INTEGER NOT NULL,
+  PRIMARY KEY (stage_height, participant_address, model_id)
+);
+
+CREATE TABLE IF NOT EXISTS poc_early_guard_state (
+  participant_address TEXT NOT NULL,
+  model_id TEXT NOT NULL,
+  consecutive_misses INTEGER NOT NULL DEFAULT 0,
+  updated_stage_height INTEGER NOT NULL,
+  PRIMARY KEY (participant_address, model_id)
+);
+```
+
+Optional operational metadata:
+
+```sql
+CREATE TABLE IF NOT EXISTS poc_early_capture_runs (
+  stage_height INTEGER NOT NULL,
+  model_id TEXT NOT NULL,
+  target_block_height INTEGER NOT NULL,
+  captured_at_block_height INTEGER NOT NULL,
+  captured_commit_count INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  PRIMARY KEY (stage_height, model_id)
+);
+```
+
+### Retention
+
+DAPI already prunes local PoC/CPoC data on a stage/epoch basis: the per-`(stage, model)` artifact store (`ManagedArtifactStore`) keeps only the most recent stages via its background cleanup loop (currently `retainCount = 10`), and `ManagedStorage` retains the last few epochs. The new tables follow the same model:
+
+- `poc_early_checkpoints` and `poc_early_capture_runs` are stage-keyed and ride the existing stage-based pruning. Their retention must be `<=` the artifact store's `retainCount`, since a checkpoint is useless once its stage's artifacts are gone. Simplest is to prune them in the same cleanup loop using the same `retainCount`.
+- `poc_early_guard_state` is intentionally longer-lived: it is keyed per `(participant_address, model_id)`, not per stage, and carries the cross-epoch miss streak. It is small and persists across epochs, with at most occasional GC for participants/models that no longer exist.
+
+## DAPI flow
+
+### Block listener / checkpoint worker
+
+Add a DAPI worker that observes chain phase state and schedules one capture per PoC/CPoC stage:
+
+1. Detect current stage and first-third target height.
+2. Wait until `target_height`.
+3. Query `AllPoCV2StoreCommitsForStage(stage_height)`.
+4. Store all returned commitments as local early checkpoints.
+5. Mark the capture run as completed.
+
+The worker should be idempotent. If DAPI restarts after capture, it should not overwrite an existing checkpoint set unless explicitly configured to do so.
+
+### Validation path
+
+Extend `OffChainValidator.ValidateAll` / `validateParticipant`:
+
+1. Load final commits as today.
+2. Load early checkpoints for the same stage.
+3. Compute the per-model weight-weighted P50 over `early_count / final_count`, weighting each participant by its established per-model voting power from the validation snapshot (`snapshot.ModelVotingPowers[model_id]`).
+4. Before MLNode statistical validation, run the early guard for participants with available checkpoint data:
+   - threshold check
+   - miss streak check
+   - early inclusion check
+5. If the guard decides to vote no, return permanent validation failure and submit `ValidatedWeight = -1`. If the inclusion proof is transiently unavailable in enforce mode, return retryable validation failure and let the existing retry queue handle it.
+6. If the guard is unavailable, continue with normal validation.
+
+## Configuration
+
+Suggested DAPI config:
+
+```yaml
+early_share_guard:
+  mode: disabled
+  first_fraction: 0.3333333333
+  threshold_ratio: 0.5
+  require_inclusion_proof: true
+  inclusion_sample_size: 5
+```
+
+The guard should default to disabled until tested on testnet/mainnet in observe-only mode.
+
+Recommended modes:
+
+- `disabled`: no capture, no validation effect
+- `observe`: capture checkpoints and log pass/fail decisions, but never vote no
+- `enforce`: vote no after the miss-streak rule triggers or the early inclusion check fails
+
+## Failure behavior
+
+The guard must fail open for missing local data:
+
+- DAPI missed the first-third capture for a `(stage, model_id)`: skip guard for that whole stage.
+- DAPI restarted before capture and no checkpoint exists: skip guard.
+- Chain query failed at capture time: retry until a configured deadline, then skip.
+- Established per-model voting power is unavailable in the validation snapshot (model absent, or its total voting power is `0`): skip guard for that `(stage, model_id)`. There is no unweighted fallback — if the weighting data cannot be obtained, the guard does not run.
+
+Note that a participant present in the final list but absent from the captured early snapshot is *not* a skip case: with the stage captured, it is treated as `early_share = 0` and evaluated normally (see Final comparison).
+
+The guard should fail closed for invalid captured data:
+
+- `early_count > final_count`: vote no if the miss streak triggers; also skip the inclusion check.
+- an early or final inclusion proof fails verification: vote no.
+- the final tree does not contain a sampled early nonce with the same vector (mismatch or omitted by-nonce response): vote no.
+
+## Limitations
+
+This is intentionally DAPI-local and does not create a consensus-level rule. Different validators can make different decisions if they miss different checkpoint data. To reduce false negatives, missing checkpoint data must skip the guard rather than penalize.
+
+The robust consensus version would store early checkpoint history or first-third checkpoints on chain. This proposal avoids chain changes and accepts the weaker availability guarantees.
+
+## Implementation touchpoints
+
+- `decentralized-api/poc/phase.go`: helper for first-third target height.
+- `decentralized-api/internal/event_listener/new_block_dispatcher.go`: stage detection and checkpoint worker scheduling.
+- `decentralized-api/poc/validator.go`: load early guard data, run threshold/miss/inclusion checks. Reuse the `PoCValidationSnapshot.ModelVotingPowers` it already queries for sampling as the per-model weights for the weighted median. Reuse the seeded sampling helper for the early sample; the final validation sample is unchanged. Use slow-growing retry backoff for transient proof failures.
+- `decentralized-api/poc/proof_client.go`: reuse `FetchAndVerifyProofs` for the early proofs; add a by-nonce fetch/verify for the final-tree inclusion proofs, treating omitted requested nonces as `ErrNonceAbsent`.
+- `decentralized-api/internal/server/public/poc_handler.go`: add `POST /v1/poc/proofs/by-nonce` with a domain-separated request signing payload; the existing `POST /v1/poc/proofs` already serves arbitrary `(root_hash, count, leaf_indices)` snapshots, including the early one.
+- `decentralized-api/poc/artifacts`: add batch proof APIs plus `GetArtifactAndProofByNonce(nonce, snapshotCount)` to the `ArtifactStore` interface and SMST store. Add the bounded process-wide snapshot cache.
+- `decentralized-api/poc/validator.go` block hook: warm the prover-side early snapshot by querying the chain for the local participant's recorded commit at the first-fraction block.
+- DAPI local DB package: add checkpoint and guard-state persistence.
+
+## Open questions
+
+- None currently open.
diff --git a/proposals/poc/smst-phase-1.md b/proposals/poc/smst-phase-1.md
new file mode 100644
index 0000000000..e768bf526d
--- /dev/null
+++ b/proposals/poc/smst-phase-1.md
@@ -0,0 +1,63 @@
+# Phase 1: MMR Benchmark Results
+
+Baseline performance measurements for the current MMR-based artifact store.
+
+## Test Environment
+
+- CPU: AMD Ryzen 9 9950X 16-Core Processor
+- OS: Linux
+- Go: standard crypto/sha256
+
+## Write Throughput
+
+| Operation | Throughput | Latency |
+|:----------|:-----------|:--------|
+| Add (in-memory) | ~2M ops/sec | 504 ns/op |
+| Add (with flush every 1K) | ~330K ops/sec | 3012 ns/op |
+
+MMR append is O(1) amortized - each insert adds a leaf and merges sibling nodes based on trailing zeros in the leaf count.
+
+## Read Throughput
+
+| Operation | Tree Size | Throughput | Latency |
+|:----------|:----------|:-----------|:--------|
+| GetProof | 100K | ~4.8M ops/sec | 254 ns/op |
+| VerifyProof | 100K | ~510K ops/sec | 1959 ns/op |
+
+Proof generation is fast because the MMR nodes are in memory. Verification is slower due to hash computation.
+
+## Proof Size
+
+| Tree Size | Avg Proof Size | Hash Count |
+|:----------|:---------------|:-----------|
+| 1,000 | 420 bytes | 13 |
+| 10,000 | 523 bytes | 16 |
+| 100,000 | 659 bytes | 20 |
+| 1,000,000 | 775 bytes | 24 |
+| 5,000,000 | 911 bytes | 28 |
+
+Proof size grows logarithmically. At 5M artifacts, average proof is ~900 bytes (28 SHA-256 hashes).
+
+## Recovery Time (Disk Load)
+
+| Artifact Count | Recovery Time | Rate |
+|:---------------|:--------------|:-----|
+| 10,000 | 6.5 ms | 1.5M artifacts/sec |
+| 100,000 | 68 ms | 1.5M artifacts/sec |
+| 1,000,000 | 742 ms | 1.3M artifacts/sec |
+
+Recovery reads artifacts.data sequentially and rebuilds the MMR in memory. At 5M artifacts (production scale), estimated recovery time is ~3.5 seconds.
+
+## Analysis
+
+The MMR implementation is well-optimized:
+
+1. In-memory inserts are fast (500ns) due to O(1) append
+2. Proof generation is memory-bound, not CPU-bound
+3. Recovery scales linearly with artifact count
+4. Proof sizes are reasonable but grow with tree size
+
+For SMST comparison (Phase 4), key metrics to track:
+- Insert latency (expected: higher due to O(D) vs O(1))
+- Proof size (expected: smaller, fixed depth)
+- Recovery time (expected: similar, same data format)
diff --git a/proposals/poc/smst-phase-2.md b/proposals/poc/smst-phase-2.md
new file mode 100644
index 0000000000..18a535e0c5
--- /dev/null
+++ b/proposals/poc/smst-phase-2.md
@@ -0,0 +1,45 @@
+# Phase 2: Interface Extraction
+
+Extracted `ArtifactStore` interface to enable alternative implementations.
+
+## Changes
+
+1. Created `interface.go` with `ArtifactStore` interface
+2. Renamed `store.go` -> `mmr_store.go`
+3. Renamed struct `ArtifactStore` -> `MMRArtifactStore`
+4. Updated `managed_store.go` to use interface type in map
+
+## Interface Definition
+
+```go
+type ArtifactStore interface {
+    Add(nonce int32, vector []byte) error                           // deprecated
+    AddWithNode(nonce int32, vector []byte, nodeId string) error
+    GetRoot() []byte
+    GetRootAt(snapshotCount uint32) ([]byte, error)
+    GetFlushedRoot() (count uint32, root []byte)
+    Count() uint32
+    GetArtifact(denseIndex uint32) (nonce int32, vector []byte, err error)
+    GetProof(denseIndex uint32, snapshotCount uint32) ([][]byte, error)
+    GetNodeDistribution() map[string]uint32
+    GetNodeCounts() map[string]uint32
+    Flush() error
+    Close() error
+}
+```
+
+## Design Notes
+
+The interface uses `denseIndex` terminology to clarify that indexes are sequential [0, count), regardless of underlying tree structure. For MMR this maps directly to leaf index. For SMST this will require sum-based navigation.
+
+`Add()` is kept for backwards compatibility with existing tests but is deprecated in favor of `AddWithNode()` which tracks per-node contribution.
+
+Compile-time interface assertion ensures `MMRArtifactStore` implements the interface:
+
+```go
+var _ ArtifactStore = (*MMRArtifactStore)(nil)
+```
+
+## Verification
+
+All 2264 tests pass (757 API + 1507 chain).
diff --git a/proposals/poc/smst-phase-3.md b/proposals/poc/smst-phase-3.md
new file mode 100644
index 0000000000..a89d9d0c08
--- /dev/null
+++ b/proposals/poc/smst-phase-3.md
@@ -0,0 +1,89 @@
+# Phase 3: SMST Implementation
+
+Implemented Sparse Merkle Sum Tree (SMST) for duplicate-proof artifact storage.
+
+## Files Created
+
+1. `smst.go` - Core tree operations
+2. `smst_store.go` - Store implementing ArtifactStore interface  
+3. `smst_verify.go` - Proof verification
+4. `smst_test.go` - Unit tests
+
+## SMST Design
+
+The tree is a fixed-depth binary tree where nonce bits determine the path from root to leaf.
+
+Node structure:
+```go
+type smstNode struct {
+    hash  []byte   // SHA-256 hash
+    count uint32   // sum of leaf counts in subtree
+    left  *smstNode
+    right *smstNode
+}
+```
+
+Sum property enables dense index navigation in a sparse tree:
+```
+if index < left.count: go left
+else: go right, index -= left.count
+```
+
+Hash computation includes the count:
+```go
+hash = SHA256(0x01 || left_hash || right_hash || count_le32)
+```
+
+## Key Features
+
+Dynamic depth: Default depth is 24 (supports nonces up to 16.7M). Larger nonces automatically expand the tree depth up to 32.
+
+Duplicate prevention: Inserting the same nonce returns `ErrDuplicateNonce`. This is the core property that prevents the duplicate attack.
+
+Dense indexing: Validators sample using dense indices [0, count), which the tree navigates using sum-based traversal.
+
+Snapshot support: The store tracks committed roots in `flushedRoots` map and can rebuild trees at historical counts via `rebuildTreeAt()`.
+
+## Proof Format
+
+Proofs contain sibling hashes with their subtree counts, enabling verification without inferring counts:
+
+```go
+type SMSTProofElement struct {
+    SiblingHash  []byte  // 32 bytes
+    SiblingCount uint32  // 4 bytes
+}
+```
+
+Transport format: 36 bytes per level (32 hash + 4 count).
+
+## Verification
+
+Verification reconstructs the root by hashing from leaf to root:
+
+1. Start with `leafHash = SHA256(0x00 || leafData)`
+2. At each level, combine with sibling using path direction
+3. Include count in hash: `SHA256(0x01 || left || right || count)`
+4. Compare final hash and count with expected root
+
+## Interface Compliance
+
+`SMSTArtifactStore` implements the full `ArtifactStore` interface:
+- Add/AddWithNode - insert with duplicate rejection
+- GetRoot/GetRootAt/GetFlushedRoot - root hashes
+- GetArtifact - retrieval by dense index
+- GetProof - proof generation
+- Node distribution tracking
+- Persistence via artifacts.data (same format as MMR)
+
+## Test Coverage
+
+13 new tests covering:
+- Empty tree, insert, count
+- Duplicate rejection
+- Dense index navigation
+- Root consistency (insertion order independent)
+- Depth expansion
+- Store basics and recovery
+- Proof generation and verification
+- Proof encoding/decoding
diff --git a/proposals/poc/smst-phase-4.md b/proposals/poc/smst-phase-4.md
new file mode 100644
index 0000000000..17b7017132
--- /dev/null
+++ b/proposals/poc/smst-phase-4.md
@@ -0,0 +1,71 @@
+# Phase 4: SMST Benchmark Results
+
+Performance comparison between MMR and SMST artifact stores.
+
+## Test Environment
+
+- CPU: AMD Ryzen 9 9950X 16-Core Processor
+- OS: Linux
+- Go: standard crypto/sha256
+
+## Write Throughput
+
+| Store | Operation | Throughput | Latency |
+|:------|:----------|:-----------|:--------|
+| MMR | Add (in-memory) | 2.0M ops/sec | 504 ns/op |
+| SMST | Add (in-memory) | 355K ops/sec | 2818 ns/op |
+| MMR | Add (with flush) | 330K ops/sec | 3012 ns/op |
+| SMST | Add (with flush) | 187K ops/sec | 5349 ns/op |
+
+MMR is ~5.6x faster for in-memory inserts because it's O(1) amortized vs O(24) for SMST tree traversal.
+
+## Read Throughput
+
+| Store | Operation | Throughput | Latency |
+|:------|:----------|:-----------|:--------|
+| MMR | GetProof | 4.8M ops/sec | 254 ns/op |
+| SMST | GetProof | 823K ops/sec | 1215 ns/op |
+| MMR | VerifyProof | 510K ops/sec | 1959 ns/op |
+| SMST | VerifyProof | 387K ops/sec | 2584 ns/op |
+
+SMST proof generation is slower due to tree traversal vs direct array access in MMR. Verification is comparable since both require ~24 hash computations.
+
+## Proof Size
+
+| Store | Tree Size | Proof Size | Elements |
+|:------|:----------|:-----------|:---------|
+| MMR | 100K | 659 bytes | 20 hashes |
+| SMST | 100K | 864 bytes | 24 (hash+count) |
+| MMR | 5M | 911 bytes | 28 hashes |
+| SMST | 5M | 864 bytes | 24 (hash+count) |
+
+SMST proofs are fixed at 864 bytes (24 levels x 36 bytes). MMR proofs grow with tree size but are hash-only (32 bytes each). At 5M artifacts SMST is slightly smaller.
+
+## Recovery Time (Disk Load)
+
+| Store | Artifact Count | Recovery Time | Rate |
+|:------|:---------------|:--------------|:-----|
+| MMR | 10K | 6.5 ms | 1.5M/sec |
+| SMST | 10K | 31.5 ms | 317K/sec |
+| MMR | 100K | 68 ms | 1.5M/sec |
+| SMST | 100K | 312 ms | 320K/sec |
+| MMR | 1M | 742 ms | 1.3M/sec |
+| SMST | 1M | 3037 ms | 329K/sec |
+
+SMST recovery is ~4x slower because each artifact requires a full tree traversal during insertion. At 5M artifacts, estimated SMST recovery is ~15 seconds.
+
+## Summary
+
+| Metric | MMR | SMST | Trade-off |
+|:-------|:----|:-----|:----------|
+| Insert | 2M/sec | 355K/sec | 5.6x slower |
+| Recovery | 742 ms/1M | 3037 ms/1M | 4x slower |
+| Proof size | Variable (grows) | Fixed 864 bytes | SMST wins at scale |
+| Duplicate prevention | No | Yes | SMST required |
+
+SMST is slower but provides the essential duplicate prevention property. The performance is acceptable for production use:
+- 355K inserts/sec handles burst traffic easily
+- 3-second recovery at 1M artifacts is reasonable for restart
+- Fixed proof size is actually an advantage at high scale
+
+The trade-off is worth it because duplicate prevention is a security requirement.
diff --git a/proposals/poc/smst-phase-5.md b/proposals/poc/smst-phase-5.md
new file mode 100644
index 0000000000..d9e09ac401
--- /dev/null
+++ b/proposals/poc/smst-phase-5.md
@@ -0,0 +1,81 @@
+# Phase 5: Integration
+
+Added `use_smst` parameter to chain and testermint for SMST enablement.
+
+## Changes
+
+### Chain (params.proto)
+
+Added to `PocParams`:
+
+```protobuf
+bool use_smst = 13;  // Use SMST instead of MMR for artifact storage (duplicate prevention)
+```
+
+Proto regenerated with `ignite generate proto-go`.
+
+### Testermint (AppExport.kt)
+
+Added to `PocParams` data class:
+
+```kotlin
+@SerializedName("use_smst")
+val useSmst: Boolean = true,  // Use SMST for duplicate prevention (default: true)
+```
+
+## Integration Points (Future Work)
+
+The following integration points are documented for future implementation when enabling SMST in production:
+
+### ManagedArtifactStore Factory
+
+The `ManagedArtifactStore` should select store type based on `use_smst` param:
+
+```go
+func (m *ManagedArtifactStore) GetOrCreateStore(height int64, useSmst bool) (ArtifactStore, error) {
+    if useSmst {
+        return OpenSMST(storeDir)
+    }
+    return Open(storeDir)
+}
+```
+
+### proof_client.go
+
+Verify proofs using the appropriate verifier:
+
+```go
+if useSmst {
+    elements := decodeSMSTProof(proofHashes)
+    if !artifacts.VerifySMSTProofWithCounts(rootHash, count, nonce, leafData, elements) {
+        return ErrProofVerificationFailed
+    }
+} else {
+    if !artifacts.VerifyProof(rootHash, count, leafIndex, leafData, proofHashes) {
+        return ErrProofVerificationFailed
+    }
+}
+```
+
+### commit_worker.go
+
+Trigger SMST prebuild for efficient proof queries:
+
+```go
+if smstStore, ok := store.(*artifacts.SMSTArtifactStore); ok {
+    smstStore.PrebuildSnapshot(resp.Count)
+}
+```
+
+## Migration Path
+
+1. Deploy with `use_smst = false` (MMR, current behavior)
+2. Test SMST in staging environment
+3. Enable via governance proposal: `use_smst = true`
+4. All new PoC stages use SMST; existing stages continue with MMR
+
+No data migration required - each PoC stage is independent.
+
+## Verification
+
+All 2281 tests pass (774 API + 1507 chain).
diff --git a/proposals/poc/smst-phase-6.md b/proposals/poc/smst-phase-6.md
new file mode 100644
index 0000000000..b8d14d9e6c
--- /dev/null
+++ b/proposals/poc/smst-phase-6.md
@@ -0,0 +1,116 @@
+# Phase 6: Security Verification
+
+Verified SMST implementation provides cryptographic guarantees against duplicate attacks.
+
+## Security Properties
+
+### Duplicate Prevention
+
+The SMST structure inherently prevents duplicates by using the nonce as the path determinant.
+
+- `Insert(nonce, ...)` checks `hasNonce` map for immediate duplicate rejection
+- Structurally, a nonce `N` maps to a unique path `P`. It is impossible to store two different values for nonce `N` in the same tree
+- Verification `VerifySMSTProofWithCounts` reconstructs the path based on the claimed nonce. If an attacker tries to store nonce `N` at path `P'` (to duplicate it), the verification will fail because it will attempt to traverse path `P`
+
+### Count Inflation Prevention
+
+The attack where a malicious participant claims a higher count (e.g., 100) than actual artifacts (e.g., 50) is prevented by the Merkle Sum Tree properties.
+
+1. Count Commitment: The root hash includes the total `count` of leaves via `H_root = Hash(left, right, count)`. To claim `Count=100`, the attacker must provide a root hash that corresponds to a tree with 100 items.
+
+2. Index Binding: The verifier requests an artifact at a specific dense index `i`. `VerifySMSTProofWithDenseIndex` verifies that the provided proof actually leads to the `i`-th non-empty leaf by summing the counts of left siblings along the path.
+
+3. Since sibling counts are committed in the node hashes, the attacker cannot forge the index without changing the root hash.
+
+### Verified Index Logic
+
+The function `VerifySMSTProofWithDenseIndex` in `smst_verify.go` implements the critical check:
+
+```go
+computedIndex := uint32(0)
+for i := 0; i < depth; i++ {
+    if path[i] {
+        computedIndex += elements[i].SiblingCount
+    }
+}
+return computedIndex == denseIndex
+```
+
+This ensures that if the validator asks for the 90th artifact, the proof must correspond to the 90th artifact in the tree committed to by `root_hash`.
+
+## Hardening Tests
+
+Added explicit attack scenario tests in `smst_test.go`:
+
+| Test | What it verifies |
+|:-----|:-----------------|
+| `TestSMSTCountInflationAttackFails` | Claiming higher count than actual leaves fails |
+| `TestSMSTProofWithWrongCountFails` | count-1, count+1 variations all fail verification |
+| `TestSMSTNonceHasUniqueDenseIndex` | Each nonce maps to exactly ONE dense index |
+| `TestSMSTNegativeNonces` | Negative int32 nonces handled correctly (depth expands to 32) |
+| `TestSMSTCountBoundaries` | Edge cases: count=0, denseIndex >= count, single leaf |
+
+These tests document the security properties and provide regression protection.
+
+## Verification
+
+All 44 SMST tests pass including 5 new security hardening tests.
+
+## Implementation Details
+
+### Proof Format
+
+Each proof element is exactly 36 bytes:
+```
+[sibling_hash (32 bytes)] [sibling_subtree_count (4 bytes, Little Endian)]
+```
+
+Proof elements are ordered from root to leaf. The verifier infers tree depth from proof length.
+
+### Root Reconstruction
+
+1. Start with `currentHash = hash(0x00 || leafData)`, `currentCount = 1`
+2. For each proof level (leaf to root):
+   - Determine direction from nonce path bit
+   - Combine: `currentHash = hash(0x01 || leftHash || rightHash || combinedCount)`
+   - Accumulate: `currentCount = myCount + siblingCount`
+3. Verify: `currentCount == claimed_count` AND `currentHash == claimed_root`
+
+### Dense Index Binding
+
+After root verification, compute the dense index from sibling counts:
+```
+computedIndex = 0
+for level in 0..depth:
+    if nonce_path[level] is RIGHT:
+        computedIndex += sibling_count[level]
+return computedIndex == claimed_dense_index
+```
+
+The `computedIndex` equals the count of leaves with nonces numerically smaller than the current nonce. Sibling counts are committed by the root hash, making index binding cryptographically sound.
+
+### Snapshot Consistency
+
+The proof endpoint must serve artifacts and proofs from the same snapshot tree state. Unlike MMR where leaf positions were stable, SMST dense indices change as leaves are added.
+
+The interface enforces this with a single read method:
+```go
+GetArtifactAndProof(denseIndex, snapshotCount uint32) (nonce int32, vector []byte, proof [][]byte, error)
+```
+
+Separate `GetArtifact`/`GetProof` methods are intentionally omitted to prevent mixing tree states.
+
+### Verifier Hardening
+
+`VerifySMSTProofWithDenseIndex` uses:
+- `uint64` accumulator for overflow protection
+- Explicit `count == 0` rejection
+- Defense-in-depth bounds checking during accumulation
+
+## Conclusion
+
+The SMST implementation provides cryptographic guarantees against:
+
+- Duplicate Nonces: Structural impossibility (one slot per nonce)
+- Count Inflation: Detected by sibling count commitment in root hash
+- Index Swapping: Detected by path-to-nonce verification
diff --git a/proxy-ssl/Dockerfile b/proxy-ssl/Dockerfile
index fb8c695ef6..226a4b6ced 100644
--- a/proxy-ssl/Dockerfile
+++ b/proxy-ssl/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.24-alpine AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 
 # Install build dependencies
 RUN apk add --no-cache git ca-certificates tzdata
diff --git a/proxy-ssl/Makefile b/proxy-ssl/Makefile
index b3a96db6f4..f9921b1b87 100644
--- a/proxy-ssl/Makefile
+++ b/proxy-ssl/Makefile
@@ -7,8 +7,9 @@ SET_LATEST ?= 0
 SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
 PLATFORMS ?= linux/amd64,linux/arm64
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
 ifeq ($(USE_REGISTRY_CACHE),1)
-DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/proxy-ssl:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/proxy-ssl:buildcache,mode=min
+DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/proxy-ssl:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/proxy-ssl:buildcache,mode=min
 DOCKER_BUILD_PREFIX := docker buildx build --load $(DOCKER_CACHE_ARGS)
 else
 DOCKER_CACHE_ARGS :=
diff --git a/proxy/Dockerfile b/proxy/Dockerfile
index 289a1fe2ea..5db910c9d1 100644
--- a/proxy/Dockerfile
+++ b/proxy/Dockerfile
@@ -1,12 +1,12 @@
 # Build Stage for Sidecar
-FROM golang:1.24-alpine AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 WORKDIR /app
 COPY sidecar/main.go .
 # Build static binary
 RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o sidecar main.go
 
 # Final Stage
-FROM nginx:1.28-alpine
+FROM nginx:1.28-alpine3.21
 
 # Install curl, gettext (for envsubst), jq, bash (for setup-ssl.sh), and
 # apache2-utils (htpasswd for observability UI basic auth).
diff --git a/proxy/Makefile b/proxy/Makefile
index 10ef70a8bb..95846d912e 100644
--- a/proxy/Makefile
+++ b/proxy/Makefile
@@ -7,8 +7,9 @@ SET_LATEST ?= 0
 SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
 PLATFORMS ?= linux/amd64,linux/arm64
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
 ifeq ($(USE_REGISTRY_CACHE),1)
-DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/proxy:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/proxy:buildcache,mode=min
+DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/proxy:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/proxy:buildcache,mode=min
 DOCKER_BUILD_PREFIX := docker buildx build --load $(DOCKER_CACHE_ARGS)
 else
 DOCKER_CACHE_ARGS :=
diff --git a/proxy/nginx.unified.conf.template b/proxy/nginx.unified.conf.template
index b73406c2d3..76a2e2db83 100644
--- a/proxy/nginx.unified.conf.template
+++ b/proxy/nginx.unified.conf.template
@@ -100,8 +100,7 @@ http {
 
     # Versiond upstream - only included if VERSIOND_SERVICE_NAME is set.
     # Routes /devshard/<version>/* to versiond which forwards to the matching
-    # devshard binary. /v1/devshard/* still goes to the api backend (legacy
-    # in-process HostManager).
+    # devshard binary.
     ${VERSIOND_UPSTREAM}
 
     # Enable gzip compression
diff --git a/scripts/upgrade-rehearsal/prepare_previous_images.sh b/scripts/upgrade-rehearsal/prepare_previous_images.sh
new file mode 100755
index 0000000000..88adc19a64
--- /dev/null
+++ b/scripts/upgrade-rehearsal/prepare_previous_images.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+pull_and_tag() {
+  local source_image="$1"
+  local target_image="$2"
+
+  if [[ -z "${source_image}" || -z "${target_image}" ]]; then
+    return 0
+  fi
+
+  echo "Pulling ${source_image}"
+  docker pull "${source_image}"
+  echo "Tagging ${source_image} as ${target_image}"
+  docker tag "${source_image}" "${target_image}"
+}
+
+pull_and_tag "${PREVIOUS_NODE_IMAGE:-}" "${TARGET_NODE_IMAGE:-ghcr.io/product-science/inferenced}"
+pull_and_tag "${PREVIOUS_API_IMAGE:-}" "${TARGET_API_IMAGE:-ghcr.io/product-science/api}"
+pull_and_tag "${PREVIOUS_PROXY_IMAGE:-}" "${TARGET_PROXY_IMAGE:-ghcr.io/product-science/proxy:latest}"
+pull_and_tag "${PREVIOUS_VERSIOND_IMAGE:-}" "${TARGET_VERSIOND_IMAGE:-versiond:latest}"
+
+echo "Prepared previous release images:"
+docker images | grep -E 'product-science/(inferenced|api|proxy)|versiond' || true
diff --git a/scripts/upgrade-rehearsal/resolve_previous_images.py b/scripts/upgrade-rehearsal/resolve_previous_images.py
new file mode 100755
index 0000000000..a71c5ab477
--- /dev/null
+++ b/scripts/upgrade-rehearsal/resolve_previous_images.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Read production image references from a previous release deploy compose file."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+from pathlib import Path
+
+
+SERVICE_RE = re.compile(r"^  ([A-Za-z0-9_-]+):\s*(?:#.*)?$")
+IMAGE_RE = re.compile(r"^\s+image:\s*([^#\s]+)")
+
+LOCAL_TARGETS = {
+    "node": "ghcr.io/product-science/inferenced",
+    "api": "ghcr.io/product-science/api",
+    "proxy": "ghcr.io/product-science/proxy:latest",
+    "versiond": "versiond:latest",
+}
+
+
+def parse_service_images(compose_file: Path) -> dict[str, str]:
+    images: dict[str, str] = {}
+    current_service: str | None = None
+    for raw_line in compose_file.read_text().splitlines():
+        service_match = SERVICE_RE.match(raw_line)
+        if service_match:
+            current_service = service_match.group(1)
+            continue
+
+        image_match = IMAGE_RE.match(raw_line)
+        if image_match and current_service:
+            images[current_service] = image_match.group(1).strip()
+
+    return images
+
+
+def write_outputs(values: dict[str, str]) -> None:
+    output_file = os.environ.get("GITHUB_OUTPUT")
+    if output_file:
+        with open(output_file, "a", encoding="utf-8") as handle:
+            for key, value in values.items():
+                handle.write(f"{key}={value}\n")
+
+    for key, value in values.items():
+        print(f"{key}={value}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--compose", required=True, help="path to previous release deploy/join/docker-compose.yml")
+    args = parser.parse_args()
+
+    compose_file = Path(args.compose).resolve()
+    images = parse_service_images(compose_file)
+
+    missing = [service for service in ("node", "api") if service not in images]
+    if missing:
+        raise RuntimeError(f"missing required service image(s) in {compose_file}: {', '.join(missing)}")
+
+    outputs: dict[str, str] = {}
+    for service, target in LOCAL_TARGETS.items():
+        image = images.get(service, "")
+        outputs[f"{service}_image"] = image
+        outputs[f"{service}_target_image"] = target
+
+    write_outputs(outputs)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/upgrade-rehearsal/resolve_versions.py b/scripts/upgrade-rehearsal/resolve_versions.py
new file mode 100755
index 0000000000..ee47815e60
--- /dev/null
+++ b/scripts/upgrade-rehearsal/resolve_versions.py
@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""Resolve the target upgrade and previous canonical release tag."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+SEMVER_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)$")
+CANONICAL_RELEASE_RE = re.compile(r"^release/v(\d+)\.(\d+)\.(\d+)$")
+UPGRADE_NAME_RE = re.compile(r'UpgradeName\s*=\s*"([^"]+)"')
+
+
+@dataclass(frozen=True, order=True)
+class SemVer:
+    major: int
+    minor: int
+    patch: int
+
+    @classmethod
+    def parse(cls, value: str) -> "SemVer":
+        match = SEMVER_RE.match(value)
+        if not match:
+            raise ValueError(f"not a semantic version: {value}")
+        return cls(*(int(part) for part in match.groups()))
+
+    def with_v(self) -> str:
+        return f"v{self.major}.{self.minor}.{self.patch}"
+
+    def without_v(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+
+def run_git(repo: Path, *args: str) -> str:
+    return subprocess.check_output(["git", "-C", str(repo), *args], text=True).strip()
+
+
+def normalize_upgrade(value: str) -> tuple[str, SemVer]:
+    cleaned = value.strip()
+    if cleaned.startswith("release/"):
+        cleaned = cleaned[len("release/") :]
+    version = SemVer.parse(cleaned)
+    return version.with_v(), version
+
+
+def normalize_release(value: str) -> tuple[str, SemVer]:
+    cleaned = value.strip()
+    if cleaned.startswith("release/"):
+        cleaned = cleaned[len("release/") :]
+    upgrade, version = normalize_upgrade(cleaned)
+    return f"release/{upgrade}", version
+
+
+def discover_target_upgrade(repo: Path) -> tuple[str, SemVer]:
+    candidates: list[tuple[SemVer, str, Path]] = []
+    upgrades_dir = repo / "inference-chain" / "app" / "upgrades"
+    for constants_file in upgrades_dir.glob("*/constants.go"):
+        text = constants_file.read_text()
+        match = UPGRADE_NAME_RE.search(text)
+        if not match:
+            continue
+        name = match.group(1)
+        try:
+            upgrade, version = normalize_upgrade(name)
+        except ValueError:
+            continue
+        candidates.append((version, upgrade, constants_file))
+
+    if not candidates:
+        raise RuntimeError(f"no semantic UpgradeName constants found under {upgrades_dir}")
+
+    _, upgrade, source = max(candidates, key=lambda item: item[0])
+    print(f"Discovered target upgrade {upgrade} from {source}", file=sys.stderr)
+    return normalize_upgrade(upgrade)
+
+
+def canonical_release_tags(repo: Path) -> list[tuple[SemVer, str]]:
+    tags = run_git(repo, "tag", "--list", "release/v*").splitlines()
+    releases: list[tuple[SemVer, str]] = []
+    for tag in tags:
+        match = CANONICAL_RELEASE_RE.match(tag)
+        if not match:
+            continue
+        version = SemVer(*(int(part) for part in match.groups()))
+        releases.append((version, tag))
+    return sorted(releases)
+
+
+def write_outputs(values: dict[str, str]) -> None:
+    output_file = os.environ.get("GITHUB_OUTPUT")
+    if output_file:
+        with open(output_file, "a", encoding="utf-8") as handle:
+            for key, value in values.items():
+                handle.write(f"{key}={value}\n")
+
+    for key, value in values.items():
+        print(f"{key}={value}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--repo", default=".", help="candidate repository checkout")
+    parser.add_argument("--target-upgrade", default="", help="override target upgrade, e.g. v0.2.14")
+    parser.add_argument("--previous-release", default="", help="override previous release, e.g. release/v0.2.13")
+    args = parser.parse_args()
+
+    repo = Path(args.repo).resolve()
+    if args.target_upgrade.strip():
+        target_upgrade, target_version = normalize_upgrade(args.target_upgrade)
+    else:
+        target_upgrade, target_version = discover_target_upgrade(repo)
+
+    if args.previous_release.strip():
+        previous_release, previous_version = normalize_release(args.previous_release)
+    else:
+        candidates = [
+            (version, tag)
+            for version, tag in canonical_release_tags(repo)
+            if version < target_version
+        ]
+        if not candidates:
+            raise RuntimeError(f"no canonical release tag found before {target_upgrade}")
+        previous_version, previous_release = candidates[-1]
+
+    if previous_version >= target_version:
+        raise RuntimeError(
+            f"previous release {previous_release} must be lower than target upgrade {target_upgrade}"
+        )
+
+    write_outputs(
+        {
+            "target_upgrade": target_upgrade,
+            "target_version": target_version.without_v(),
+            "target_release": f"release/{target_upgrade}",
+            "previous_upgrade": previous_version.with_v(),
+            "previous_version": previous_version.without_v(),
+            "previous_release": previous_release,
+        }
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/skills/upgrade-bootstrap/SKILL.md b/skills/upgrade-bootstrap/SKILL.md
new file mode 100644
index 0000000000..3d775a3ca9
--- /dev/null
+++ b/skills/upgrade-bootstrap/SKILL.md
@@ -0,0 +1,205 @@
+---
+name: upgrade-bootstrap
+description: Bootstrap a new Gonka full automatic upgrade train for inference-chain and decentralized-api only. Use when the user wants to start a new upgrade branch from the latest main, scaffold the matching chain upgrade handler, make the initial bootstrap commit, and open the canonical draft PR against main. Do not use for MLNode-only or devshard-only work, release rollout, governance voting, or post-upgrade merge steps.
+---
+
+# Upgrade Bootstrap
+
+This skill bootstraps an upgrade train. It does not finish one.
+
+Use it only for the special full automatic upgrade flow that covers:
+
+- `inference-chain`
+- `decentralized-api`
+
+Do not use this skill for:
+
+- MLNode upgrades
+- devshard upgrades
+- ad hoc API-only rollouts
+- release publishing
+- governance voting
+- testnet rollout
+- merge or post-upgrade cleanup
+
+## Required input
+
+The caller must provide the target version in exact `vX.Y.Z` form.
+
+Everything else is derived from that one string:
+
+- branch: `upgrade-vX.Y.Z`
+- upgrade package dir: `inference-chain/app/upgrades/vX_Y_Z/`
+- Go package: `vX_Y_Z`
+- upgrade constant: `UpgradeName = "vX.Y.Z"`
+- draft PR title: `Upgrade vX.Y.Z`
+
+If the caller gives a partial version, a branch name without the `v`, or any
+other approximate form, normalize only after confirming the exact target
+version.
+
+## Goal
+
+Produce the canonical starting point for the upgrade train:
+
+1. branch from the latest `main`
+2. scaffold the minimal chain upgrade handler
+3. make one bootstrap commit
+4. open a draft PR against `main`
+5. stop
+
+That draft PR is the coordination anchor for the rest of the upgrade work.
+
+## Safety rules
+
+- Always branch from the latest `main`, not from the current branch and not
+  from an older upgrade branch.
+- Prefer non-interactive git commands.
+- If local work prevents switching to `main` or fast-forwarding it cleanly, do
+  not bulldoze through it. Pause and ask the user how to proceed.
+- Never include MLNode or devshard work in this bootstrap unless the caller
+  explicitly broadens scope.
+- Keep the initial scaffold intentionally small. Do not start implementing the
+  actual upgrade features unless the caller asks.
+
+## Bootstrap workflow
+
+### 1. Prepare the branch
+
+Start from the latest `main`:
+
+```bash
+git fetch origin
+git switch main
+git pull --ff-only origin main
+git switch -c upgrade-vX.Y.Z
+```
+
+If the repo is dirty and switching branches would disturb local work, stop and
+ask before proceeding.
+
+### 2. Scaffold the upgrade handler
+
+Create the minimal handler scaffold modeled after the current tracked-upgrade
+pattern.
+Touch only the upgrade-registration surface:
+
+- `inference-chain/app/upgrades.go`
+- `inference-chain/app/upgrades/vX_Y_Z/constants.go`
+- `inference-chain/app/upgrades/vX_Y_Z/upgrades.go`
+- `inference-chain/app/upgrades/vX_Y_Z/upgrades_test.go`
+
+Do the following:
+
+- Add the new import in `inference-chain/app/upgrades.go`
+- Register the handler in `setupUpgradeHandlers()` using
+  `app.setTrackedUpgradeHandler(...)`, not raw `SetUpgradeHandler(...)`
+- Create `constants.go` with the exact on-chain upgrade name
+- Create `upgrades.go` with a minimal handler that:
+  - logs start and success
+  - fixes missing `capability` version in `fromVM`
+  - runs `mm.RunMigrations(...)`
+  - does nothing else yet
+- Create `upgrades_test.go` with a test that pins `UpgradeName` exactly
+
+The initial scaffold should not:
+
+- add real migration logic
+- bump module `ConsensusVersion`
+- register empty migrations in `registerMigrations()`
+- create proposal/release/governance artifact docs
+- modify join-stack image tags
+
+Those belong to later upgrade work, not to bootstrap.
+
+The registration helper matters: it keeps `LastUpgradeHeight` tracking attached
+to every software upgrade handler automatically. Do not bypass it unless the
+upgrade work is intentionally changing that behavior.
+
+### 3. Keep the scaffold comments useful
+
+The scaffold should explain the contract briefly:
+
+- `UpgradeName` must exactly match the future on-chain proposal name
+- future migration steps belong below the capability-version fix and above
+  `RunMigrations`
+- if later work bumps a module `ConsensusVersion`, that later work must also
+  register the corresponding migration in `registerMigrations()`
+
+Keep these comments short and operational.
+
+### 4. Verify only the bootstrap surface
+
+Run a narrow test for the new package. When using Go commands, always go
+through `zsh -lc` so the shell loads the Go environment.
+
+Example:
+
+```bash
+cd inference-chain
+zsh -lc 'go test ./app/upgrades/vX_Y_Z'
+```
+
+If the new package needs broader verification because of compile-time
+registration issues, extend to the smallest useful check. Do not turn bootstrap
+into a full upgrade test pass.
+
+### 5. Make the initial bootstrap commit
+
+Use a focused commit message. Default:
+
+```text
+chore(upgrade): scaffold vX.Y.Z upgrade handler
+```
+
+Stage only the scaffold files and commit them. Do not mix unrelated work into
+this commit.
+
+### 6. Push and open the draft PR
+
+Push the new branch and open a draft PR against `main`.
+
+The PR is the canonical upgrade thread. It should exist immediately after the
+bootstrap commit so future work has one shared place for review and scope.
+
+Default PR title:
+
+```text
+Upgrade vX.Y.Z
+```
+
+Default PR body should be short and clearly marked as bootstrap. Include:
+
+- that this is the draft upgrade train for the full automatic `inference-chain`
+  + `decentralized-api` upgrade
+- that the branch currently contains only the initial upgrade-handler scaffold
+- that later commits on this branch will accumulate the actual upgrade changes
+- that MLNode and devshard work are out of scope for this PR unless explicitly
+  added later
+
+Do not pad the PR with release, voting, or rollout instructions.
+
+If GitHub connector tools are available, prefer them for PR creation. Otherwise
+use a non-interactive `gh pr create --draft ...` flow.
+
+## Stop condition
+
+Stop as soon as all of the following exist:
+
+- local branch `upgrade-vX.Y.Z`
+- minimal handler scaffold in `inference-chain/app/upgrades/vX_Y_Z/`
+- one bootstrap commit
+- pushed branch
+- draft PR against `main`
+
+Do not continue into feature implementation unless the caller explicitly asks.
+
+## Report back
+
+When finished, report:
+
+- branch name
+- bootstrap commit hash
+- test command run
+- draft PR URL
+- any blocker or deviation from the standard bootstrap flow
diff --git a/testermint/src/main/kotlin/ApplicationAPI.kt b/testermint/src/main/kotlin/ApplicationAPI.kt
index ee78a87b71..b4896a472d 100644
--- a/testermint/src/main/kotlin/ApplicationAPI.kt
+++ b/testermint/src/main/kotlin/ApplicationAPI.kt
@@ -491,15 +491,6 @@ data class ApplicationAPI(
         get(url, "admin/v1/config")
     }
 
-    fun getDevshardMempool(escrowId: Long): DevshardMempoolResponse = wrapLog("GetDevshardMempool", false) {
-        val url = urlFor(SERVER_TYPE_PUBLIC)
-        val resp = Fuel.get("$url/v1/devshard/sessions/$escrowId/mempool")
-            .timeoutRead(1000 * 30)
-            .responseObject<DevshardMempoolResponse>(gsonDeserializer(cosmosJson))
-        logResponse(resp)
-        resp.third.get()
-    }
-
 }
 
 // Retry helper for transient 502 Bad Gateway errors during cluster boot.
diff --git a/testermint/src/main/kotlin/ApplicationCLI.kt b/testermint/src/main/kotlin/ApplicationCLI.kt
index 22756ddee2..ae1c396267 100644
--- a/testermint/src/main/kotlin/ApplicationCLI.kt
+++ b/testermint/src/main/kotlin/ApplicationCLI.kt
@@ -156,6 +156,10 @@ data class ApplicationCLI(
         execAndParse(listOf("query", "inference", "list-inference-timeout"))
     }
 
+    fun listClaimRecipients(participant: String): ClaimRecipientsResponse = wrapLog("listClaimRecipients", false) {
+        execAndParse(listOf("query", "inference", "list-claim-recipients", participant))
+    }
+
     fun getParticipantCurrentStats(): ParticipantStatsResponse = wrapLog("getParticipantCurrentStats", false) {
         execAndParse(listOf("query", "inference", "get-all-participant-current-stats"))
     }
@@ -178,6 +182,15 @@ data class ApplicationCLI(
         execAndParse(listOf("query", "inference", "ml-node-version"))
     }
 
+    fun getLastUpgradeHeight(): LastUpgradeHeightQueryResponse = wrapLog("getLastUpgradeHeight", infoLevel = false) {
+        val canonicalExecName = "${config.stateDirName}/cosmovisor/current/bin/${config.appName}"
+        val command = "$canonicalExecName query inference last-upgrade-height --output json"
+        Logger.debug("Executing shell command for last-upgrade-height: {}", command)
+        val output = exec(listOf("/bin/sh", "-lc", command)).joinToString("")
+        Logger.debug("Output: {}", output)
+        cosmosJson.fromJson(output, LastUpgradeHeightQueryResponse::class.java)
+    }
+
     var coldAccountKey: Validator? = null
     var warmAccountKey: Validator? = null
 
@@ -434,7 +447,11 @@ data class ApplicationCLI(
         return cosmosJson.fromJson(output, T::class.java)
     }
 
-    fun execCli(args: List<String>, includeOutputFlag: Boolean = true, stdIn: String? = null): String {
+    fun execCli(
+        args: List<String>,
+        includeOutputFlag: Boolean = true,
+        stdIn: String? = null
+    ): String {
         val argsWithJson = listOf(config.execName) +
                 args + if (includeOutputFlag) listOf("--output", "json") else emptyList()
         Logger.debug("Executing command: {}", argsWithJson.joinToString(" "))
@@ -497,7 +514,12 @@ data class ApplicationCLI(
             operationAccountAddress) + getTransactionArgs(coldAccountName)
         val response = this.exec(commands, passwordInjection)
         val fullResponse = response.joinToString("\n")
-        if (!fullResponse.contains("Transaction confirmed successfully!")) {
+        val alreadyGranted =
+            response.any {
+                it.contains("fee allowance already exists") ||
+                    it.contains("authorization already exists")
+            }
+        if (!fullResponse.contains("Transaction confirmed successfully!") && !alreadyGranted) {
             if ((fullResponse.contains(NOT_READY_MESSAGE) || fullResponse.contains("not found: key not found")) && retries > 0) {
                 Thread.sleep(Duration.ofSeconds(5))
                 this.grantMlOpsPermissionsToWarmAccount(retries-1)
@@ -674,6 +696,25 @@ data class ApplicationCLI(
         return execAndParse(finalArgs, stdIn = passwordInjection)
     }
 
+    fun setClaimRecipients(entriesJson: String, from: String = getColdAccountName(), node: String? = null): TxResponse =
+        wrapLog("setClaimRecipients", true) {
+            val nodeArgs = node?.let { listOf("--node", it) } ?: emptyList()
+            val finalArgs = listOf(config.execName, "tx", "inference", "set-claim-recipients", entriesJson) +
+                getTransactionArgs(from) + nodeArgs + listOf("--output", "json")
+            val command = if (passwordInjection != null) {
+                "printf '%s' ${shellQuote(passwordInjection)} | ${finalArgs.joinToString(" ") { shellQuote(it) }}"
+            } else {
+                finalArgs.joinToString(" ") { shellQuote(it) }
+            }
+            val output = exec(listOf("/bin/sh", "-lc", command)).joinToString("")
+            val txResponse = cosmosJson.fromJson(output, TxResponse::class.java)
+            if (txResponse.code == 0) {
+                waitForTxProcessed(txResponse.txhash)
+            } else {
+                txResponse
+            }
+        }
+
     private fun getTransactionArgs(from: String): List<String> = listOf(
         "--keyring-backend",
         this.config.keyringBackend,
@@ -690,6 +731,9 @@ data class ApplicationCLI(
         from
     )
 
+    private fun shellQuote(arg: String): String =
+        "'" + arg.replace("'", "'\\''") + "'"
+
     // Returns getTransactionArgs with gas-adjustment replaced by a fixed gas
     // and a --fees flag added. Used by tests that need to assert specific
     // fee values (e.g., TransactionFeeTests verifying fee rejection).
diff --git a/testermint/src/main/kotlin/DevshardVersiondTestConfig.kt b/testermint/src/main/kotlin/DevshardVersiondTestConfig.kt
index f3fa665d9d..d78dd146ce 100644
--- a/testermint/src/main/kotlin/DevshardVersiondTestConfig.kt
+++ b/testermint/src/main/kotlin/DevshardVersiondTestConfig.kt
@@ -1,6 +1,9 @@
 package com.productscience
 
 import com.github.kittinunf.fuel.Fuel
+import com.productscience.data.AppState
+import com.productscience.data.Spec
+import com.productscience.data.spec
 import org.tinylog.kotlin.Logger
 import java.nio.file.Files
 import java.nio.file.Path
@@ -112,6 +115,26 @@ fun versiondOverrideEnv(version: String = devshardTestVersion()): Map<String, St
 fun devshardVersionedRoutePrefix(version: String = devshardTestVersion()): String =
     "/devshard/$version"
 
+fun devshardVersiondComposeFilesByPairName(
+    pairNames: List<String> = listOf(GENESIS_KEY_NAME, "join1", "join2"),
+): Map<String, List<String>> =
+    pairNames.associateWith { listOf("docker-compose.versiond.yml") }
+
+fun devshardVersiondConfig(
+    genesisSpec: Spec<AppState>,
+    env: Map<String, String>,
+    pairNames: List<String> = listOf(GENESIS_KEY_NAME, "join1", "join2"),
+): ApplicationConfig = inferenceConfig.copy(
+    genesisSpec = genesisSpec,
+    additionalDockerFilesByKeyName = devshardVersiondComposeFilesByPairName(pairNames),
+    additionalEnvVars = env,
+)
+
+fun mergedDevshardGenesisSpec(vararg specs: Spec<AppState>): Spec<AppState> {
+    val base = inferenceConfig.genesisSpec ?: spec<AppState> {}
+    return specs.fold(base) { current, extra -> current.merge(extra) }
+}
+
 /**
  * [local-test-net/docker-compose.versiond.yml] only declares `VERSIOND_OVERRIDE_dev` for
  * compose substitution. Other version names need an explicit service env entry.
diff --git a/testermint/src/main/kotlin/DockerExecutor.kt b/testermint/src/main/kotlin/DockerExecutor.kt
index c31d372dd9..0ca17a201a 100644
--- a/testermint/src/main/kotlin/DockerExecutor.kt
+++ b/testermint/src/main/kotlin/DockerExecutor.kt
@@ -1,5 +1,6 @@
 package com.productscience
 
+import com.github.dockerjava.api.exception.NotFoundException
 import com.github.dockerjava.api.model.Volume
 import com.github.dockerjava.core.DockerClientBuilder
 import com.github.dockerjava.okhttp.OkDockerHttpClient
@@ -8,25 +9,46 @@ import java.net.URI
 import java.time.Duration
 import java.util.concurrent.TimeUnit
 
-data class DockerExecutor(val containerId: String, val config: ApplicationConfig) : CliExecutor {
+class DockerExecutor(val containerId: String, val config: ApplicationConfig) : CliExecutor {
     private val dockerClient = DockerClientBuilder.getInstance().build()
+    @Volatile
+    private var currentContainerId: String = containerId
         
     override fun exec(args: List<String>, stdin: String?): List<String> {
+        try {
+            return execWithContainer(currentContainerId, args, stdin)
+        } catch (e: NotFoundException) {
+            val refreshedContainerId = refreshContainerId()
+            if (refreshedContainerId == null || refreshedContainerId == currentContainerId) {
+                throw e
+            }
+            Logger.warn(
+                "Docker exec hit stale container ID {}, retrying with {} for pair {}",
+                currentContainerId,
+                refreshedContainerId,
+                config.pairName
+            )
+            currentContainerId = refreshedContainerId
+            return execWithContainer(currentContainerId, args, stdin)
+        }
+    }
+
+    private fun execWithContainer(targetContainerId: String, args: List<String>, stdin: String?): List<String> {
         val output = ExecCaptureOutput()
         Logger.trace("Executing command: {}", args.joinToString(" "))
-        
+
         val execCmd = if (stdin != null) {
             // Use shell to pass stdin via printf
-            val stdinEscaped = stdin.replace("'", "'\\''")  // Escape single quotes
+            val stdinEscaped = stdin.replace("'", "'\\''")
             val fullCommand = "printf '%s' '$stdinEscaped' | ${args.joinToString(" ")}"
-            dockerClient.execCreateCmd(containerId)
+            dockerClient.execCreateCmd(targetContainerId)
                 .withAttachStdout(true)
                 .withAttachStderr(true)
                 .withAttachStdin(false)
                 .withTty(false)
                 .withCmd("/bin/sh", "-c", fullCommand)
         } else {
-            dockerClient.execCreateCmd(containerId)
+            dockerClient.execCreateCmd(targetContainerId)
                 .withAttachStdout(true)
                 .withAttachStderr(true)
                 .withAttachStdin(false)
@@ -47,6 +69,19 @@ data class DockerExecutor(val containerId: String, val config: ApplicationConfig
         return output.output
     }
 
+    private fun refreshContainerId(): String? {
+        val candidateNames = setOf(
+            "/${config.pairName}-node",
+            "${config.pairName}-node"
+        )
+
+        return dockerClient.listContainersCmd().exec()
+            .firstOrNull { container ->
+                container.names.any { it in candidateNames }
+            }
+            ?.id
+    }
+
     override fun kill() {
         Logger.info("Killing container, id={}", containerId)
         dockerClient.killContainerCmd(containerId).exec()
@@ -76,4 +111,4 @@ data class DockerExecutor(val containerId: String, val config: ApplicationConfig
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/testermint/src/main/kotlin/DockerGroup.kt b/testermint/src/main/kotlin/DockerGroup.kt
index 1b472cf9a8..fe6cf2700b 100644
--- a/testermint/src/main/kotlin/DockerGroup.kt
+++ b/testermint/src/main/kotlin/DockerGroup.kt
@@ -88,7 +88,7 @@ val NODE_COMPOSE_FILES = BASE_COMPOSE_FILES + "${LOCAL_TEST_NET_DIR}/docker-comp
 data class GenesisUrls(val keyName: String) {
     val apiUrl = "http://$keyName-api:9000"
     val rpcUrl = "http://$keyName-node:26657"
-    val p2pUrl = "http://$keyName-node:26656"
+    val p2pUrl = "tcp://$keyName-node:26656"
 }
 
 data class DockerGroup(
@@ -110,15 +110,14 @@ data class DockerGroup(
     val genesisOverridesFile: String,
     // publicUrl is what dapi registers on chain as its participant.inference_url.
     // Mirrors production: chain points at the per-pair proxy, which routes
-    // /v1/devshard/* to dapi (legacy in-process HostManager via the exempt
-    // route mechanism) and /devshard/<version>/* to versiond when configured.
+    // /devshard/<version>/* to versiond when configured.
     val publicUrl: String = "http://$pairName-proxy",
     // pocCallbackUrl stays direct -- it's an internal mlnode -> dapi callback
     // on the ML server port, never routed through nginx.
     val pocCallbackUrl: String = "http://$pairName-api:9100",
     val config: ApplicationConfig,
     val useSnapshots: Boolean,
-    val p2pExternalAddress: String = "http://$pairName-node:26656",
+    val p2pExternalAddress: String = "$pairName-node:26656",
 ) {
     val warmKeyName = "$pairName-WARM"
     val coldKeyName = pairName
diff --git a/testermint/src/main/kotlin/Epochs.kt b/testermint/src/main/kotlin/Epochs.kt
index 6ed5ed4413..6661ca48a7 100644
--- a/testermint/src/main/kotlin/Epochs.kt
+++ b/testermint/src/main/kotlin/Epochs.kt
@@ -13,6 +13,14 @@ enum class EpochStage {
     CLAIM_REWARDS
 }
 
+const val INFERENCE_STAGE_SLACK_BLOCKS = 3L
+
+data class StageSafeInferenceBlock(
+    val block: Long,
+    val inferenceWindowStart: Long,
+    val nextPocStart: Long,
+)
+
 fun EpochResponse.getNextStage(stage: EpochStage): Long {
     return when (stage) {
         EpochStage.START_OF_POC -> resolveUpcomingStage(epochStages.pocStart, nextEpochStages.pocStart)
@@ -34,6 +42,36 @@ fun EpochResponse.resolveUpcomingStage(latestEpochStage: Long, nextEpochStage: L
     }
 }
 
+fun EpochResponse.findStageSafeInferenceBlock(
+    earliestBlock: Long,
+    minimumSlackBeforeNextPoc: Long = INFERENCE_STAGE_SLACK_BLOCKS,
+): StageSafeInferenceBlock? {
+    require(minimumSlackBeforeNextPoc >= 0) { "minimumSlackBeforeNextPoc must be non-negative" }
+
+    val epochLength = nextEpochStages.pocStart - epochStages.pocStart
+    require(epochLength > 0) { "epoch stages must advance across epochs" }
+
+    val firstInferenceWindowStart = epochStages.claimMoney + 1
+    val firstInferenceWindowNextPoc = epochStages.nextPocStart
+    val firstCandidateWindowIndex = maxOf(0L, (earliestBlock - firstInferenceWindowStart) / epochLength)
+
+    for (windowIndex in firstCandidateWindowIndex..firstCandidateWindowIndex + 1) {
+        val windowStart = firstInferenceWindowStart + windowIndex * epochLength
+        val nextPocStart = firstInferenceWindowNextPoc + windowIndex * epochLength
+        val candidateBlock = maxOf(blockHeight + 1, earliestBlock, windowStart)
+        val latestSafeBlock = nextPocStart - minimumSlackBeforeNextPoc - 1
+        if (candidateBlock <= latestSafeBlock) {
+            return StageSafeInferenceBlock(
+                block = candidateBlock,
+                inferenceWindowStart = windowStart,
+                nextPocStart = nextPocStart,
+            )
+        }
+    }
+
+    return null
+}
+
 @Deprecated("Use EpochResponse.getNextStage instead. We keep it only to get the block when the very 1st validators are active.")
 fun EpochParams.getStage(stage: EpochStage): Long = when (stage) {
     EpochStage.START_OF_POC -> 0L
diff --git a/testermint/src/main/kotlin/LocalInferencePair.kt b/testermint/src/main/kotlin/LocalInferencePair.kt
index 8edf20b86a..540ddbfd3f 100644
--- a/testermint/src/main/kotlin/LocalInferencePair.kt
+++ b/testermint/src/main/kotlin/LocalInferencePair.kt
@@ -8,6 +8,7 @@ import com.github.dockerjava.api.model.*
 import com.github.dockerjava.core.DockerClientBuilder
 import com.github.kittinunf.fuel.core.FuelError
 import com.productscience.data.*
+import com.productscience.data.ProposalStatus
 import okhttp3.Address
 import org.tinylog.kotlin.Logger
 import java.io.BufferedReader
@@ -328,6 +329,8 @@ data class LocalInferencePair(
     var mostRecentParams: InferenceParams? = null,
     var mostRecentEpochData: EpochResponse? = null,
 ) : HasConfig {
+    private val terminalProposalStates = setOf(ProposalStatus.PASSED, ProposalStatus.REJECTED)
+
     /**
      * Gets an alternative API URL using DNS alias (api.{name}.test).
      * This URL:
@@ -360,6 +363,15 @@ data class LocalInferencePair(
         }
     }
 
+    fun restartApiContainer() {
+        val apiContainer = getRawContainers(config).getApi(name)
+            ?: error("API container not found for $name")
+        DockerClientBuilder.getInstance().build().use { dockerClient ->
+            Logger.warn("Restarting API container for {}", name)
+            dockerClient.restartContainerCmd(apiContainer.id).exec()
+        }
+    }
+
     private fun siblingContainerId(serviceName: String): String {
         val cleanName = name.trimStart('/')
         val expectedNames = setOf("$cleanName-$serviceName", "/$cleanName-$serviceName")
@@ -915,7 +927,21 @@ data class LocalInferencePair(
             logSection("Voting on proposal, no voters: ${noVoters.joinToString(", ")}")
             cluster.allPairs.forEach {
                 val voteResponse = it.voteOnProposal(proposalId, if (noVoters.contains(it.name)) "no" else "yes")
-                require(voteResponse.code == 0) { "Vote failed: ${voteResponse.rawLog}" }
+                if (voteResponse.code != 0) {
+                    val finalizedStatus = this.node.getGovernanceProposals().proposals
+                        .firstOrNull { proposal -> proposal.id == proposalId }
+                        ?.status
+                    val inactiveProposal = voteResponse.rawLog.contains("inactive proposal")
+                    val isTerminalProposalState = finalizedStatus in terminalProposalStates
+                    require(inactiveProposal && isTerminalProposalState) {
+                        "Vote failed: ${voteResponse.rawLog}"
+                    }
+                    Logger.info(
+                        "Skipping late vote for finalized proposal {} with status {}",
+                        proposalId,
+                        finalizedStatus
+                    )
+                }
             }
 
             logSection("Waiting for voting period to end")
@@ -961,17 +987,14 @@ data class LocalInferencePair(
         escrowId: Long,
         keyName: String? = null,
         port: Int = 18080 + escrowId.toInt(),
-        routePrefix: String? = null,
+        routePrefix: String,
         debugLogging: Boolean = false,
         model: String = defaultModel,
     ): DevshardProxyHandle =
         wrapLog("startDevshardProxy", true) {
             val privateKey = (if (keyName != null) node.getPrivateKey(keyName) else node.getColdPrivateKey()).trim()
             val stderrFile = devshardProxyLogPath(escrowId)
-            // Tests pin the route prefix explicitly so they are not coupled to
-            // devshardctl's release-default routing choice.
-            val effectiveRoutePrefix = routePrefix ?: "/v1/devshard"
-            val routePrefixEnv = " DEVSHARD_ROUTE_PREFIX='$effectiveRoutePrefix'"
+            val routePrefixEnv = " DEVSHARD_ROUTE_PREFIX='$routePrefix'"
             val logLevelEnv = if (debugLogging) " DEVSHARD_LOG_LEVEL=debug" else ""
             val startCommand = listOf(
                 "sh", "-c",
@@ -1031,12 +1054,12 @@ data class LocalInferencePair(
     }
 
     // Returns every inference the gateway knows about, keyed by inference id.
-    // Uses /v1/state (the per-runtime full state snapshot) which carries status and
-    // votes per inference.
+    // Uses /v1/debug/inferences (the full inference dump, split out of /v1/state)
+    // which carries status and votes per inference.
     fun getDevshardProxyInferences(proxyUrl: String): Map<Long, DevshardInferencePayload> {
         val raw = api.executor.exec(listOf(
             "sh", "-c",
-            "curl -sf $proxyUrl/v1/state -H 'Authorization: Bearer $devshardAdminApiKey'"
+            "curl -sf $proxyUrl/v1/debug/inferences -H 'Authorization: Bearer $devshardAdminApiKey'"
         ), null).joinToString("")
         val start = raw.indexOf('{')
         val end = raw.lastIndexOf('}')
diff --git a/testermint/src/main/kotlin/data/AppExport.kt b/testermint/src/main/kotlin/data/AppExport.kt
index 086d0694f9..7e0dd9e6b7 100644
--- a/testermint/src/main/kotlin/data/AppExport.kt
+++ b/testermint/src/main/kotlin/data/AppExport.kt
@@ -74,6 +74,8 @@ data class InferenceParams(
     val devshardEscrowParams: DevshardEscrowParams? = null,
     @SerializedName("fee_params")
     val feeParams: FeeParamsData? = null,
+    @SerializedName("maintenance_params")
+    val maintenanceParams: MaintenanceParams? = null,
     @SerializedName("delegation_params")
     val delegationParams: DelegationParams? = null,
 )
@@ -532,4 +534,35 @@ data class ExemptionUsageEntry(
     val accountAddress: String,
     @SerializedName("usage_count")
     val usageCount: Long,
-)
\ No newline at end of file
+)
+
+// -----------------------
+// Maintenance Window Parameters
+// -----------------------
+// Defaults below mirror the chain's Default* constants in
+// inference-chain/x/inference/types/params.go (DefaultMaintenanceEnabled,
+// DefaultMaintenanceMinScheduleLeadBlocks, DefaultMaintenanceMaxWindowBlocks,
+// DefaultMaintenanceMaxConcurrentValidators, DefaultMaintenanceMaxConcurrentPowerBps,
+// DefaultMaintenanceCreditCapBlocks, DefaultMaintenanceCreditEarnPerEpochBlocks).
+// Keep the two sides in lockstep — testermint exercises real chain genesis,
+// so any drift here will silently mask a bug rather than expose it.
+
+data class MaintenanceParams(
+    @SerializedName("maintenance_enabled")
+    val maintenanceEnabled: Boolean = false,
+    @SerializedName("maintenance_min_schedule_lead_blocks")
+    val maintenanceMinScheduleLeadBlocks: Long = 100,
+    @SerializedName("maintenance_max_window_blocks")
+    val maintenanceMaxWindowBlocks: Long = 200,
+    // Proto types are uint32 (range 0 .. 4_294_967_295). Kotlin Int is signed
+    // and would overflow at 2_147_483_648. Widen to Long so any governance
+    // value the chain accepts can round-trip without silent truncation.
+    @SerializedName("maintenance_max_concurrent_validators")
+    val maintenanceMaxConcurrentValidators: Long = 3,
+    @SerializedName("maintenance_max_concurrent_power_bps")
+    val maintenanceMaxConcurrentPowerBps: Long = 1000,
+    @SerializedName("maintenance_credit_cap_blocks")
+    val maintenanceCreditCapBlocks: Long = 400,
+    @SerializedName("maintenance_credit_earn_per_successful_epoch_blocks")
+    val maintenanceCreditEarnPerSuccessfulEpochBlocks: Long = 20,
+)
diff --git a/testermint/src/main/kotlin/data/Maintenance.kt b/testermint/src/main/kotlin/data/Maintenance.kt
new file mode 100644
index 0000000000..4452696e49
--- /dev/null
+++ b/testermint/src/main/kotlin/data/Maintenance.kt
@@ -0,0 +1,75 @@
+package com.productscience.data
+
+import com.google.gson.annotations.SerializedName
+
+// -----------------------
+// Maintenance Query Response Types
+// -----------------------
+
+data class MaintenanceCreditResponse(
+    @SerializedName("credit_blocks")
+    val creditBlocks: Long = 0,
+    val found: Boolean = false,
+)
+
+data class MaintenanceScheduledResponse(
+    val reservation: MaintenanceReservation? = null,
+    val found: Boolean = false,
+)
+
+data class MaintenanceActiveResponse(
+    val reservations: List<MaintenanceReservation> = emptyList(),
+)
+
+data class MaintenanceStatusResponse(
+    val state: MaintenanceState? = null,
+    @SerializedName("active_reservation")
+    val activeReservation: MaintenanceReservation? = null,
+    @SerializedName("scheduled_reservation")
+    val scheduledReservation: MaintenanceReservation? = null,
+    val found: Boolean = false,
+)
+
+data class MaintenanceSchedulabilityResponse(
+    val schedulable: Boolean = false,
+    @SerializedName("rejection_reason")
+    val rejectionReason: String = "",
+)
+
+data class MaintenanceConcurrencyResponse(
+    @SerializedName("concurrent_count")
+    val concurrentCount: Int = 0,
+    @SerializedName("concurrent_power_bps")
+    val concurrentPowerBps: Long = 0,
+)
+
+// -----------------------
+// Maintenance State Types
+// -----------------------
+
+data class MaintenanceReservation(
+    @SerializedName("reservation_id")
+    val reservationId: Long = 0,
+    val participant: String = "",
+    @SerializedName("start_height")
+    val startHeight: Long = 0,
+    @SerializedName("duration_blocks")
+    val durationBlocks: Long = 0,
+    @SerializedName("created_by")
+    val createdBy: String = "",
+    val status: String = "",
+    @SerializedName("activation_warning")
+    val activationWarning: String = "",
+)
+
+data class MaintenanceState(
+    val participant: String = "",
+    @SerializedName("credit_blocks")
+    val creditBlocks: Long = 0,
+    @SerializedName("last_maintenance_epoch")
+    val lastMaintenanceEpoch: Long = 0,
+    @SerializedName("active_reservation_id")
+    val activeReservationId: Long = 0,
+    @SerializedName("scheduled_reservation_id")
+    val scheduledReservationId: Long = 0,
+)
diff --git a/testermint/src/main/kotlin/data/devshard.kt b/testermint/src/main/kotlin/data/devshard.kt
index 8bd2d78d81..860a593695 100644
--- a/testermint/src/main/kotlin/data/devshard.kt
+++ b/testermint/src/main/kotlin/data/devshard.kt
@@ -93,9 +93,9 @@ data class DevshardHostStatsEntry(
     val invalid: Int,
     val cost: Long,
     @SerializedName("required_validations")
-    val requiredValidations: Int,
+    val requiredValidations: Int? = null,
     @SerializedName("completed_validations")
-    val completedValidations: Int
+    val completedValidations: Int? = null,
 )
 
 data class DevshardSlotSignatureEntry(
diff --git a/testermint/src/main/kotlin/data/epoch.kt b/testermint/src/main/kotlin/data/epoch.kt
index 3f5df10114..44470164cd 100644
--- a/testermint/src/main/kotlin/data/epoch.kt
+++ b/testermint/src/main/kotlin/data/epoch.kt
@@ -1,6 +1,7 @@
 package com.productscience.data
 
 import com.google.gson.annotations.SerializedName
+import com.productscience.INFERENCE_STAGE_SLACK_BLOCKS
 
 data class EpochResponse(
     @SerializedName("block_height")
@@ -19,9 +20,10 @@ data class EpochResponse(
     @SerializedName("active_confirmation_poc_event")
     val activeConfirmationPocEvent: ConfirmationPoCEvent? = null
 ) {
-    val safeForInference: Boolean
-        get() = if (phase == EpochPhase.Inference) {
-            nextEpochStages.pocStart - blockHeight > 3
+    val safeForInference: Boolean =
+        if (phase == EpochPhase.Inference) {
+            val blocksUntilEnd = nextEpochStages.pocStart - blockHeight
+            blocksUntilEnd > INFERENCE_STAGE_SLACK_BLOCKS
         } else {
             false
         }
diff --git a/testermint/src/main/kotlin/data/inference.kt b/testermint/src/main/kotlin/data/inference.kt
index d83b2530c6..032aa5964d 100644
--- a/testermint/src/main/kotlin/data/inference.kt
+++ b/testermint/src/main/kotlin/data/inference.kt
@@ -174,6 +174,21 @@ data class MsgClaimRewards(
     val epochIndex: Long = 0
 ) : TxMessage
 
+data class ClaimRecipientEntry(
+    val epoch: Long,
+    val recipient: String
+)
+
+data class ClaimRecipientsResponse(
+    val entries: List<ClaimRecipientEntry> = emptyList()
+)
+
+data class MsgSetClaimRecipients(
+    override val type: String = "/inference.inference.MsgSetClaimRecipients",
+    val creator: String = "",
+    val entries: List<ClaimRecipientEntry> = emptyList()
+) : TxMessage
+
 // Admin endpoint request/response for storing payloads directly
 data class StorePayloadRequest(
     @com.google.gson.annotations.SerializedName("prompt_payload")
diff --git a/testermint/src/main/kotlin/data/inferenceNodes.kt b/testermint/src/main/kotlin/data/inferenceNodes.kt
index e28cbcfdcf..7e3e343151 100644
--- a/testermint/src/main/kotlin/data/inferenceNodes.kt
+++ b/testermint/src/main/kotlin/data/inferenceNodes.kt
@@ -75,6 +75,11 @@ data class MlNodeVersionQueryResponse(
     val mlnodeVersion: MlNodeVersion
 )
 
+data class LastUpgradeHeightQueryResponse(
+    val lastUpgradeHeight: Long,
+    val found: Boolean,
+)
+
 data class MlNodeVersion(
     val currentVersion: String,
-)
\ No newline at end of file
+)
diff --git a/testermint/src/test/kotlin/BandwidthLimiterTests.kt b/testermint/src/test/kotlin/BandwidthLimiterTests.kt
index dfb924f7d5..a7dae0e919 100644
--- a/testermint/src/test/kotlin/BandwidthLimiterTests.kt
+++ b/testermint/src/test/kotlin/BandwidthLimiterTests.kt
@@ -2,11 +2,14 @@ import com.github.kittinunf.fuel.core.FuelError
 import com.productscience.*
 import com.productscience.data.*
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.tinylog.kotlin.Logger
 import java.time.Instant
 import kotlin.test.assertNotNull
 
+// Classic inference flow was removed (PR #1386); these tests exercise the deprecated endpoints.
+@Tag("exclude")
 class BandwidthLimiterTests : TestermintTest() {
 
     @Test
diff --git a/testermint/src/test/kotlin/ClaimRecipientTests.kt b/testermint/src/test/kotlin/ClaimRecipientTests.kt
new file mode 100644
index 0000000000..b0c72a8d79
--- /dev/null
+++ b/testermint/src/test/kotlin/ClaimRecipientTests.kt
@@ -0,0 +1,126 @@
+import com.productscience.EpochStage
+import com.productscience.assertions.assertThat
+import com.productscience.data.ClaimRecipientEntry
+import com.productscience.data.UnfundedInferenceParticipant
+import com.productscience.inferenceConfig
+import com.productscience.initCluster
+import com.productscience.logSection
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Timeout
+import java.util.concurrent.TimeUnit
+
+@Timeout(value = 20, unit = TimeUnit.MINUTES)
+class ClaimRecipientTests : TestermintTest() {
+    @Test
+    fun `claim rewards can be routed to configured recipient`() {
+        val (cluster, genesis) = initCluster(config = claimRecipientConfig, reboot = true)
+        cluster.allPairs.forEach { pair ->
+            pair.waitForMlNodesToLoad()
+        }
+
+        logSection("Clear pending claims before configuring recipient")
+        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 3)
+
+        val participantPair = cluster.joinPairs.first()
+        val participant = participantPair.node.getColdAddress()
+        val recipient = genesis.node.createKey("claim-recipient-${System.currentTimeMillis()}").address
+        val targetEpoch = genesis.getEpochData().latestEpoch.index + 1
+        val recipientBalanceBefore = genesis.getBalance(recipient)
+
+        logSection("Configure recipient for epoch $targetEpoch")
+        val setRecipient = participantPair.node.setClaimRecipients(claimRecipientsJson(targetEpoch, recipient))
+        assertThat(setRecipient).isSuccess()
+        assertThat(genesis.node.listClaimRecipients(participant).entries)
+            .anyMatch { it.epoch == targetEpoch && it.recipient == recipient }
+
+        logSection("Wait until target epoch $targetEpoch is active")
+        while (genesis.getEpochData().latestEpoch.index < targetEpoch) {
+            genesis.waitForNextEpoch()
+        }
+        val rewardSeed = participantPair.api.getConfig().currentSeed
+
+        genesis.markNeedsReboot()
+        participantPair.stopApiContainer()
+        logSection("Stopped participant API to prevent auto-claim before manual verification")
+
+        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
+        val claimResponse = participantPair.submitTransaction(
+            listOf(
+                "inference",
+                "claim-rewards",
+                rewardSeed.seed.toString(),
+                rewardSeed.epochIndex.toString(),
+            )
+        )
+        assertThat(claimResponse).isSuccess()
+
+        val recipientBalanceAfter = genesis.getBalance(recipient)
+        assertThat(recipientBalanceAfter)
+            .`as`("configured recipient receives the claim payout")
+            .isGreaterThan(recipientBalanceBefore)
+        assertThat(genesis.node.listClaimRecipients(participant).entries)
+            .`as`("recipient entry is retained after claim for late same-epoch payouts")
+            .anyMatch { it.epoch == targetEpoch && it.recipient == recipient }
+    }
+
+    @Test
+    fun `claim recipient pruning waits until epoch is safely stale`() {
+        val (cluster, genesis) = initCluster(config = claimRecipientConfig, reboot = true)
+        cluster.allPairs.forEach { pair ->
+            pair.waitForMlNodesToLoad()
+        }
+
+        val participantKey = genesis.node.createKey("claim-recipient-prune-participant-${System.currentTimeMillis()}")
+        val participant = participantKey.address
+        genesis.api.addUnfundedInferenceParticipant(
+            UnfundedInferenceParticipant(
+                url = "",
+                models = listOf(),
+                validatorKey = "",
+                pubKey = participantKey.pubkey.key,
+                address = participant
+            )
+        )
+        genesis.node.waitForNextBlock(2)
+
+        val recipient = genesis.node.createKey("claim-recipient-prune-${System.currentTimeMillis()}").address
+        val targetEpoch = genesis.getEpochData().latestEpoch.index + 1
+
+        logSection("Configure recipient for inactive participant epoch $targetEpoch")
+        val setRecipient = genesis.node.setClaimRecipients(
+            claimRecipientsJson(targetEpoch, recipient),
+            from = participantKey.name
+        )
+        assertThat(setRecipient).isSuccess()
+        assertThat(genesis.node.listClaimRecipients(participant).entries)
+            .anyMatch { it.epoch == targetEpoch && it.recipient == recipient }
+
+        logSection("Advance until target epoch is claimable, but not pruneable")
+        while (genesis.getEpochData().latestEpoch.index < targetEpoch + 1) {
+            genesis.waitForNextEpoch()
+        }
+        assertThat(genesis.node.listClaimRecipients(participant).entries)
+            .`as`("recipient entry is still present while the epoch is only one epoch old")
+            .anyMatch { it.epoch == targetEpoch && it.recipient == recipient }
+
+        logSection("Advance until target epoch is past the pruning threshold")
+        while (genesis.getEpochData().latestEpoch.index < targetEpoch + 5) {
+            genesis.waitForNextEpoch()
+        }
+        genesis.node.waitForNextBlock(2)
+
+        assertThat(genesis.node.listClaimRecipients(participant).entries)
+            .`as`("recipient entry is pruned only after it is safely stale")
+            .noneMatch { it.epoch == targetEpoch && it.recipient == recipient }
+    }
+
+    companion object {
+        private val claimRecipientConfig = inferenceConfig.copy(
+            genesisSpec = inferenceConfig.genesisSpec
+        )
+
+        private fun claimRecipientsJson(epoch: Long, recipient: String): String =
+            """[{"epoch":$epoch,"recipient":"$recipient"}]"""
+    }
+}
diff --git a/testermint/src/test/kotlin/CollateralTests.kt b/testermint/src/test/kotlin/CollateralTests.kt
index e40bdbdea2..13f7b05fee 100644
--- a/testermint/src/test/kotlin/CollateralTests.kt
+++ b/testermint/src/test/kotlin/CollateralTests.kt
@@ -10,6 +10,7 @@ import com.productscience.data.ValidationParams
 import com.productscience.data.getParticipant
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.data.Offset
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import java.time.Duration
 
@@ -135,7 +136,15 @@ class CollateralTests : TestermintTest() {
         assertThat(finalUnbondingQueue.unbondings).isNullOrEmpty()
     }
 
+    // Classic inference flow removed (PR #1386). This test triggered downtime slashing
+    // via classic bad-inference timeouts (StartInference -> expiration -> MissedRequests).
+    // The downtime-slash mechanism itself is still live: devshard settlement aggregates
+    // per-slot `missed` stats into CurrentEpochStats.MissedRequests
+    // (AggregateDevshardHostStatsIntoCurrentEpochStats -> UpdateParticipantStatus ->
+    // SlashForDowntime), but producing signed settlements with missed>0 needs new
+    // devshard test machinery. TODO(devshard): rewrite via devshard escrow settlement.
     @Test
+    @Tag("exclude")
     fun `a participant is slashed for downtime with unbonding slashed`() {
         // Configure genesis with fast expiration for downtime testing
         val fastExpirationSpec = createSpec(
diff --git a/testermint/src/test/kotlin/ConsumerTests.kt b/testermint/src/test/kotlin/ConsumerTests.kt
index 1a0043992d..5ad5ed01dd 100644
--- a/testermint/src/test/kotlin/ConsumerTests.kt
+++ b/testermint/src/test/kotlin/ConsumerTests.kt
@@ -1,9 +1,12 @@
 import com.productscience.*
 import com.productscience.data.*
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import kotlin.test.assertNotNull
 
+// Classic inference flow was removed (PR #1386); these tests exercise the deprecated endpoints.
+@Tag("exclude")
 class ConsumerTests : TestermintTest() {
     @Test
     fun `verify failed inference is refunded to consumer`() {
diff --git a/testermint/src/test/kotlin/DelegationTests.kt b/testermint/src/test/kotlin/DelegationTests.kt
index da1fadd6e3..a84d09cc31 100644
--- a/testermint/src/test/kotlin/DelegationTests.kt
+++ b/testermint/src/test/kotlin/DelegationTests.kt
@@ -196,13 +196,12 @@ class DelegationTests : TestermintTest() {
         // secondModel is bootstrap-only and not pre-eligible here.
         // It contributes zero consensus weight.
         // A declared bootstrap intent, which is acceptable while preEligible=false.
-        // B refused and C made no choice, so both are punished as NONE.
-        // A keeps model A only -> 50
-        // B serves A only -> floor(50 * 0.5) penalty -> 25
-        // C serves A only -> floor(50 * 0.5) penalty -> 25
+        // B refused and C made no choice, but penalties are reward-only and
+        // do not modify consensus weights.
+        // All three keep model A only -> 50 consensus weight each.
         assertThat(pA.weight).isEqualTo(50)
-        assertThat(pB.weight).isEqualTo(25)
-        assertThat(pC.weight).isEqualTo(25)
+        assertThat(pB.weight).isEqualTo(50)
+        assertThat(pC.weight).isEqualTo(50)
 
         // Voting powers only exist for model A because secondModel never entered validation.
         assertThat(pA.votingPowers).isNotNull
@@ -215,13 +214,13 @@ class DelegationTests : TestermintTest() {
         val vpB = pB.votingPowers!!.associateBy { it.modelId }
         assertThat(vpB).containsKey(defaultModel)
         assertThat(vpB).doesNotContainKey(secondModel)
-        assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(25)
+        assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(50)
 
         assertThat(pC.votingPowers).isNotNull
         val vpC = pC.votingPowers!!.associateBy { it.modelId }
         assertThat(vpC).containsKey(defaultModel)
         assertThat(vpC).doesNotContainKey(secondModel)
-        assertThat(vpC[defaultModel]!!.votingPower).isEqualTo(25)
+        assertThat(vpC[defaultModel]!!.votingPower).isEqualTo(50)
     }
 
     @Test
@@ -267,11 +266,12 @@ class DelegationTests : TestermintTest() {
             logSection("Node ${p.first}: weight=${p.second.weight}, votingPowers=${p.second.votingPowers}")
         }
 
-        // A, D serve both models -> consensusWeight = 50 + 10 = 60, no penalty.
-        // B declared intent for secondModel but doesn't serve it -> no_participation_penalty on consensusWeight.
-        // C delegated for secondModel -> no penalty.
+        // A, D serve both models -> consensusWeight = 50 + 10 = 60.
+        // B declared intent for secondModel but doesn't serve it, but penalties
+        // are reward-only and do not change consensusWeight.
+        // C delegated for secondModel -> no consensus penalty.
         assertThat(pA.weight).isEqualTo(60)
-        assertThat(pB.weight).isEqualTo(25) // 50 - floor(50*0.5) = 25
+        assertThat(pB.weight).isEqualTo(50)
         assertThat(pC.weight).isEqualTo(50)
         assertThat(pD.weight).isEqualTo(60)
 
@@ -281,7 +281,7 @@ class DelegationTests : TestermintTest() {
         val vpD = pD.votingPowers!!.associateBy { it.modelId }
 
         assertThat(vpA[defaultModel]!!.votingPower).isEqualTo(60)
-        assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(25)
+        assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(50)
         assertThat(vpC[defaultModel]!!.votingPower).isEqualTo(50)
         assertThat(vpD[defaultModel]!!.votingPower).isEqualTo(60)
 
@@ -293,7 +293,7 @@ class DelegationTests : TestermintTest() {
     }
 
     @Test
-    fun `delegation transfers weight and voting power to delegate target`() {
+    fun `delegation transfers voting power but not consensus weight to delegate target`() {
         val delegationSpec = spec<DelegationParams> {
             this[DelegationParams::deployWindow] = 1L
             this[DelegationParams::refusalPenalty] = Decimal.fromDouble(0.0)
@@ -400,24 +400,23 @@ class DelegationTests : TestermintTest() {
         assertThat(pC.mlNodes).hasSize(1)
 
         // Expected weights:
-        // Consensus before adjustment: A=60, B=60, C=50
-        // C is DELEGATE for model B -> delta=floor(50*0.2)=10
-        //   C: 50-10=40, A: 60+10=70
-        assertThat(pA.weight).isEqualTo(70)
+        // Consensus weight is reward-independent. C is DELEGATE for model B,
+        // but delegation_share is reward-only and must not mutate epoch weight.
+        assertThat(pA.weight).isEqualTo(60)
         assertThat(pB.weight).isEqualTo(60)
-        assertThat(pC.weight).isEqualTo(40)
+        assertThat(pC.weight).isEqualTo(50)
 
-        // Voting powers for model A (all DIRECT, VP = own final weight)
+        // Voting powers for model A (all DIRECT, VP = own consensus weight)
         val vpA = pA.votingPowers!!.associateBy { it.modelId }
         val vpB = pB.votingPowers!!.associateBy { it.modelId }
         val vpC = pC.votingPowers!!.associateBy { it.modelId }
 
-        assertThat(vpA[defaultModel]!!.votingPower).isEqualTo(70)
+        assertThat(vpA[defaultModel]!!.votingPower).isEqualTo(60)
         assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(60)
-        assertThat(vpC[defaultModel]!!.votingPower).isEqualTo(40)
+        assertThat(vpC[defaultModel]!!.votingPower).isEqualTo(50)
 
         // Voting powers for model B:
-        // A (DIRECT): VP = own(70) + delegated(C's final weight 40) = 110
+        // A (DIRECT): VP = own(60) + delegated(C's consensus weight 50) = 110
         // B (DIRECT): VP = own(60)
         // C (DELEGATE): no VP entry for model B
         assertThat(vpA[secondModel]!!.votingPower).isEqualTo(110)
@@ -459,12 +458,11 @@ class DelegationTests : TestermintTest() {
 
         // Model B ineligible -> no consensus contribution from model B.
         // Both get base weight from model A only: pocWeightA * coeffA = 50.
-        // Bootstrap penalty for non-pre-eligible model B: direct committers are
-        // exempt (BootstrapPenaltyDirect), only non-committers get penalized.
-        // Node A committed to model B -> no penalty -> 50.
-        // Node B did not commit to model B -> BootstrapPenaltyNone -> 50*0.5 = 25.
+        // Bootstrap penalties are reward-only and do not change consensus
+        // weights. Model B is ineligible, so only model A contributes.
+        // Node A and node B both keep 50 consensus weight.
         assertThat(pA.weight).isEqualTo(50)
-        assertThat(pB.weight).isEqualTo(25)
+        assertThat(pB.weight).isEqualTo(50)
 
         // Voting powers: only model A entries (model B ineligible -> no VP computed)
         val vpA = pA.votingPowers!!.associateBy { it.modelId }
@@ -476,7 +474,7 @@ class DelegationTests : TestermintTest() {
         assertThat(vpB).doesNotContainKey(secondModel)
 
         assertThat(vpA[defaultModel]!!.votingPower).isEqualTo(50)
-        assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(25)
+        assertThat(vpB[defaultModel]!!.votingPower).isEqualTo(50)
     }
 
     @Test
@@ -526,16 +524,15 @@ class DelegationTests : TestermintTest() {
         logSection("At penalty_start_epoch: epoch=${atGate.activeParticipants.epochId}, A=${atGateA.weight}, B=${atGateB.weight}")
 
         // The runtime compares against the upcoming epoch being formed, so the
-        // active set for penaltyStartEpoch is the first one where the penalty applies.
-        // Node A committed to model B -> exempt from no-participation penalty (Direct).
-        // Node B did not commit to model B -> penalized: 50 * 0.5 = 25.
+        // active set for penaltyStartEpoch is the first one where reward-only
+        // penalty accounting applies. Consensus weights stay unchanged.
         assertThat(atGate.activeParticipants.epochId).isEqualTo(penaltyStartEpoch)
         assertThat(atGateA.weight).isEqualTo(50)
-        assertThat(atGateB.weight).isEqualTo(25)
+        assertThat(atGateB.weight).isEqualTo(50)
     }
 
     @Test
-    fun `delegation share starts at configured epoch for eligible model`() {
+    fun `delegation share gate does not affect consensus weights for eligible model`() {
         val penaltyStartEpoch = 7L
         val delegationSpec = spec<DelegationParams> {
             this[DelegationParams::deployWindow] = 1L
@@ -575,7 +572,8 @@ class DelegationTests : TestermintTest() {
 
         logSection("Before delegation_share gate: epoch=${beforeGate.activeParticipants.epochId}, A=${beforeA.weight}, B=${beforeB.weight}, C=${beforeC.weight}")
 
-        // secondModel is eligible, but its delegation_share must still be gated off.
+        // secondModel is eligible, but reward-only delegation_share must not
+        // affect consensus weights before the reward gate.
         assertThat(beforeGate.activeParticipants.epochId).isEqualTo(penaltyStartEpoch - 1)
         assertThat(beforeA.weight).isEqualTo(60)
         assertThat(beforeB.weight).isEqualTo(60)
@@ -590,8 +588,8 @@ class DelegationTests : TestermintTest() {
         logSection("At delegation_share gate: epoch=${atGate.activeParticipants.epochId}, A=${atGateA.weight}, B=${atGateB.weight}, C=${atGateC.weight}")
 
         assertThat(atGate.activeParticipants.epochId).isEqualTo(penaltyStartEpoch)
-        assertThat(atGateA.weight).isEqualTo(70)
+        assertThat(atGateA.weight).isEqualTo(60)
         assertThat(atGateB.weight).isEqualTo(60)
-        assertThat(atGateC.weight).isEqualTo(40)
+        assertThat(atGateC.weight).isEqualTo(50)
     }
 }
diff --git a/testermint/src/test/kotlin/DevshardPostgresStorageTests.kt b/testermint/src/test/kotlin/DevshardPostgresStorageTests.kt
index 82ab4a01af..4e43754e25 100644
--- a/testermint/src/test/kotlin/DevshardPostgresStorageTests.kt
+++ b/testermint/src/test/kotlin/DevshardPostgresStorageTests.kt
@@ -12,19 +12,23 @@ import java.time.Instant
  *
  * Postgres is unconditional infrastructure for this cluster (see
  * docker-compose.postgres.yml + DockerGroup.kt), so these tests run in the
- * default suite alongside DevshardTests.
+ * default suite alongside the versioned devshardd tests.
  */
 class DevshardPostgresStorageTests : TestermintTest() {
+    private val standaloneTestVersionName = devshardTestVersion()
+    private val routePrefix = devshardVersionedRoutePrefix(standaloneTestVersionName)
     private val devshardEscrowModel = defaultModel
 
-    private val noRestrictionsConfig = inferenceConfig.copy(
-        genesisSpec = inferenceConfig.genesisSpec?.merge(devshardNoRestrictionsSpec) ?: devshardNoRestrictionsSpec
+    private val noRestrictionsConfig = devshardVersiondConfig(
+        genesisSpec = mergedDevshardGenesisSpec(devshardNoRestrictionsSpec),
+        env = versiondOverrideEnv(standaloneTestVersionName),
     )
 
     @Test
     fun `devshard sessions, diffs, signatures land in postgres`() {
         val (cluster, genesis) = initCluster(config = noRestrictionsConfig, reboot = true)
         genesis.waitForNextEpoch()
+        waitForVersionedHealth(genesis)
 
         cluster.stubDevshardChatResponse()
 
@@ -39,7 +43,11 @@ class DevshardPostgresStorageTests : TestermintTest() {
         logSection("Escrow $escrowId is in epoch $epochIndex")
 
         logSection("Driving inferences through devshard proxy")
-        val handle = genesis.startDevshardProxy(escrowId = escrowId, keyName = user.keyName)
+        val handle = genesis.startDevshardProxy(
+            escrowId = escrowId,
+            keyName = user.keyName,
+            routePrefix = routePrefix,
+        )
         try {
             genesis.waitForDevshardProxyWarmup()
             for (i in 0 until 10) {
@@ -124,6 +132,7 @@ class DevshardPostgresStorageTests : TestermintTest() {
         // so the chain naturally ticks during the test.
         val (cluster, genesis) = initCluster(config = noRestrictionsConfig, reboot = true)
         genesis.waitForNextEpoch()
+        waitForVersionedHealth(genesis)
 
         cluster.stubDevshardChatResponse()
 
@@ -137,7 +146,11 @@ class DevshardPostgresStorageTests : TestermintTest() {
         val firstEpoch = genesis.node.queryDevshardEscrow(firstEscrowId).escrow!!.epochIndex.toLong()
 
         run {
-            val handle = genesis.startDevshardProxy(escrowId = firstEscrowId, keyName = user.keyName)
+            val handle = genesis.startDevshardProxy(
+                escrowId = firstEscrowId,
+                keyName = user.keyName,
+                routePrefix = routePrefix,
+            )
             try {
                 genesis.waitForDevshardProxyWarmup()
                 for (i in 0 until 5) {
@@ -169,7 +182,11 @@ class DevshardPostgresStorageTests : TestermintTest() {
             val tickUser = genesis.createFundedDevshardUser("devshard-pg-prune-tick-${tick++}")
             val newEscrowId = genesis.createDevshardEscrowForUser(escrowAmount, tickUser.keyName, modelId = devshardEscrowModel)
             lastTickEpoch = genesis.node.queryDevshardEscrow(newEscrowId).escrow!!.epochIndex.toLong()
-            val handle = genesis.startDevshardProxy(escrowId = newEscrowId, keyName = tickUser.keyName)
+            val handle = genesis.startDevshardProxy(
+                escrowId = newEscrowId,
+                keyName = tickUser.keyName,
+                routePrefix = routePrefix,
+            )
             try {
                 genesis.waitForDevshardProxyWarmup()
                 genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "tick")
@@ -207,4 +224,15 @@ class DevshardPostgresStorageTests : TestermintTest() {
                 .isTrue()
         }
     }
+
+    private fun waitForVersionedHealth(genesis: LocalInferencePair) {
+        val deadline = System.currentTimeMillis() + 90_000L
+        while (System.currentTimeMillis() < deadline) {
+            if (genesis.queryVersionedHealth(standaloneTestVersionName) == "200:ok") {
+                return
+            }
+            Thread.sleep(1_000L)
+        }
+        error("Timed out waiting for proxy to serve $routePrefix/healthz")
+    }
 }
diff --git a/testermint/src/test/kotlin/DevshardStandaloneTests.kt b/testermint/src/test/kotlin/DevshardStandaloneTests.kt
index 2f7ae89bde..d6dc685e15 100644
--- a/testermint/src/test/kotlin/DevshardStandaloneTests.kt
+++ b/testermint/src/test/kotlin/DevshardStandaloneTests.kt
@@ -1,5 +1,9 @@
 import com.github.kittinunf.fuel.Fuel
 import com.productscience.*
+import com.productscience.devshardStateRootProtocolVersion
+import com.productscience.devshardTestVersion
+import com.productscience.devshardVersionedRoutePrefix
+import com.productscience.versiondOverrideEnv
 import com.productscience.data.*
 import kotlinx.coroutines.asCoroutineDispatcher
 import kotlinx.coroutines.async
@@ -20,9 +24,7 @@ import java.util.zip.ZipOutputStream
 import kotlin.test.assertNotNull
 
 /**
- * Mirror of DevshardTests but routed through versiond -> devshardd instead of
- * dapi's in-process HostManager. The shape of every assertion is the same;
- * only the test setup differs:
+ * Devshard integration coverage routed through versiond -> devshardd:
  *
  *  - docker-compose.versiond.yml is included for every pair so each pair runs
  *    a versiond container that boots the locally-built devshardd binary as
@@ -33,8 +35,6 @@ import kotlin.test.assertNotNull
  *    devshardctl builds host URLs as proxy/devshard/<version>/sessions/:id/...
  *    nginx strips /devshard/, versiond strips /<version>/, devshardd handles
  *    /sessions/:id/...
- *  - DAPI's in-process HostManager is still mounted on /v1/devshard for the
- *    legacy path; the new test does not exercise it.
  *  - This file also contains a startup-seeded state-driven test for the normal
  *    `approved_versions -> /versions -> versiond download` path without local
  *    overrides for the tested version.
@@ -50,12 +50,6 @@ class DevshardStandaloneTests : TestermintTest() {
             get() = "/devshard/${approvedVersion.name}"
     }
 
-    // The default join count is 2 -> three pairs total (genesis, join1, join2).
-    // Every pair gets the versiond compose extension so each runs its own
-    // devshardd child managed by its own ${KEY_NAME}-versiond container.
-    private val versiondComposeFilesByPairName = listOf(GENESIS_KEY_NAME, "join1", "join2")
-        .associateWith { listOf("docker-compose.versiond.yml") }
-
     // Switches the test cluster from "default" to "devshardd via versiond":
     //  - VERSIOND_BINARY_NAME selects the binary versiond launches per child
     //  - VERSIOND_OVERRIDE_<version> points at the bind-mounted host binary
@@ -82,23 +76,32 @@ class DevshardStandaloneTests : TestermintTest() {
     private val devsharddArtifactZip = devsharddArtifactDir.resolve("devshardd.zip")
     private val devsharddArtifactSha = devsharddArtifactDir.resolve("devshardd.zip.sha256")
 
-    private val overrideConfig = versiondConfig(
-        genesisSpec = mergedGenesisSpec(devshardNoRestrictionsSpec),
+    private val overrideConfig = devshardVersiondConfig(
+        genesisSpec = mergedDevshardGenesisSpec(devshardNoRestrictionsSpec),
         env = overrideVersiondEnv,
     )
 
-    private val streamingLongEpochConfig = versiondConfig(
+    private val streamingLongEpochConfig = devshardVersiondConfig(
         genesisSpec = createSpec(epochLength = 20, epochShift = 10).merge(devshardNoRestrictionsSpec),
         env = overrideVersiondEnv,
     )
 
-    private val parallelLongEpochConfig = versiondConfig(
-        genesisSpec = createSpec(epochLength = 25, epochShift = 10).merge(devshardNoRestrictionsSpec),
+    // devshardEscrowAlwaysValidateSpec pins devshard_escrow_params.validation_rate
+    // to 10000 bps so escrows snapshot 100% sampling at create. Without it the
+    // tests depend on the chain default and go flaky when that default changes.
+    private val parallelLongEpochConfig = devshardVersiondConfig(
+        genesisSpec = createSpec(epochLength = 25, epochShift = 10)
+            .merge(devshardNoRestrictionsSpec)
+            .merge(devshardEscrowAlwaysValidateSpec),
         env = overrideVersiondEnv,
     )
 
-    private val overrideAlwaysValidateConfig = versiondConfig(
-        genesisSpec = mergedGenesisSpec(devshardNoRestrictionsSpec, devshardAlwaysValidateSpec),
+    private val overrideAlwaysValidateConfig = devshardVersiondConfig(
+        genesisSpec = mergedDevshardGenesisSpec(
+            devshardNoRestrictionsSpec,
+            devshardAlwaysValidateSpec,
+            devshardEscrowAlwaysValidateSpec,
+        ),
         env = overrideVersiondEnv,
     )
 
@@ -375,6 +378,10 @@ class DevshardStandaloneTests : TestermintTest() {
                     .isEqualTo(session.escrowId.toString())
                 assertThat(result.parsed.stateRootAndProtocolVersion).isEqualTo(devshardStateRootProtocolVersion())
                 assertThat(result.parsed.hostStats).isNotEmpty()
+                // Settlement host_stats validation counters are always zero on this
+                // branch: the reveal-based recomputeCompliance was removed with seed
+                // reveal (see devshard/docs/inference-lifecycle.md). Validation
+                // coverage is asserted via validationObservability below instead.
                 assertThat(result.parsed.signatures).isNotEmpty()
                 val obs = genesis.getDevshardShardStatsDetail(session.escrowId, routePrefix = overrideRoutePrefix)
                 assertThat(obs.validationObservability.totals.completedValidations)
@@ -479,22 +486,8 @@ class DevshardStandaloneTests : TestermintTest() {
         }
     }
 
-    private fun versiondConfig(
-        genesisSpec: Spec<AppState>,
-        env: Map<String, String>,
-    ): ApplicationConfig = inferenceConfig.copy(
-        genesisSpec = genesisSpec,
-        additionalDockerFilesByKeyName = versiondComposeFilesByPairName,
-        additionalEnvVars = env,
-    )
-
-    private fun mergedGenesisSpec(vararg specs: Spec<AppState>): Spec<AppState> {
-        val base = inferenceConfig.genesisSpec ?: spec<AppState> {}
-        return specs.fold(base) { current, extra -> current.merge(extra) }
-    }
-
-    private fun stateDrivenConfig(approvedVersion: DevshardApprovedVersion): ApplicationConfig = versiondConfig(
-        genesisSpec = mergedGenesisSpec(
+    private fun stateDrivenConfig(approvedVersion: DevshardApprovedVersion): ApplicationConfig = devshardVersiondConfig(
+        genesisSpec = mergedDevshardGenesisSpec(
             devshardNoRestrictionsSpec,
             approvedVersionsSpec(listOf(approvedVersion)),
         ),
diff --git a/testermint/src/test/kotlin/DevshardTestSupport.kt b/testermint/src/test/kotlin/DevshardTestSupport.kt
index 6ffd95dbd4..cec013110e 100644
--- a/testermint/src/test/kotlin/DevshardTestSupport.kt
+++ b/testermint/src/test/kotlin/DevshardTestSupport.kt
@@ -51,7 +51,6 @@ val devshardShortSealGraceSpec = spec<AppState> {
                 this[DevshardEscrowParams::defaultInferenceSealGraceNonces] = devshardAutoSealInferenceSealGraceNonces
                 this[DevshardEscrowParams::defaultInferenceSealGraceSeconds] = devshardAutoSealInferenceSealGraceSeconds
                 this[DevshardEscrowParams::defaultAutoSealEveryNNonces] = devshardAutoSealEveryNNonces
-                this[DevshardEscrowParams::validationRate] = 0L
             }
         }
     }
@@ -85,12 +84,16 @@ fun LocalInferencePair.dumpDevshardChallengeTraceLogs(escrowId: Long) {
     val patterns = listOf(
         "execute_ml_",
         "validation_ml_",
+        "validation_rate_bound",
+        "validation_rate_sample",
         "validation_enqueued",
+        "validation_triggered",
         "apply_validation",
         "proxy_inference_",
         "validation started",
         "validation_result",
         "validation_vote",
+        "NewStateMachine",
     )
     val grepExpr = patterns.joinToString("|") { Regex.escape(it) }
     logSection("phase-trace docker logs (escrow=$escrowId, patterns=$grepExpr)")
@@ -375,7 +378,7 @@ fun LocalInferencePair.assertDevshardSettlement(
     assertThat(result.parsed.nonce).isGreaterThanOrEqualTo(activeNonces)
     assertThat(result.parsed.fees).isEqualTo(expectedFees)
 
-    val totalCompletedValidations = result.parsed.hostStats.sumOf { it.completedValidations }
+    val totalCompletedValidations = result.parsed.hostStats.sumOf { it.completedValidations ?: 0 }
     if (requireCompletedValidations) {
         assertThat(totalCompletedValidations).isGreaterThan(0)
     }
@@ -412,7 +415,7 @@ fun LocalInferencePair.assertDevshardSettlement(
 
 fun LocalInferencePair.getDevshardShardStatsDetail(
     escrowId: Long,
-    routePrefix: String = "/v1/devshard",
+    routePrefix: String,
 ): DevshardShardStatsDetail {
     val normalizedPrefix = routePrefix.trimEnd('/')
     val path = "$normalizedPrefix/stats/shards/$escrowId"
@@ -434,7 +437,7 @@ fun LocalInferencePair.waitForDevshardValidationObservability(
     minCompleted: Int = 1,
     timeoutMs: Long = 120_000L,
     pollIntervalMs: Long = 2_000L,
-    routePrefix: String = "/v1/devshard",
+    routePrefix: String,
 ) {
     val deadline = System.currentTimeMillis() + timeoutMs
     while (System.currentTimeMillis() < deadline) {
diff --git a/testermint/src/test/kotlin/DevshardTests.kt b/testermint/src/test/kotlin/DevshardTests.kt
deleted file mode 100644
index 73cc41fb24..0000000000
--- a/testermint/src/test/kotlin/DevshardTests.kt
+++ /dev/null
@@ -1,528 +0,0 @@
-import com.productscience.*
-import com.productscience.data.DevshardInferencePayload
-import com.productscience.data.DevshardInferenceStatus
-import com.github.dockerjava.api.async.ResultCallback
-import com.github.dockerjava.core.DockerClientBuilder
-import com.github.dockerjava.api.model.Frame
-import kotlinx.coroutines.asCoroutineDispatcher
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.runBlocking
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Test
-import java.time.Duration
-import java.util.concurrent.Executors
-import kotlin.test.assertNotNull
-
-class DevshardTests : TestermintTest() {
-    private val devshardEscrowModel = defaultModel
-
-    private val noRestrictionsConfig = inferenceConfig.copy(
-        genesisSpec = inferenceConfig.genesisSpec?.merge(devshardNoRestrictionsSpec) ?: devshardNoRestrictionsSpec
-    )
-
-    private val streamingLongEpochConfig = inferenceConfig.copy(
-        genesisSpec = createSpec(
-            epochLength = 20,
-            epochShift = 10,
-        ).merge(devshardNoRestrictionsSpec),
-    )
-
-    private val parallelLongEpochConfig = inferenceConfig.copy(
-        genesisSpec = createSpec(
-            epochLength = 25,
-            epochShift = 10,
-        ).merge(devshardNoRestrictionsSpec),
-    )
-
-    private val noRestrictionsAlwaysValidateConfig = inferenceConfig.copy(
-        genesisSpec = inferenceConfig.genesisSpec
-            ?.merge(devshardNoRestrictionsSpec)
-            ?.merge(devshardAlwaysValidateSpec)
-            ?.merge(devshardEscrowAlwaysValidateSpec)
-            ?: devshardNoRestrictionsSpec
-                .merge(devshardAlwaysValidateSpec)
-                .merge(devshardEscrowAlwaysValidateSpec)
-    )
-
-    private val shortSealGraceConfig = inferenceConfig.copy(
-        genesisSpec = inferenceConfig.genesisSpec
-            ?.merge(devshardNoRestrictionsSpec)
-            ?.merge(devshardShortSealGraceSpec)
-            ?: devshardNoRestrictionsSpec.merge(devshardShortSealGraceSpec),
-    )
-
-    @Test
-    fun `devshard gateway auto-seals inferences after grace timeout`() {
-        val slots = devshardAutoSealGroupSize.toInt()
-        val firstBatch = slots * 2
-
-        val (cluster, genesis) = initCluster(config = shortSealGraceConfig, reboot = true)
-        genesis.waitForNextEpoch()
-        cluster.stubDevshardChatResponse()
-
-        val user = genesis.createFundedDevshardUser("devshard-autoseal-user")
-        genesis.waitForNextInferenceWindow()
-
-        val escrowAmount = 7_000_000_000L
-        val escrowId = genesis.createDevshardEscrowForUser(escrowAmount, user.keyName, modelId = devshardEscrowModel)
-
-        logSection("Starting devshard proxy for auto-seal test")
-        val handle = genesis.startDevshardProxy(escrowId = escrowId, keyName = user.keyName)
-
-        try {
-            genesis.waitForDevshardProxyWarmup()
-
-            val status = genesis.getDevshardProxyStatus(handle.proxyUrl)
-            assertThat(status.config.inferenceSealGraceNonces).isEqualTo(devshardAutoSealInferenceSealGraceNonces.toInt())
-            assertThat(status.config.inferenceSealGraceSeconds)
-                .isEqualTo(devshardAutoSealInferenceSealGraceSeconds.toInt())
-            assertThat(status.config.validationRate).isEqualTo(0)
-
-            logSection("Sending first batch ($firstBatch finished inferences)")
-            for (i in 0 until firstBatch) {
-                val response = genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "autoseal batch1 $i")
-                assertThat(response).isNotEmpty()
-            }
-            genesis.waitForFinishedDevshardInferences(handle.proxyUrl, firstBatch)
-
-            val debugBeforeGrace = genesis.getDevshardProxyDebugState(handle.proxyUrl)
-            logSection(
-                "Before grace wait: live=${debugBeforeGrace.liveInferences} " +
-                    "sealed=${debugBeforeGrace.sealedInferences} nonce=${debugBeforeGrace.nonce} " +
-                    "live_status=${debugBeforeGrace.liveStatusCounts}",
-            )
-            assertThat(debugBeforeGrace.liveInferences).isGreaterThanOrEqualTo(firstBatch)
-            assertThat(debugBeforeGrace.sealedInferences).isEqualTo(0)
-
-            logSection("Waiting ${devshardAutoSealInferenceSealGraceSeconds}s inference seal grace")
-            Thread.sleep((devshardAutoSealInferenceSealGraceSeconds + 2) * 1_000L)
-
-            logSection(
-                "Driving nonce to auto-seal boundary ($devshardAutoSealEveryNNonces) " +
-                    "and waiting for >= $firstBatch sealed inferences",
-            )
-            genesis.waitForDevshardAutoSeal(
-                proxyUrl = handle.proxyUrl,
-                minSealed = firstBatch,
-                targetNonce = devshardAutoSealEveryNNonces,
-            )
-
-            val debugAfter = genesis.getDevshardProxyDebugState(handle.proxyUrl)
-            logSection(
-                "After second batch: live=${debugAfter.liveInferences} " +
-                    "sealed=${debugAfter.sealedInferences} nonce=${debugAfter.nonce} " +
-                    "live_status=${debugAfter.liveStatusCounts}",
-            )
-
-            assertThat(debugAfter.sealedInferences)
-                .describedAs("gateway should auto-seal Finished inferences after grace + new nonce")
-                .isGreaterThan(debugBeforeGrace.sealedInferences)
-            assertThat(debugAfter.sealedInferences)
-                .describedAs("at least the first batch of Finished inferences should seal")
-                .isGreaterThanOrEqualTo(firstBatch)
-            assertThat(debugAfter.liveInferences)
-                .describedAs("live map should shrink as sealed inferences are folded into sealed_acc")
-                .isLessThan(debugBeforeGrace.liveInferences)
-        } finally {
-            genesis.stopDevshardProxy(escrowId)
-        }
-    }
-
-    @Test
-    fun `create devshard escrow and query it`() {
-        val (cluster, genesis) = initCluster(reboot = true)
-
-        // Wait for first epoch to complete so EffectiveEpochIndex is set.
-        genesis.waitForNextEpoch()
-
-        val creator = genesis.node.getColdAddress()
-        val initialBalance = genesis.getBalance(creator)
-
-        logSection("Creating devshard escrow")
-        val escrowAmount = 7_000_000_000L  // 7 GNK
-        val txResponse = genesis.createDevshardEscrow(escrowAmount, modelId = devshardEscrowModel)
-        assertThat(txResponse.code).isEqualTo(0)
-
-        logSection("Querying devshard escrow")
-        val escrowResponse = genesis.node.queryDevshardEscrow(1)
-        assertThat(escrowResponse.found).isTrue()
-        assertThat(escrowResponse.escrow).isNotNull()
-        assertThat(escrowResponse.escrow!!.creator).isEqualTo(creator)
-        assertThat(escrowResponse.escrow!!.amount).isEqualTo(escrowAmount.toString())
-        assertThat(escrowResponse.escrow!!.slots).hasSize(16)  // DevshardGroupSize
-        assertThat(escrowResponse.escrow!!.settled).isFalse()
-
-        logSection("Verifying balance decreased")
-        val balanceAfter = genesis.getBalance(creator)
-        assertThat(balanceAfter).isEqualTo(initialBalance - escrowAmount)
-    }
-
-    @Test
-    fun `devshard inference e2e with settlement`() {
-        val (cluster, genesis) = initCluster(config = noRestrictionsConfig, reboot = true)
-        genesis.waitForNextEpoch()
-
-        cluster.stubDevshardChatResponse()
-
-        val user = genesis.createFundedDevshardUser("devshard-proxy-user")
-
-        genesis.waitForNextInferenceWindow()
-
-        val escrowAmount = 7_000_000_000L
-        val escrowId = genesis.createDevshardEscrowForUser(escrowAmount, user.keyName, modelId = devshardEscrowModel)
-
-        logSection("Starting devshard proxy")
-        val handle = genesis.startDevshardProxy(escrowId = escrowId, keyName = user.keyName)
-
-        try {
-            genesis.waitForDevshardProxyWarmup()
-            logSection("Sending chat completions via proxy")
-            for (i in 0 until 20) {
-                val response = genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "test prompt $i")
-                assertThat(response).isNotEmpty()
-            }
-
-            genesis.assertDevshardSettlement(handle, escrowId, user, escrowAmount, requireCompletedValidations = false)
-        } finally {
-            genesis.stopDevshardProxy(escrowId)
-        }
-    }
-
-    @Test
-    fun `devshard streaming inference e2e with settlement`() {
-        val (cluster, genesis) = initCluster(config = streamingLongEpochConfig, reboot = true)
-        genesis.waitForNextEpoch()
-
-        cluster.stubDevshardChatResponse(content = "hello from stream", streamDelay = Duration.ofMillis(50))
-
-        val user = genesis.createFundedDevshardUser("devshard-proxy-stream-user")
-
-        genesis.waitForNextInferenceWindow()
-
-        val escrowAmount = 7_000_000_000L
-        val escrowId = genesis.createDevshardEscrowForUser(escrowAmount, user.keyName, modelId = devshardEscrowModel)
-
-        logSection("Starting devshard proxy")
-        val handle = genesis.startDevshardProxy(escrowId = escrowId, keyName = user.keyName, debugLogging = true)
-
-        try {
-            genesis.waitForDevshardProxyWarmup()
-            logSection("Sending streaming chat completions via proxy")
-            val numInferences = 20L
-            for (i in 0 until numInferences) {
-                val response =
-                    genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "test prompt $i", stream = true)
-                assertThat(response).isNotEmpty()
-                assertThat(response).contains("data:")
-            }
-
-            val result = genesis.assertDevshardSettlement(handle, escrowId, user, escrowAmount, requireCompletedValidations = false)
-
-            logSection("Verifying inference statuses")
-            try {
-                val finished = genesis.getDevshardProxyInferences(handle.proxyUrl)
-                    .values.count { it.status == DevshardInferenceStatus.FINISHED }
-                assertThat(finished)
-                    .describedAs("finished devshard inferences")
-                    .isGreaterThanOrEqualTo(numInferences.toInt())
-            } catch (t: Throwable) {
-                dumpDevshardFailureDebug(
-                    genesis = genesis,
-                    handle = handle,
-                    escrowId = escrowId,
-                    maxInferenceId = numInferences,
-                    context = "streaming-status-verification",
-                )
-                throw t
-            }
-        } finally {
-            genesis.stopDevshardProxy(escrowId)
-        }
-    }
-
-    @Test
-    fun `parallel devshard sessions with isolated settlement`() {
-        val sessionCount = 6
-        val (cluster, genesis) = initCluster(config = parallelLongEpochConfig, reboot = true)
-        genesis.waitForNextEpoch()
-
-        cluster.stubDevshardChatResponse()
-
-        data class UserInfo(val keyName: String, val address: String)
-        data class SessionSetup(val keyName: String, val address: String, val escrowId: Long)
-
-        val fundAmount = 10_000_000_000L
-        val escrowAmount = 7_000_000_000L
-
-        val users = (0 until sessionCount).map { i ->
-            val user = genesis.createFundedDevshardUser("devshard-proxy-parallel-$i", fundAmount)
-            UserInfo(user.keyName, user.address)
-        }
-
-        genesis.waitForNextEpoch()
-        genesis.waitForNextInferenceWindow()
-
-        val sessions = users.mapIndexed { i, user ->
-            logSection("Creating escrow for user $i")
-            val escrowId =
-                genesis.createDevshardEscrowForUser(escrowAmount, user.keyName, modelId = devshardEscrowModel)
-            SessionSetup(user.keyName, user.address, escrowId)
-        }
-
-        logSection("Starting $sessionCount devshard proxies")
-        val handles = sessions.map { session ->
-            genesis.startDevshardProxy(escrowId = session.escrowId, keyName = session.keyName, debugLogging = true)
-        }
-
-        try {
-            genesis.waitForDevshardProxyWarmup()
-            logSection("Running $sessionCount proxy sessions in parallel")
-            val dispatcher = Executors.newFixedThreadPool(sessionCount).asCoroutineDispatcher()
-            runBlocking(dispatcher) {
-                handles.map { handle ->
-                    async {
-                        for (i in 0 until 10) {
-                            genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "test prompt $i")
-                        }
-                    }
-                }.awaitAll()
-            }
-            runBlocking(dispatcher) {
-                handles.map { handle ->
-                    async {
-                        for (i in 0 until 10) {
-                            genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "test prompt $i")
-                        }
-                    }
-                }.awaitAll()
-            }
-
-            logSection("Syncing devshard hosts before validation observability")
-            handles.forEach { handle ->
-                genesis.syncDevshardProxyHosts(handle.proxyUrl)
-            }
-
-            logSection("Waiting for validation observability on active escrows")
-            sessions.forEach { session ->
-                genesis.waitForDevshardValidationObservability(session.escrowId, minCompleted = 1)
-            }
-
-            logSection("Finalizing, settling, and verifying $sessionCount escrows")
-            sessions.zip(handles).forEach { (session, handle) ->
-                try {
-                    val result = genesis.finalizeDevshardProxy(handle.proxyUrl)
-                    assertThat(result.parsed.escrowId)
-                        .withFailMessage("Escrow ID mismatch for ${session.keyName}")
-                        .isEqualTo(session.escrowId.toString())
-                    assertThat(result.parsed.hostStats).isNotEmpty()
-                    assertThat(result.parsed.signatures).isNotEmpty()
-                    val obs = genesis.getDevshardShardStatsDetail(session.escrowId)
-                    assertThat(obs.validationObservability.totals.completedValidations)
-                        .withFailMessage("validation observability for escrow ${session.escrowId}")
-                        .isGreaterThan(0)
-
-                    val settleResp = genesis.settleDevshardEscrow(result.rawJson, from = session.keyName)
-                    assertThat(settleResp.code)
-                        .withFailMessage("Settlement failed for escrow ${session.escrowId}")
-                        .isEqualTo(0)
-
-                    val escrow = genesis.node.queryDevshardEscrow(session.escrowId)
-                    assertThat(escrow.escrow!!.settled)
-                        .withFailMessage("Escrow ${session.escrowId} not settled")
-                        .isTrue()
-
-                    val balance = genesis.getBalance(session.address)
-                    assertThat(balance)
-                        .withFailMessage("User ${session.keyName} did not receive refund")
-                        .isGreaterThan(fundAmount - escrowAmount)
-                } catch (t: Throwable) {
-                    dumpDevshardFailureDebug(
-                        genesis = genesis,
-                        handle = handle,
-                        escrowId = session.escrowId,
-                        maxInferenceId = 30,
-                        context = "parallel-finalize-${session.keyName}",
-                    )
-                    throw t
-                }
-            }
-        } finally {
-            handles.forEach { genesis.stopDevshardProxy(it.escrowId) }
-        }
-    }
-
-    @Test
-    fun `create escrow and query devshard mempool`() {
-        val (cluster, genesis) = initCluster(reboot = true)
-
-        // Wait for first epoch so EffectiveEpochIndex is set.
-        genesis.waitForNextEpoch()
-
-        logSection("Creating devshard escrow")
-        val escrowAmount = 7_000_000_000L  // 7 GNK
-        val txResponse = genesis.createDevshardEscrow(escrowAmount, modelId = devshardEscrowModel)
-        assertThat(txResponse.code).isEqualTo(0)
-
-        logSection("Query devshard mempool -- triggers lazy session creation")
-        val mempool = genesis.api.getDevshardMempool(1)
-        assertThat(mempool.txs).isNotNull()
-        assertThat(mempool.txs).isEmpty()
-    }
-
-    @Test
-    fun `invalid inference is challenged`() {
-        val (cluster, genesis) = initCluster(config = noRestrictionsAlwaysValidateConfig, reboot = true)
-        genesis.waitForNextEpoch()
-
-        cluster.allPairs.forEach { pair ->
-            pair.mock?.stubDevshardResponseForAllSegments(
-                response = defaultInferenceResponseObject,
-                streamDelay = Duration.ofMillis(50),
-            )
-        }
-        cluster.allPairs.last().mock?.stubDevshardResponseForAllSegments(
-            response = defaultInferenceResponseObject.withMissingLogit(),
-        )
-
-        val user = genesis.createFundedDevshardUser("devshard-proxy-stream-user")
-
-        genesis.waitForNextInferenceWindow()
-
-        val escrowAmount = 7_000_000_000L
-        val escrowId = genesis.createDevshardEscrowForUser(escrowAmount, user.keyName, modelId = devshardEscrowModel)
-
-        logSection("Starting devshard proxy")
-        val handle = genesis.startDevshardProxy(escrowId, keyName = user.keyName, debugLogging = true)
-
-        try {
-            genesis.waitForDevshardProxyWarmup()
-            logSection("Sending chat completions via proxy (join2 mock = withMissingLogit)")
-            val numInferences = 20L
-            val badExecutorHostIdx = cluster.allPairs.lastIndex
-            for (i in 0 until numInferences) {
-                val inferenceId = i + 1L
-                val response = genesis.sendChatCompletion(handle.proxyUrl, defaultModel, "test prompt $i")
-                assertThat(response).isNotEmpty()
-                genesis.traceDevshardInferencePhase(handle, inferenceId, "after_completion")
-                if (inferenceId % cluster.allPairs.size == badExecutorHostIdx.toLong()) {
-                    logSection("phase-trace inference $inferenceId routed to join2 (bad mock)")
-                }
-            }
-
-            genesis.waitForDevshardPreFinalize()
-            logSection("Waiting for async validations before finalize")
-            Thread.sleep(Duration.ofSeconds(15).toMillis())
-            for (inferenceId in 1..numInferences) {
-                genesis.traceDevshardInferencePhase(handle, inferenceId, "pre_finalize")
-            }
-            genesis.dumpDevshardChallengeTraceLogs(escrowId)
-
-            logSection("Finalizing via proxy")
-            val result = genesis.finalizeDevshardProxy(handle.proxyUrl)
-
-            logSection("Verifying settlement data")
-            assertThat(result.parsed.escrowId).isEqualTo("$escrowId")
-            assertThat(result.parsed.nonce).isGreaterThan(0)
-            assertThat(result.parsed.hostStats).isNotEmpty()
-            assertThat(result.parsed.signatures).isNotEmpty()
-
-            logSection("Submitting settlement from user account")
-            val settleResp = genesis.settleDevshardEscrow(result.rawJson, from = user.keyName)
-            assertThat(settleResp.code).isEqualTo(0)
-
-            logSection("Verifying escrow settled")
-            val escrow = genesis.node.queryDevshardEscrow(escrowId)
-            assertThat(escrow.escrow!!.settled).isTrue()
-
-            genesis.dumpDevshardChallengeTraceLogs(escrowId)
-
-            logSection("Verifying inference status")
-            try {
-                val inference = assertNotNull(genesis.findChallengedDevshardInference(handle))
-                logSection("Inference: $inference")
-                assertThat(inference.status).isIn(
-                    DevshardInferenceStatus.CHALLENGED,
-                    DevshardInferenceStatus.INVALIDATED,
-                )
-                assertThat(inference.votesInvalid).isNotZero()
-            } catch (t: Throwable) {
-                dumpDevshardFailureDebug(
-                    genesis = genesis,
-                    handle = handle,
-                    escrowId = escrowId,
-                    maxInferenceId = numInferences,
-                    context = "invalid-inference-challenge-verification",
-                )
-                throw t
-            }
-        } finally {
-            genesis.stopDevshardProxy(escrowId)
-        }
-    }
-
-    private fun dumpDevshardFailureDebug(
-        genesis: LocalInferencePair,
-        handle: LocalInferencePair.DevshardProxyHandle,
-        escrowId: Long,
-        maxInferenceId: Long,
-        context: String,
-    ) {
-        logSection("Debug dump start ($context, escrow=$escrowId)")
-
-        runCatching {
-            val result = genesis.finalizeDevshardProxy(handle.proxyUrl)
-            logSection("Debug finalize rawJson (escrow=$escrowId): ${result.rawJson}")
-        }.onFailure { logSection("Debug finalize failed (escrow=$escrowId): ${it.message}") }
-
-        runCatching {
-            val escrow = genesis.node.queryDevshardEscrow(escrowId)
-            logSection("Debug escrow state (escrow=$escrowId): ${cosmosJson.toJson(escrow)}")
-        }.onFailure { logSection("Debug escrow query failed (escrow=$escrowId): ${it.message}") }
-
-        runCatching {
-            val inferences = genesis.getDevshardProxyInferences(handle.proxyUrl)
-            for (inferenceId in 1..maxInferenceId) {
-                val inference = inferences[inferenceId]
-                logSection("Debug inference $inferenceId (escrow=$escrowId): ${inference?.let { cosmosJson.toJson(it) } ?: "missing"}")
-            }
-        }.onFailure { logSection("Debug inference dump failed (escrow=$escrowId): ${it.message}") }
-
-        runCatching {
-            val grpcPort = genesis.nodeManagerGrpcHostPort
-                ?: error("NodeManager gRPC port not available for ${genesis.name}")
-            NodeManagerClient("localhost", grpcPort).use { client ->
-                val resp = client.getRuntimeConfig(clientParamsBlockHeight = 0, maxWaitSeconds = 0)
-                logSection("Debug runtime config snapshot (escrow=$escrowId): ${resp.configOrNull()?.toString()}")
-            }
-        }.onFailure { logSection("Debug runtime config dump failed (escrow=$escrowId): ${it.message}") }
-
-        runCatching {
-            val dockerClient = DockerClientBuilder.getInstance().build()
-            listOf("genesis", "join1", "join2").forEach { name ->
-                listOf("api", "proxy").forEach { svc ->
-                    val containerName = "$name-$svc"
-                    val collector = StringBuilder()
-                    dockerClient.logContainerCmd(containerName)
-                        .withStdOut(true)
-                        .withStdErr(true)
-                        .withTail(200)
-                        .exec(
-                            object : ResultCallback.Adapter<Frame>() {
-                                override fun onNext(item: Frame) {
-                                    collector.append(item.toString())
-                                }
-                            },
-                        )
-                        .awaitCompletion()
-                    logSection("Debug docker tail for $containerName (escrow=$escrowId): $collector")
-                }
-            }
-        }.onFailure { logSection("Debug docker tail failed (escrow=$escrowId): ${it.message}") }
-
-        logSection("Debug dump end ($context, escrow=$escrowId)")
-    }
-
-    private fun com.productscience.nodemanager.NodeManagerProto.GetRuntimeConfigResponse.configOrNull() =
-        if (hasConfig()) config else null
-}
diff --git a/testermint/src/test/kotlin/DynamicPricingTest.kt b/testermint/src/test/kotlin/DynamicPricingTest.kt
index a6e305f2be..c97d2f7b42 100644
--- a/testermint/src/test/kotlin/DynamicPricingTest.kt
+++ b/testermint/src/test/kotlin/DynamicPricingTest.kt
@@ -21,6 +21,8 @@ import com.productscience.assertions.assertThat
  * 2. Load generation: realistic utilization with controlled growth (75 regular inferences × 85 tokens ≈ 5.3x utilization)
  * 3. Time decay: price decreases after utilization drops (with 2% growth caps)
  */
+// Classic inference flow was removed (PR #1386); these tests exercise the deprecated endpoints.
+@Tag("exclude")
 @Timeout(value = 15, unit = TimeUnit.MINUTES)
 class DynamicPricingTest : TestermintTest() {
 
diff --git a/testermint/src/test/kotlin/EmptyEpochFallbackTests.kt b/testermint/src/test/kotlin/EmptyEpochFallbackTests.kt
new file mode 100644
index 0000000000..167b913ca0
--- /dev/null
+++ b/testermint/src/test/kotlin/EmptyEpochFallbackTests.kt
@@ -0,0 +1,142 @@
+import com.productscience.EpochStage
+import com.productscience.data.AppState
+import com.productscience.data.Decimal
+import com.productscience.data.EpochParams
+import com.productscience.data.InferenceParams
+import com.productscience.data.InferenceState
+import com.productscience.data.PocParams
+import com.productscience.data.StakeValidatorStatus
+import com.productscience.data.getParticipant
+import com.productscience.data.spec
+import com.productscience.inferenceConfig
+import com.productscience.initCluster
+import com.productscience.logSection
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Timeout
+import org.tinylog.kotlin.Logger
+import java.util.concurrent.TimeUnit
+
+/**
+ * Seatbelt for an empty PoC outcome: if nobody passes validation (and nothing is
+ * preserved into the next epoch), epoch formation must re-seat the current live
+ * validators instead of writing an empty active set and permanently stalling.
+ */
+@Timeout(value = 15, unit = TimeUnit.MINUTES)
+class EmptyEpochFallbackTests : TestermintTest() {
+
+    // Tiny preservation target so IntPart(fraction * totalWeight) == 0 with the
+    // default 3-validator cluster weights. That keeps PreservedParticipants empty,
+    // so ComputeNewWeights can actually return [] when PoC mining also fails.
+    // (pocSlotAllocation == 0 is rewritten to the 0.5 default on-chain.)
+    private val noPreservationSpec = spec {
+        this[AppState::inference] = spec<InferenceState> {
+            this[InferenceState::params] = spec<InferenceParams> {
+                this[InferenceParams::epochParams] = spec<EpochParams> {
+                    this[EpochParams::pocSlotAllocation] = Decimal.fromDouble(0.001)
+                }
+                this[InferenceParams::pocParams] = spec<PocParams> {
+                    this[PocParams::pocV2Enabled] = true
+                }
+            }
+        }
+    }
+
+    private val noPreservationConfig = inferenceConfig.copy(
+        genesisSpec = inferenceConfig.genesisSpec?.merge(noPreservationSpec) ?: noPreservationSpec,
+    )
+
+    @Test
+    fun `empty poc validation falls back to previous epoch validators`() {
+        logSection("=== TEST: Empty PoC epoch fallback ===")
+
+        val (cluster, genesis) = initCluster(
+            joinCount = 2,
+            config = noPreservationConfig,
+            reboot = true,
+            resetMlNodes = false,
+        )
+        cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
+
+        val join1 = cluster.joinPairs[0]
+        val join2 = cluster.joinPairs[1]
+        val allPairs = listOf(genesis, join1, join2)
+
+        logSection("Phase 1: Normal PoC — establish 3 active validators")
+        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
+
+        val before = genesis.api.getActiveParticipants()
+        val beforeAddresses = before.activeParticipants.participants.map { it.index }.toSet()
+        val beforeEpochId = before.activeParticipants.epochId
+
+        Logger.info("Active before failure epoch: epochId=$beforeEpochId addresses=$beforeAddresses")
+        assertThat(beforeAddresses).hasSize(3)
+        allPairs.forEach { pair ->
+            assertThat(before.activeParticipants.getParticipant(pair))
+                .describedAs("${pair.name} should be active after the healthy PoC")
+                .isNotNull
+        }
+
+        logSection("Phase 2: Force empty PoC outcome — zero weight for every mock")
+        // claimedWeight < 1 drops every mining participant. Combined with no
+        // preserved nodes, ComputeNewWeights returns empty and the seatbelt fires.
+        allPairs.forEach { it.setPocWeight(0) }
+
+        logSection("Phase 3: Run the next PoC cycle with zero weight")
+        genesis.waitForStage(EpochStage.START_OF_POC)
+        Logger.info("Zero-weight PoC generation started")
+        genesis.waitForStage(EpochStage.END_OF_POC_VALIDATION, offset = 2)
+        Logger.info("PoC validation ended — fallback should have re-seated validators")
+
+        logSection("Phase 4: Wait for new validators / settlement after fallback")
+        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
+
+        val after = genesis.api.getActiveParticipants()
+        val afterAddresses = after.activeParticipants.participants.map { it.index }.toSet()
+        val afterEpochId = after.activeParticipants.epochId
+
+        Logger.info("Active after failure epoch: epochId=$afterEpochId addresses=$afterAddresses")
+        Logger.info("Excluded after failure epoch: ${after.excludedParticipants.map { it.address }}")
+
+        assertThat(afterEpochId)
+            .describedAs("Epoch must advance; fallback forms the upcoming epoch instead of aborting")
+            .isGreaterThan(beforeEpochId)
+
+        assertThat(afterAddresses)
+            .describedAs("Seatbelt must re-seat the previous live validator set")
+            .isEqualTo(beforeAddresses)
+
+        allPairs.forEach { pair ->
+            val participant = after.activeParticipants.getParticipant(pair)
+            assertThat(participant)
+                .describedAs("${pair.name} must still be an active participant after empty PoC")
+                .isNotNull
+            assertThat(participant!!.weight)
+                .describedAs("${pair.name} must keep positive weight after fallback re-seat")
+                .isGreaterThan(0)
+        }
+
+        logSection("Phase 5: Confirm staking still has three bonded validators")
+        val validators = genesis.node.getValidators().validators
+        assertThat(validators).hasSize(3)
+        allPairs.forEach { pair ->
+            val pubKey = pair.node.getValidatorInfo().key
+            val validator = validators.find { it.consensusPubkey.value == pubKey }
+            assertThat(validator)
+                .describedAs("${pair.name} must remain a staking validator")
+                .isNotNull
+            assertThat(validator!!.statusEnum)
+                .describedAs("${pair.name} must stay bonded after empty-PoC fallback")
+                .isEqualTo(StakeValidatorStatus.BONDED)
+            assertThat(validator.tokens)
+                .describedAs("${pair.name} must keep positive staking tokens")
+                .isGreaterThan(0L)
+        }
+
+        // Restore healthy mocks so a reused cluster is not left in the failure mode.
+        allPairs.forEach { it.setPocWeight(10) }
+        genesis.markNeedsReboot()
+
+        logSection("TEST PASSED: empty PoC fell back to the previous three validators")
+    }
+}
diff --git a/testermint/src/test/kotlin/EpochSchedulingHelpersTest.kt b/testermint/src/test/kotlin/EpochSchedulingHelpersTest.kt
new file mode 100644
index 0000000000..bf31d2cdb0
--- /dev/null
+++ b/testermint/src/test/kotlin/EpochSchedulingHelpersTest.kt
@@ -0,0 +1,155 @@
+import com.productscience.findStageSafeInferenceBlock
+import com.productscience.data.Decimal
+import com.productscience.data.EpochExchangeWindow
+import com.productscience.data.EpochParams
+import com.productscience.data.EpochPhase
+import com.productscience.data.EpochResponse
+import com.productscience.data.EpochStages
+import com.productscience.data.LatestEpochDto
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class EpochSchedulingHelpersTest {
+    @Test
+    fun `findStageSafeInferenceBlock uses current inference window when lead fits`() {
+        val epochData = epochResponse(
+            blockHeight = 420,
+            phase = EpochPhase.Inference,
+            epochClaimMoney = 416,
+            epochNextPocStart = 450,
+            nextClaimMoney = 466,
+            nextNextPocStart = 500,
+        )
+
+        val selected = requireNotNull(epochData.findStageSafeInferenceBlock(earliestBlock = 428))
+
+        assertThat(selected.block).isEqualTo(428)
+        assertThat(selected.inferenceWindowStart).isEqualTo(417)
+        assertThat(selected.nextPocStart).isEqualTo(450)
+    }
+
+    @Test
+    fun `findStageSafeInferenceBlock skips unsafe tail of current inference window`() {
+        val epochData = epochResponse(
+            blockHeight = 420,
+            phase = EpochPhase.Inference,
+            epochClaimMoney = 416,
+            epochNextPocStart = 450,
+            nextClaimMoney = 466,
+            nextNextPocStart = 500,
+        )
+
+        val selected = requireNotNull(epochData.findStageSafeInferenceBlock(earliestBlock = 447))
+
+        assertThat(selected.block).isEqualTo(467)
+        assertThat(selected.inferenceWindowStart).isEqualTo(467)
+        assertThat(selected.nextPocStart).isEqualTo(500)
+    }
+
+    @Test
+    fun `findStageSafeInferenceBlock anchors on upcoming inference window when currently in validation`() {
+        val epochData = epochResponse(
+            blockHeight = 433,
+            phase = EpochPhase.PoCValidate,
+            epochClaimMoney = 440,
+            epochNextPocStart = 460,
+            nextClaimMoney = 476,
+            nextNextPocStart = 510,
+        )
+
+        val selected = requireNotNull(epochData.findStageSafeInferenceBlock(earliestBlock = 445))
+
+        assertThat(selected.block).isEqualTo(445)
+        assertThat(selected.inferenceWindowStart).isEqualTo(441)
+        assertThat(selected.nextPocStart).isEqualTo(460)
+    }
+
+    @Test
+    fun `findStageSafeInferenceBlock projects forward beyond the next epoch when lead is long`() {
+        val epochData = epochResponse(
+            blockHeight = 363,
+            phase = EpochPhase.Inference,
+            epochClaimMoney = 358,
+            epochNextPocStart = 390,
+            nextClaimMoney = 398,
+            nextNextPocStart = 430,
+        )
+
+        val selected = requireNotNull(epochData.findStageSafeInferenceBlock(earliestBlock = 443))
+
+        assertThat(selected.block).isEqualTo(443)
+        assertThat(selected.inferenceWindowStart).isEqualTo(439)
+        assertThat(selected.nextPocStart).isEqualTo(470)
+    }
+
+    private fun epochResponse(
+        blockHeight: Long,
+        phase: EpochPhase,
+        epochClaimMoney: Long,
+        epochNextPocStart: Long,
+        nextClaimMoney: Long,
+        nextNextPocStart: Long,
+    ): EpochResponse {
+        return EpochResponse(
+            blockHeight = blockHeight,
+            latestEpoch = LatestEpochDto(index = 11, pocStartBlockHeight = 400),
+            phase = phase,
+            epochStages = epochStages(
+                epochIndex = 11,
+                claimMoney = epochClaimMoney,
+                nextPocStart = epochNextPocStart,
+            ),
+            nextEpochStages = epochStages(
+                epochIndex = 12,
+                claimMoney = nextClaimMoney,
+                nextPocStart = nextNextPocStart,
+            ),
+            epochParams = EpochParams(
+                epochLength = 60,
+                epochMultiplier = 1,
+                epochShift = 0,
+                defaultUnitOfComputePrice = 100,
+                pocStageDuration = 10,
+                pocExchangeDuration = 1,
+                pocValidationDelay = 2,
+                pocValidationDuration = 4,
+                setNewValidatorsDelay = 1,
+                inferenceValidationCutoff = 1,
+                inferencePruningEpochThreshold = 10,
+                inferencePruningMax = 100,
+                pocPruningMax = 100,
+                pocSlotAllocation = Decimal.fromDouble(0.5),
+                confirmationPocSafetyWindow = 0,
+            ),
+            isConfirmationPocActive = false,
+            activeConfirmationPocEvent = null,
+        )
+    }
+
+    private fun epochStages(
+        epochIndex: Long,
+        claimMoney: Long,
+        nextPocStart: Long,
+    ): EpochStages {
+        return EpochStages(
+            epochIndex = epochIndex,
+            pocStart = claimMoney - 20,
+            pocGenerationWindDown = claimMoney - 16,
+            pocGenerationEnd = claimMoney - 15,
+            pocValidationStart = claimMoney - 10,
+            pocValidationWindDown = claimMoney - 6,
+            pocValidationEnd = claimMoney - 5,
+            setNewValidators = claimMoney - 1,
+            claimMoney = claimMoney,
+            nextPocStart = nextPocStart,
+            pocExchangeWindow = EpochExchangeWindow(
+                start = claimMoney - 14,
+                end = claimMoney - 11,
+            ),
+            pocValExchangeWindow = EpochExchangeWindow(
+                start = claimMoney - 9,
+                end = claimMoney - 7,
+            ),
+        )
+    }
+}
diff --git a/testermint/src/test/kotlin/GovernanceTests.kt b/testermint/src/test/kotlin/GovernanceTests.kt
index ea308410b0..040272a1ec 100644
--- a/testermint/src/test/kotlin/GovernanceTests.kt
+++ b/testermint/src/test/kotlin/GovernanceTests.kt
@@ -1,4 +1,3 @@
-import ValidationTests.Companion.alwaysValidate
 import com.productscience.EpochStage
 import com.productscience.data.UpdateParams
 import com.productscience.data.ProposalStatus
@@ -8,8 +7,6 @@ import com.productscience.data.Coin
 import com.productscience.data.InferenceState
 import com.productscience.data.GenesisOnlyParams
 import com.productscience.data.Decimal
-import com.productscience.data.MsgSend
-import com.productscience.data.MsgStartInference
 import com.productscience.data.MsgTransferWithVesting
 import com.productscience.inferenceConfig
 import com.productscience.initCluster
@@ -17,7 +14,6 @@ import com.productscience.logSection
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import org.tinylog.kotlin.Logger
-import kotlin.test.assertNotNull
 
 class GovernanceTests : TestermintTest() {
     @Test
@@ -144,43 +140,27 @@ class GovernanceTests : TestermintTest() {
 
     @Test
     fun `send gov funds to an account`() {
-        val (cluster, genesis) = initCluster(mergeSpec = alwaysValidate, reboot = true)
-        genesis.waitForNextEpoch()
-        cluster.allPairs.forEach { pair ->
-            pair.waitForMlNodesToLoad()
-        }
-        val helper = InferenceTestHelper(cluster, genesis)
-        val lateValidator = cluster.joinPairs.first()
-        val mlNodeVersionResponse = genesis.node.getMlNodeVersion()
-        val mlNodeVersion = mlNodeVersionResponse.mlnodeVersion.currentVersion
-        val segment = "/${mlNodeVersion}"
-        lateValidator.mock?.setInferenceErrorResponse(500, segment = segment)
-        logSection("Make sure we're in safe inference zone")
-        genesis.waitForStage(EpochStage.SET_NEW_VALIDATORS)
-        genesis.node.waitForNextBlock(3)
-        val lateValidatorBeforeBalance = lateValidator.node.getSelfBalance()
-        logSection("Use messages only for inference")
-        val seed = lateValidator.api.getConfig().currentSeed
-        val inference = helper.runFullInference()
-        logSection("Wait for claims")
-        genesis.waitForStage(EpochStage.CLAIM_REWARDS, 3)
-        // Both helpers should have validated and been rewarded
-        val updatedInference = genesis.node.getInference(inference.inferenceId)
-        // Only the other join should have validated
-        assertNotNull(updatedInference)
-        assertNotNull(updatedInference.inference)
-
-        assertThat(
-            updatedInference.inference.validatedBy ?: listOf()
-        ).doesNotContain(lateValidator.node.getColdAddress())
-        val afterBalance = lateValidator.node.getSelfBalance()
-        assertThat(afterBalance).isEqualTo(lateValidatorBeforeBalance)
-        logSection("Wait for claims to default to gov account")
-        genesis.waitForStage(EpochStage.CLAIM_REWARDS)
-        logSection("Submit Proposal to send funds")
+        val (cluster, genesis) = initCluster(reboot = true)
+        // The gov module account is intentionally not in the app's blocked-address
+        // list, so it can be funded with a plain bank send. (Previously this test
+        // funded it indirectly through classic-inference reward defaults, which
+        // were removed along with the classic inference flow.)
+        logSection("Funding governance module account")
         val governanceAddress = genesis.node.getModuleAccount("gov").account.value.address
-        val governanceBalance = genesis.node.getBalance(governanceAddress, "ngonka")
         val genesisAddress = genesis.node.getColdAddress()
+        // MsgTransferWithVesting enforces a 10-gonka minimum per transfer
+        // (streamvesting/types/msg_transfer_with_vesting.go), so the gov account
+        // must hold at least 10 gonka for the proposal below to execute.
+        val fundAmount = 10_000_000_000L
+        // Genesis cold wallet starts lean; wait for CLAIM_REWARDS income if needed.
+        genesis.ensureGenesisSpendableForDevshard(fundAmount)
+        val fundResp = genesis.submitTransaction(
+            listOf("bank", "send", genesisAddress, governanceAddress, "$fundAmount${genesis.config.denom}")
+        )
+        assertThat(fundResp.code).isEqualTo(0)
+        logSection("Submit Proposal to send funds")
+        val governanceBalance = genesis.node.getBalance(governanceAddress, "ngonka")
+        assertThat(governanceBalance.balance.amount).isGreaterThanOrEqualTo(fundAmount)
         val genesisBalance = genesis.node.getBalance(genesisAddress, "ngonka")
         val sendFunds = MsgTransferWithVesting(
             sender = governanceAddress,
diff --git a/testermint/src/test/kotlin/InferenceAccountingTests.kt b/testermint/src/test/kotlin/InferenceAccountingTests.kt
index 0bffaddf03..e2780b0290 100644
--- a/testermint/src/test/kotlin/InferenceAccountingTests.kt
+++ b/testermint/src/test/kotlin/InferenceAccountingTests.kt
@@ -19,6 +19,8 @@ import kotlin.test.assertNotNull
 
 const val DELAY_SEED = 8675309
 
+// Classic inference flow was removed (PR #1386); these tests exercise the deprecated endpoints.
+@Tag("exclude")
 @Timeout(value = 15, unit = TimeUnit.MINUTES)
 class InferenceAccountingTests : TestermintTest() {
 
diff --git a/testermint/src/test/kotlin/InferenceFailureAccountingTests.kt b/testermint/src/test/kotlin/InferenceFailureAccountingTests.kt
index b7bd04edd9..472e53e1f5 100644
--- a/testermint/src/test/kotlin/InferenceFailureAccountingTests.kt
+++ b/testermint/src/test/kotlin/InferenceFailureAccountingTests.kt
@@ -6,9 +6,12 @@ import com.productscience.data.InferenceState
 import com.productscience.data.InferenceStatus
 import com.productscience.data.spec
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.tinylog.kotlin.Logger
 
+// Classic inference flow was removed (PR #1386); this test exercises the deprecated endpoints.
+@Tag("exclude")
 class InferenceFailureAccountingTests : TestermintTest() {
 
     @Test
diff --git a/testermint/src/test/kotlin/InferenceRetryTests.kt b/testermint/src/test/kotlin/InferenceRetryTests.kt
index edadd4a9a2..51acbea180 100644
--- a/testermint/src/test/kotlin/InferenceRetryTests.kt
+++ b/testermint/src/test/kotlin/InferenceRetryTests.kt
@@ -6,6 +6,7 @@ import com.productscience.MockServerInferenceMock
 import com.productscience.EpochStage
 import com.productscience.defaultInferenceResponseObject
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import java.util.concurrent.TimeUnit
@@ -13,6 +14,8 @@ import com.github.dockerjava.api.model.Container
 import java.time.Duration
 import com.productscience.runParallelInferencesWithResults
 
+// Classic inference flow was removed (PR #1386); this test exercises the deprecated endpoints.
+@Tag("exclude")
 @Timeout(value = 15, unit = TimeUnit.MINUTES)
 class InferenceRetryTests : TestermintTest() {
     @Test
diff --git a/testermint/src/test/kotlin/InferenceTests.kt b/testermint/src/test/kotlin/InferenceTests.kt
index b7b14eb146..6c694bda6b 100644
--- a/testermint/src/test/kotlin/InferenceTests.kt
+++ b/testermint/src/test/kotlin/InferenceTests.kt
@@ -6,6 +6,7 @@ import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.assertj.core.api.SoftAssertions
 import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import java.time.Instant
 import kotlin.experimental.xor
@@ -33,6 +34,7 @@ fun computeResponseHash(responsePayload: String): String {
 
 class InferenceTests : TestermintTest() {
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `valid inference`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
@@ -53,6 +55,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `valid inference with multipart content`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
@@ -73,6 +76,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `wrong TA address`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
@@ -94,6 +98,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `submit raw transaction`() {
         val timestamp = Instant.now().toEpochNanos()
         val genesisAddress = genesis.node.getColdAddress()
@@ -225,6 +230,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `old timestamp`() {
         val params = genesis.getParams()
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
@@ -241,6 +247,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `repeated request rejected`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
@@ -264,6 +271,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `valid direct executor request`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
@@ -308,6 +316,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `executor validates dev signature`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
@@ -334,6 +343,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `executor validates TA signature`() {
         val timestamp = Instant.now().toEpochNanos()
         val genesisAddress = genesis.node.getColdAddress()
@@ -358,6 +368,7 @@ class InferenceTests : TestermintTest() {
 
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `executor rejects old timestamp`() {
         val params = genesis.getParams()
         val timestamp = Instant.now().minusSeconds(params.validationParams.timestampExpiration + 10).toEpochNanos()
@@ -382,6 +393,7 @@ class InferenceTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `executor rejects duplicate requests`() {
         cluster.allPairs.forEach { it.waitForMlNodesToLoad() }
         genesis.waitForNextInferenceWindow()
diff --git a/testermint/src/test/kotlin/InvalidationTests.kt b/testermint/src/test/kotlin/InvalidationTests.kt
index a4aba501eb..29cb3a4372 100644
--- a/testermint/src/test/kotlin/InvalidationTests.kt
+++ b/testermint/src/test/kotlin/InvalidationTests.kt
@@ -16,6 +16,7 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.runBlocking
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Order
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import org.tinylog.kotlin.Logger
@@ -26,6 +27,7 @@ import kotlin.test.assertNotNull
 
 class InvalidationTests : TestermintTest() {
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     @Timeout(15, unit = TimeUnit.MINUTES)
     @Order(Int.MAX_VALUE - 1)
     fun `test invalid gets removed and restored`() {
@@ -109,6 +111,7 @@ class InvalidationTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `test valid with invalid validator gets validated`() {
         val (cluster, genesis) = initCluster(mergeSpec = alwaysValidate)
         genesis.waitForNextInferenceWindow()
@@ -144,6 +147,7 @@ class InvalidationTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `test invalid gets marked invalid`() {
         var tries = 4
         val (cluster, genesis) = initCluster(reboot = true)
@@ -166,6 +170,7 @@ class InvalidationTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `full inference with invalid response payload`() {
         val (cluster, genesis) = initCluster(mergeSpec = alwaysValidate)
         cluster.allPairs.forEach { pair ->
@@ -184,18 +189,8 @@ class InvalidationTests : TestermintTest() {
         assertThat(inferencePayload.inference.statusEnum).isEqualTo(InferenceStatus.INVALIDATED)
     }
 
-    @Test
-    fun `logprob manipulation produces different hash`() {
-        // Security test: payloads with same content but different logprobs must have different hashes
-        // This prevents attack where executor serves fake logprobs with valid content
-        val payloadWithRealLogprobs = """{"id":"inf-1","choices":[{"index":0,"message":{"role":"assistant","content":"Hello"},"logprobs":{"content":[{"token":"Hello","logprob":-0.5,"top_logprobs":[{"token":"Hello","logprob":-0.5}]}]}}]}"""
-        val payloadWithFakeLogprobs = """{"id":"inf-1","choices":[{"index":0,"message":{"role":"assistant","content":"Hello"},"logprobs":{"content":[{"token":"Hello","logprob":-0.1,"top_logprobs":[{"token":"Hello","logprob":-0.1}]}]}}]}"""
-
-        val hash1 = computeResponseHash(payloadWithRealLogprobs)
-        val hash2 = computeResponseHash(payloadWithFakeLogprobs)
-
-        assertThat(hash1).isNotEqualTo(hash2)
-    }
+    // NOTE: `logprob manipulation produces different hash` moved to PromptHashingTests: it is a pure
+    // unit test and this class is excluded from the CI matrix.
 
     companion object {
         val alwaysValidate = spec {
diff --git a/testermint/src/test/kotlin/MaintenanceWindowTests.kt b/testermint/src/test/kotlin/MaintenanceWindowTests.kt
new file mode 100644
index 0000000000..c2e490ea23
--- /dev/null
+++ b/testermint/src/test/kotlin/MaintenanceWindowTests.kt
@@ -0,0 +1,502 @@
+import com.github.dockerjava.api.DockerClient
+import com.github.dockerjava.core.DockerClientBuilder
+import com.productscience.LocalInferencePair
+import com.productscience.data.*
+import com.productscience.getRawContainers
+import com.productscience.initCluster
+import com.productscience.logSection
+import com.productscience.EpochStage
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+import org.tinylog.kotlin.Logger
+
+/**
+ * End-to-end tests for the Maintenance Windows feature.
+ *
+ * These tests verify the two highest-signal maintenance behaviors in a real
+ * multi-node blockchain environment:
+ * 1. scheduling semantics (rejection, scheduling, cancellation, credit)
+ * 2. lifecycle behavior (activation and offline exemption without jailing)
+ */
+class MaintenanceWindowTests : TestermintTest() {
+
+    /**
+     * Lazily-instantiated Docker client shared by all node-container helpers
+     * in this class. Building a DockerClient is heavy, so we reuse one per
+     * test class lifecycle instead of constructing one per call.
+     */
+    private val dockerClient: DockerClient by lazy { DockerClientBuilder.getInstance().build() }
+
+    /**
+     * Wait until the participant has accumulated at least [minCredit] blocks of
+     * maintenance credit. Retries by waiting for additional epochs up to
+     * [maxRetryEpochs] times. Returns the final credit balance.
+     */
+    private fun awaitMinimumCredit(
+        genesis: LocalInferencePair,
+        participantAddress: String,
+        minCredit: Long,
+        maxRetryEpochs: Int = 4,
+    ): Long {
+        repeat(maxRetryEpochs) {
+            val credit: MaintenanceCreditResponse = genesis.node.execAndParse(
+                listOf("query", "inference", "maintenance-credit", participantAddress)
+            )
+            if (credit.creditBlocks >= minCredit) return credit.creditBlocks
+            Logger.info("Credit ${credit.creditBlocks} < $minCredit, waiting for another epoch...")
+            genesis.waitForNextEpoch()
+        }
+        val final: MaintenanceCreditResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-credit", participantAddress)
+        )
+        return final.creditBlocks
+    }
+
+    private fun getMaintenanceParams(genesis: LocalInferencePair): MaintenanceParams {
+        return checkNotNull(genesis.getParams().maintenanceParams) {
+            "maintenanceParams was null in Testermint chain params"
+        }
+    }
+
+    private fun waitForCometValidatorPowers(
+        genesis: LocalInferencePair,
+        expectedVotingPowerByPubKey: Map<String, String>,
+        maxBlocks: Int = 6,
+    ) {
+        repeat(maxBlocks) { attempt ->
+            val cometValidators = genesis.node.getCometValidators().validators.associateBy({ it.pubKey.key }, { it.votingPower })
+            val matches = expectedVotingPowerByPubKey.all { (pubKey, expectedVotingPower) ->
+                cometValidators[pubKey] == expectedVotingPower
+            }
+            if (matches) return
+            Logger.info(
+                "Comet validator powers not settled yet (attempt ${attempt + 1}/$maxBlocks). " +
+                    "Expected=$expectedVotingPowerByPubKey Actual=$cometValidators"
+            )
+            genesis.node.waitForNextBlock(1)
+        }
+
+        val finalCometValidators = genesis.node.getCometValidators().validators.associateBy({ it.pubKey.key }, { it.votingPower })
+        assertThat(finalCometValidators)
+            .describedAs("Comet validator powers should converge before taking a validator offline")
+            .containsAllEntriesOf(expectedVotingPowerByPubKey)
+    }
+
+    private fun assertRemainingValidatorsCanMaintainQuorum(
+        genesis: LocalInferencePair,
+        offlineValidatorPubKey: String,
+    ) {
+        val cometValidators = genesis.node.getCometValidators().validators
+        val powersByPubKey = cometValidators.associate { validator ->
+            validator.pubKey.key to checkNotNull(validator.votingPower.toLongOrNull()) {
+                "Unexpected non-numeric voting power for ${validator.pubKey.key}: ${validator.votingPower}"
+            }
+        }
+        val totalPower = powersByPubKey.values.sum()
+        val remainingPower = powersByPubKey
+            .filterKeys { it != offlineValidatorPubKey }
+            .values
+            .sum()
+
+        assertThat(remainingPower * 3)
+            .describedAs(
+                "Remaining validator power should stay above two-thirds before taking a validator offline. " +
+                    "Current powers=$powersByPubKey"
+            )
+            .isGreaterThan(totalPower * 2)
+    }
+
+    /**
+     * Resolve the Docker container for a pair's chain node.
+     * Throws if the container cannot be found.
+     */
+    private fun nodeContainerFor(pair: LocalInferencePair) =
+        getRawContainers(pair.config).getNode(pair.name)
+            ?: error("Node container not found for ${pair.name}")
+
+    /**
+     * Stop the chain node container for a given pair.
+     * This causes the validator to stop signing blocks (missing signatures).
+     */
+    private fun stopNodeContainer(pair: LocalInferencePair) {
+        dockerClient.stopContainerCmd(nodeContainerFor(pair).id).exec()
+        Logger.info("Stopped node container for ${pair.name}")
+    }
+
+    /**
+     * Find a future maintenance window that is safely inside inference and far
+     * enough from the next PoC transition to avoid phase-overlap rejections.
+     */
+    private fun findSchedulableWindowStart(
+        genesis: LocalInferencePair,
+        participantAddress: String,
+        durationBlocks: Long,
+        extraLeadBuffer: Long = 1,
+        maxBlockAttempts: Int = 80,
+        maxExtraOffset: Long = extraLeadBuffer,
+    ): Long {
+        val params = getMaintenanceParams(genesis)
+        repeat(maxBlockAttempts) {
+            val epochData = genesis.getEpochData()
+            for (offset in extraLeadBuffer..maxExtraOffset) {
+                val startHeight = epochData.blockHeight + params.maintenanceMinScheduleLeadBlocks + offset
+
+                Logger.info(
+                    "Evaluating maintenance window candidate: start=$startHeight duration=$durationBlocks " +
+                        "currentHeight=${epochData.blockHeight} phase=${epochData.phase} offset=$offset"
+                )
+
+                val schedulability: MaintenanceSchedulabilityResponse? = try {
+                    querySchedulability(genesis, participantAddress, startHeight, durationBlocks)
+                } catch (e: Exception) {
+                    Logger.warn(e) { "Transient failure while querying schedulability for start=$startHeight duration=$durationBlocks" }
+                    null
+                }
+
+                if (schedulability?.schedulable == true) {
+                    return startHeight
+                }
+                if (schedulability == null) {
+                    Logger.info("Candidate schedulability unavailable yet, retrying on next block")
+                } else {
+                    Logger.info("Candidate rejected: ${schedulability.rejectionReason}")
+                }
+            }
+
+            waitForObservedBlockAdvance(genesis, epochData.blockHeight)
+        }
+
+        error("Unable to find a schedulable maintenance window for duration=$durationBlocks")
+    }
+
+    private fun waitForObservedBlockAdvance(
+        genesis: LocalInferencePair,
+        previousHeight: Long,
+        maxPollAttempts: Int = 30,
+    ) {
+        repeat(maxPollAttempts) {
+            try {
+                val currentHeight = genesis.getCurrentBlockHeight()
+                if (currentHeight > previousHeight) {
+                    return
+                }
+            } catch (e: Exception) {
+                Logger.warn(e) { "Transient failure while waiting for block advance after height $previousHeight" }
+            }
+            Thread.sleep(1000)
+        }
+
+        error("Observed block height did not advance past $previousHeight")
+    }
+
+    /**
+     * Find a future window that deliberately overlaps the next PoC boundary.
+     */
+    private fun findPocOverlapWindowStart(
+        genesis: LocalInferencePair,
+        durationBlocks: Long,
+        maxBlockAttempts: Int = 80,
+    ): Long {
+        val params = getMaintenanceParams(genesis)
+        repeat(maxBlockAttempts) {
+            val epochData = genesis.getEpochData()
+            val nextPocStart = genesis.getNextStage(EpochStage.START_OF_POC)
+            val earliestAllowedStart = epochData.blockHeight + params.maintenanceMinScheduleLeadBlocks
+            val overlapStart = maxOf(earliestAllowedStart, nextPocStart - durationBlocks + 1)
+
+            Logger.info(
+                "Evaluating PoC-overlap window candidate: start=$overlapStart duration=$durationBlocks " +
+                    "currentHeight=${epochData.blockHeight} nextPoC=$nextPocStart"
+            )
+
+            if (overlapStart < nextPocStart && overlapStart + durationBlocks > nextPocStart) {
+                return overlapStart
+            }
+
+            genesis.node.waitForNextBlock(1)
+        }
+
+        error("Unable to find a deterministic PoC-overlap maintenance window")
+    }
+
+    /**
+     * Query schedulability for a proposed maintenance window.
+     */
+    private fun querySchedulability(
+        genesis: LocalInferencePair,
+        participantAddress: String,
+        startHeight: Long,
+        durationBlocks: Long,
+    ): MaintenanceSchedulabilityResponse? {
+        return genesis.node.execAndParse(
+            listOf(
+                "query", "inference", "maintenance-schedulability",
+                participantAddress,
+                startHeight.toString(),
+                durationBlocks.toString()
+            )
+        )
+    }
+
+    /**
+     * Assert that the given validator is still bonded in the active validator set.
+     */
+    private fun assertValidatorBonded(genesis: LocalInferencePair, validatorPubKey: String, message: String) {
+        val validator = checkNotNull(
+            genesis.node.getValidators().validators.find { it.consensusPubkey.value == validatorPubKey }
+        ) { "Validator with pubkey $validatorPubKey not found in validator set" }
+        assertThat(validator.statusEnum)
+            .describedAs(message)
+            .isEqualTo(StakeValidatorStatus.BONDED)
+    }
+
+    @Test
+    @Tag("maintenance")
+    fun `maintenance scheduling semantics are deterministic`() {
+        val (cluster, genesis) = initCluster()
+
+        val params = getMaintenanceParams(genesis)
+        assertThat(params.maintenanceEnabled).isTrue()
+
+        logSection("Earning maintenance credit")
+        genesis.waitForNextEpoch()
+        genesis.waitForNextEpoch()
+
+        val join1 = cluster.joinPairs[0]
+        val join1Address = join1.node.getColdAddress()
+        val requiredCredit = 20L
+        val availableCredit = awaitMinimumCredit(genesis, join1Address, requiredCredit)
+        assertThat(availableCredit).isGreaterThanOrEqualTo(requiredCredit)
+
+        logSection("Verifying zero concurrency before any maintenance is active")
+        val initialConcurrency: MaintenanceConcurrencyResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-concurrency", genesis.getCurrentBlockHeight().toString())
+        )
+        assertThat(initialConcurrency.concurrentCount).isEqualTo(0)
+
+        logSection("Verifying PoC-overlapping window is rejected")
+        val overlapDuration = 3L
+        val overlapStart = findPocOverlapWindowStart(genesis, overlapDuration)
+        val overlapSchedulability = checkNotNull(
+            querySchedulability(genesis, join1Address, overlapStart, overlapDuration)
+        ) { "overlap schedulability query returned null" }
+        assertThat(overlapSchedulability.schedulable)
+            .describedAs("Window overlapping the next PoC transition should be rejected")
+            .isFalse()
+        assertThat(overlapSchedulability.rejectionReason).isNotBlank()
+
+        logSection("Finding a schedulable future window")
+        val durationBlocks = 3L
+        val startHeight = findSchedulableWindowStart(
+            genesis,
+            join1Address,
+            durationBlocks,
+            extraLeadBuffer = 3,
+        )
+        val creditBeforeSchedule: MaintenanceCreditResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-credit", join1Address)
+        )
+        val schedulability = checkNotNull(
+            querySchedulability(genesis, join1Address, startHeight, durationBlocks)
+        ) { "schedulability query returned null for chosen future window" }
+        assertThat(schedulability.schedulable).isTrue()
+
+        logSection("Scheduling maintenance window")
+        val scheduleTx = join1.submitTransaction(
+            listOf(
+                "inference", "schedule-maintenance",
+                "--participant", join1Address,
+                "--start-height", startHeight.toString(),
+                "--duration-blocks", durationBlocks.toString(),
+            )
+        )
+        assertThat(scheduleTx.code).isEqualTo(0)
+
+        val creditAfterSchedule: MaintenanceCreditResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-credit", join1Address)
+        )
+        assertThat(creditAfterSchedule.creditBlocks)
+            .describedAs("Scheduling should reserve credit equal to the window duration")
+            .isEqualTo(creditBeforeSchedule.creditBlocks - durationBlocks)
+
+        val status: MaintenanceStatusResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-status", join1Address)
+        )
+        val scheduled = checkNotNull(status.scheduledReservation) { "scheduled reservation missing after schedule tx" }
+        val reservationId = scheduled.reservationId
+        Logger.info("Reservation ID to cancel: $reservationId")
+
+        // Cancel the maintenance window
+        logSection("Canceling maintenance window")
+        val cancelTx = join1.submitTransaction(
+            listOf(
+                "inference", "cancel-maintenance",
+                "--reservation-id", reservationId.toString(),
+            )
+        )
+        assertThat(cancelTx.code).isEqualTo(0)
+
+        val creditAfterCancel: MaintenanceCreditResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-credit", join1Address)
+        )
+        assertThat(creditAfterCancel.creditBlocks)
+            .describedAs("Credit should be restored after cancellation")
+            .isGreaterThanOrEqualTo(creditBeforeSchedule.creditBlocks)
+
+        val statusAfterCancel: MaintenanceStatusResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-status", join1Address)
+        )
+        assertThat(statusAfterCancel.scheduledReservation).isNull()
+        assertThat(statusAfterCancel.activeReservation).isNull()
+
+        val finalConcurrency: MaintenanceConcurrencyResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-concurrency", genesis.getCurrentBlockHeight().toString())
+        )
+        assertThat(finalConcurrency.concurrentCount).isEqualTo(0)
+
+        genesis.markNeedsReboot()
+    }
+
+    @Test
+    @Tag("maintenance")
+    fun `maintenance lifecycle survives offline validator during maintenance`() {
+        val (cluster, genesis) = initCluster(joinCount = 3, reboot = true)
+
+        val params = getMaintenanceParams(genesis)
+        assertThat(params.maintenanceEnabled).isTrue()
+
+        logSection("Earning maintenance credit")
+        genesis.waitForNextEpoch()
+        genesis.waitForNextEpoch()
+
+        val join1 = cluster.joinPairs[0]
+        val join2 = cluster.joinPairs[1]
+        val join3 = cluster.joinPairs[2]
+        val join1Address = join1.node.getColdAddress()
+        val join1DefaultNode = join1.api.getNodes().first {
+            it.node.host == "ml-0000.${join1.name.trimStart('/')}.test"
+        }.node
+        val genesisValidatorPubKey = genesis.node.getValidatorInfo().key
+        val validatorPubKey = join1.node.getValidatorInfo().key
+        val join2ValidatorPubKey = join2.node.getValidatorInfo().key
+        val join3ValidatorPubKey = join3.node.getValidatorInfo().key
+        val requiredCredit = 10L
+        val creditBlocks = awaitMinimumCredit(genesis, join1Address, requiredCredit)
+        assertThat(creditBlocks).isGreaterThanOrEqualTo(requiredCredit)
+
+        logSection("Reducing join1 voting power so the cluster stays live while join1 is offline")
+        genesis.waitForStage(EpochStage.SET_NEW_VALIDATORS)
+        join1.setPocWeight(5, join1DefaultNode)
+        join1.waitForNextEpoch()
+        join1.node.waitForNextBlock(1)
+        val reducedJoin1Validator = join1.node.getValidators().validators.first {
+            it.consensusPubkey.value == validatorPubKey
+        }
+        assertThat(reducedJoin1Validator.tokens)
+            .describedAs("join1 voting power should be reduced before taking it offline")
+            .isEqualTo(5)
+        join1.node.waitForNextBlock(1)
+        val reducedJoin1CometValidator = genesis.node.getCometValidators().validators.first {
+            it.pubKey.key == validatorPubKey
+        }
+        assertThat(reducedJoin1CometValidator.votingPower)
+            .describedAs("join1 comet voting power should be reduced before taking it offline")
+            .isEqualTo("5")
+        waitForCometValidatorPowers(
+            genesis,
+            mapOf(
+                genesisValidatorPubKey to "10",
+                validatorPubKey to "5",
+                join2ValidatorPubKey to "10",
+                join3ValidatorPubKey to "10",
+            )
+        )
+
+        val durationBlocks = 6L
+        logSection("Scheduling a future maintenance window")
+        val startHeight = findSchedulableWindowStart(
+            genesis,
+            join1Address,
+            durationBlocks,
+            extraLeadBuffer = 5,
+            maxBlockAttempts = 200,
+            maxExtraOffset = 80,
+        )
+        val scheduleTx = join1.submitTransaction(
+            listOf(
+                "inference", "schedule-maintenance",
+                "--participant", join1Address,
+                "--start-height", startHeight.toString(),
+                "--duration-blocks", durationBlocks.toString(),
+            )
+        )
+        assertThat(scheduleTx.code).isEqualTo(0)
+
+        val scheduledStatus: MaintenanceStatusResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-status", join1Address)
+        )
+        val scheduledReservation = checkNotNull(scheduledStatus.scheduledReservation) {
+            "Scheduled reservation missing after maintenance scheduling"
+        }
+        assertThat(scheduledReservation.startHeight).isEqualTo(startHeight)
+        assertThat(scheduledReservation.durationBlocks).isEqualTo(durationBlocks)
+
+        assertValidatorBonded(
+            genesis,
+            validatorPubKey,
+            "Validator should be bonded before maintenance activation"
+        )
+
+        logSection("Waiting for maintenance activation")
+        genesis.node.waitForMinimumBlock(startHeight + 1, "maintenance activation")
+
+        val activeResponse: MaintenanceActiveResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-active")
+        )
+        assertThat(activeResponse.reservations).hasSize(1)
+        assertThat(activeResponse.reservations.single().participant).isEqualTo(join1Address)
+
+        val activeConcurrency: MaintenanceConcurrencyResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-concurrency", genesis.getCurrentBlockHeight().toString())
+        )
+        assertThat(activeConcurrency.concurrentCount).isEqualTo(1)
+
+        val endHeight = startHeight + durationBlocks
+        val currentHeightBeforeStop = genesis.getCurrentBlockHeight()
+        assertThat(currentHeightBeforeStop)
+            .describedAs("Maintenance window should still have runway left before taking join1 offline")
+            .isLessThan(endHeight - 1)
+        assertRemainingValidatorsCanMaintainQuorum(genesis, validatorPubKey)
+
+        logSection("Stopping join1 chain node during active maintenance")
+        stopNodeContainer(join1)
+
+        logSection("Waiting for the maintenance window to complete")
+        genesis.node.waitForMinimumBlock(endHeight + 2, "maintenance completion")
+
+        assertValidatorBonded(
+            genesis,
+            validatorPubKey,
+            "Validator should remain bonded after being offline during maintenance"
+        )
+
+        val statusAfterMaintenance: MaintenanceStatusResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-status", join1Address)
+        )
+        assertThat(statusAfterMaintenance.activeReservation).isNull()
+        assertThat(statusAfterMaintenance.scheduledReservation).isNull()
+
+        val activeAfterMaintenance: MaintenanceActiveResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-active")
+        )
+        assertThat(activeAfterMaintenance.reservations.none { it.participant == join1Address }).isTrue()
+
+        val concurrencyAfterMaintenance: MaintenanceConcurrencyResponse = genesis.node.execAndParse(
+            listOf("query", "inference", "maintenance-concurrency", genesis.getCurrentBlockHeight().toString())
+        )
+        assertThat(concurrencyAfterMaintenance.concurrentCount).isEqualTo(0)
+
+        genesis.markNeedsReboot()
+    }
+}
diff --git a/testermint/src/test/kotlin/MultiModelPoCTests.kt b/testermint/src/test/kotlin/MultiModelPoCTests.kt
index 80c8519425..a08888818c 100644
--- a/testermint/src/test/kotlin/MultiModelPoCTests.kt
+++ b/testermint/src/test/kotlin/MultiModelPoCTests.kt
@@ -140,26 +140,8 @@ class MultiModelPoCTests : TestermintTest() {
             }
         }
 
-        logSection("Setting up inference responses per model")
-        allPairs.forEach { pair ->
-            pair.mock?.setInferenceResponse(
-                defaultInferenceResponseObject.withResponse("response-model-a"),
-                model = defaultModel,
-            )
-            pair.mock?.setInferenceResponse(
-                defaultInferenceResponseObject.withResponse("response-model-b"),
-                model = secondModel,
-            )
-        }
-
-        logSection("Making inference request for model A")
-        genesis.waitForNextInferenceWindow()
-        val responseA = genesis.makeInferenceRequest(inferenceRequest)
-        assertThat(responseA.choices.first().message.content).isEqualTo("response-model-a")
-
-        logSection("Making inference request for model B")
-        val requestB = cosmosJson.toJson(inferenceRequestObject.copy(model = secondModel))
-        val responseB = genesis.makeInferenceRequest(requestB)
-        assertThat(responseB.choices.first().message.content).isEqualTo("response-model-b")
+        // NOTE: This test previously finished with a classic inference request per model as a routing
+        // smoke check. Classic inference was removed (PR #1386); the PoC weight/commit/slot assertions
+        // above are the substance of this test and do not depend on it.
     }
 }
diff --git a/testermint/src/test/kotlin/MultiModelTests.kt b/testermint/src/test/kotlin/MultiModelTests.kt
index 6eb928659a..06bd42a06e 100644
--- a/testermint/src/test/kotlin/MultiModelTests.kt
+++ b/testermint/src/test/kotlin/MultiModelTests.kt
@@ -30,6 +30,7 @@ class MultiModelTests : TestermintTest() {
     }
 
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `simple multi model`() {
         val (cluster, genesis) = initCluster(3, mergeSpec = secondModelSpec)
         val (newModelName, secondModelPairs) = setSecondModel(cluster, genesis)
@@ -103,6 +104,11 @@ class MultiModelTests : TestermintTest() {
 
 
     @Test
+    // Classic inference flow removed (PR #1386). This test "passed" on the deprecation branch only
+    // because runParallelInferencesWithResults swallows request failures: every request 410s, the
+    // helper returns an empty list, and all verification loops run over nothing (vacuous green).
+    // Needs a devshard-based rewrite before it provides real coverage again.
+    @Tag("exclude")
     fun `multi model inferences get validated and claimed`() {
         val (cluster, genesis) = initCluster(3, reboot = true, mergeSpec = secondModelSpec)
         logSection("Setting up second model")
diff --git a/testermint/src/test/kotlin/NodeAdminStateTests.kt b/testermint/src/test/kotlin/NodeAdminStateTests.kt
index a36a174d2b..958d1797e9 100644
--- a/testermint/src/test/kotlin/NodeAdminStateTests.kt
+++ b/testermint/src/test/kotlin/NodeAdminStateTests.kt
@@ -55,10 +55,8 @@ class NodeAdminStateTests : TestermintTest() {
         val disableEpoch = disabledNode.state.adminState?.epoch ?: 0UL
         Logger.info("Node disabled at epoch: $disableEpoch")
         
-        logSection("Making inference request to verify disabled node still serves")
-        val inferenceResult = getInferenceResult(genesis)
-        assertThat(inferenceResult).isNotNull
-        
+        // Classic-inference "disabled node still serves" check removed with the
+        // dapi deprecation; the state assertions below still cover disable/enable.
         logSection("Waiting for PoC phase to verify node stops")
         genesis.waitForStage(EpochStage.START_OF_POC)
         genesis.node.waitForNextBlock(2)
diff --git a/testermint/src/test/kotlin/NodeDisableInferenceTests.kt b/testermint/src/test/kotlin/NodeDisableInferenceTests.kt
index d0901bf9be..d8b670c2bc 100644
--- a/testermint/src/test/kotlin/NodeDisableInferenceTests.kt
+++ b/testermint/src/test/kotlin/NodeDisableInferenceTests.kt
@@ -3,11 +3,14 @@ import com.productscience.assertions.assertThat
 import com.productscience.data.getParticipant
 import com.github.kittinunf.fuel.core.FuelError
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import org.tinylog.kotlin.Logger
 import java.util.concurrent.TimeUnit
 
+// Relies on classic inference assignment/rewards, which were removed (PR #1386); was failing on base before that too.
+@Tag("exclude")
 @Timeout(value = 15, unit = TimeUnit.MINUTES)
 class NodeDisableInferenceTests : TestermintTest() {
 
diff --git a/testermint/src/test/kotlin/ParticipantTests.kt b/testermint/src/test/kotlin/ParticipantTests.kt
index 4c3dd0d894..1598f55547 100644
--- a/testermint/src/test/kotlin/ParticipantTests.kt
+++ b/testermint/src/test/kotlin/ParticipantTests.kt
@@ -73,7 +73,14 @@ class ParticipantTests : TestermintTest() {
         assertThat(newPair.node.logOutput.minimumHeight).isLessThan(currentHeight)
     }
 
+    // Classic inference flow removed (PR #1386). TrafficBasis is derived from
+    // EpochGroupData.NumberOfRequests, incremented only while queueing classic
+    // inferences for validation (inference_validation_endblock.go). Devshard
+    // validates inside shard sessions and never feeds this metric, so there is
+    // no non-classic way to move it. The classic validation-average mechanism is
+    // a dead-code candidate alongside dynamic pricing (see PR #1386 notes).
     @Test
+    @Tag("exclude")
     fun `traffic basis decreases minimum average validation`() {
         val (_, genesis) = initCluster()
         logSection("Making sure traffic basis is low")
diff --git a/testermint/src/test/kotlin/PromptHashingTests.kt b/testermint/src/test/kotlin/PromptHashingTests.kt
index 31052aadf0..7bbeed8b31 100644
--- a/testermint/src/test/kotlin/PromptHashingTests.kt
+++ b/testermint/src/test/kotlin/PromptHashingTests.kt
@@ -41,4 +41,17 @@ class PromptHashingTests {
         val streamOptions = modifiedMap["stream_options"] as Map<String, Any?>
         assertThat(streamOptions["include_usage"]).isEqualTo(true)
     }
+
+    @Test
+    fun `logprob manipulation produces different hash`() {
+        // Security test: payloads with same content but different logprobs must have different hashes
+        // This prevents attack where executor serves fake logprobs with valid content
+        val payloadWithRealLogprobs = """{"id":"inf-1","choices":[{"index":0,"message":{"role":"assistant","content":"Hello"},"logprobs":{"content":[{"token":"Hello","logprob":-0.5,"top_logprobs":[{"token":"Hello","logprob":-0.5}]}]}}]}"""
+        val payloadWithFakeLogprobs = """{"id":"inf-1","choices":[{"index":0,"message":{"role":"assistant","content":"Hello"},"logprobs":{"content":[{"token":"Hello","logprob":-0.1,"top_logprobs":[{"token":"Hello","logprob":-0.1}]}]}}]}"""
+
+        val hash1 = computeResponseHash(payloadWithRealLogprobs)
+        val hash2 = computeResponseHash(payloadWithFakeLogprobs)
+
+        assertThat(hash1).isNotEqualTo(hash2)
+    }
 }
diff --git a/testermint/src/test/kotlin/PruningTests.kt b/testermint/src/test/kotlin/PruningTests.kt
index 5554a8fbd1..a33892094d 100644
--- a/testermint/src/test/kotlin/PruningTests.kt
+++ b/testermint/src/test/kotlin/PruningTests.kt
@@ -3,6 +3,7 @@ import com.productscience.inferenceRequest
 import com.productscience.initCluster
 import com.productscience.logSection
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.tinylog.kotlin.Logger
 import java.time.Duration
@@ -10,6 +11,7 @@ import kotlin.test.assertNotNull
 
 class PruningTests : TestermintTest() {
     @Test
+    @Tag("exclude") // Classic inference flow removed (PR #1386)
     fun `prune inferences`() {
         val (_, genesis) = initCluster(reboot = true)
         genesis.waitForStage(EpochStage.SET_NEW_VALIDATORS, offset = 2)
diff --git a/testermint/src/test/kotlin/RestrictionsTests.kt b/testermint/src/test/kotlin/RestrictionsTests.kt
index 795dcb61b9..773a5bd2b3 100644
--- a/testermint/src/test/kotlin/RestrictionsTests.kt
+++ b/testermint/src/test/kotlin/RestrictionsTests.kt
@@ -2,7 +2,6 @@ import com.productscience.*
 import com.productscience.data.*
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
-import java.time.Duration
 import kotlin.test.assertNotNull
 
 import org.junit.jupiter.api.BeforeAll
@@ -46,7 +45,6 @@ class RestrictionsTests : TestermintTest() {
             logHighlight("  • Restriction deadline set to block 100 for fast testing")
             logHighlight("  • User-to-user transfers blocked during restriction period")
             logHighlight("  • Gas fee payments allowed during restrictions")
-            logHighlight("  • Inference payments work normally")
             logHighlight("  • Governance emergency exemptions")
             logHighlight("  • Automatic restriction lifting at deadline (block 100)")
             logHighlight("  • Parameter governance control")
@@ -175,34 +173,8 @@ class RestrictionsTests : TestermintTest() {
         
         assertThat(result.isSuccess).isTrue()
         logHighlight("✅ Gas fee transaction successful")
-        
-        // Test 2: Inference payments should work normally
-        logHighlight("Testing inference payments work during restrictions")
-        val beforeInferenceBalance = genesis.getBalance(genesis.node.getColdAddress())
-        
-        // Make an inference request (this involves escrow payment to inference module)
-        logHighlight("Making inference request to test module payments")
-        cluster.allPairs.forEach {
-            it.mock?.setInferenceResponse(defaultInferenceResponseObject, Duration.ofSeconds(10))
-        }
-        
-        val inferenceResult = runCatching {
-            genesis.makeInferenceRequest(inferenceRequest)
-        }
-        
-        assertThat(inferenceResult.isSuccess).isTrue()
-        genesis.node.waitForNextBlock(2)
-        
-        val afterInferenceBalance = genesis.getBalance(genesis.node.getColdAddress())
-        val inferenceCost = beforeInferenceBalance - afterInferenceBalance
-        
-        logHighlight("✅ Inference payment successful:")
-        logHighlight("  • Before: $beforeInferenceBalance ngonka")
-        logHighlight("  • After: $afterInferenceBalance ngonka") 
-        logHighlight("  • Cost: $inferenceCost ngonka")
-        
-        assertThat(inferenceCost).isGreaterThan(0)
-        logHighlight("✅ Module payments (escrow) work correctly during restrictions")
+        // Classic-inference payment check removed with the dapi deprecation
+        // (devshard escrow payments are covered by the devshard test suites).
     }
 
     private fun testGovernanceEmergencyExemptions(genesis: LocalInferencePair, cluster: LocalCluster, fromAddress: String, toAddress: String) {
diff --git a/testermint/src/test/kotlin/StatsApiE2ETest.kt b/testermint/src/test/kotlin/StatsApiE2ETest.kt
index 17fce79ff3..1f349a1abb 100644
--- a/testermint/src/test/kotlin/StatsApiE2ETest.kt
+++ b/testermint/src/test/kotlin/StatsApiE2ETest.kt
@@ -4,11 +4,14 @@ import com.productscience.data.DeveloperInferencesResponse
 import com.productscience.data.StatsModelsResponse
 import com.productscience.data.StatsSummaryResponse
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import java.time.Duration
 import java.util.concurrent.TimeUnit
 
+// Classic inference flow was removed (PR #1386); stats ingestion here depends on the deprecated endpoints.
+@Tag("exclude")
 @Timeout(value = 15, unit = TimeUnit.MINUTES)
 class StatsApiE2ETest : TestermintTest() {
 
diff --git a/testermint/src/test/kotlin/StreamVestingTests.kt b/testermint/src/test/kotlin/StreamVestingTests.kt
index 2b6c2e9fc8..9145c2a73e 100644
--- a/testermint/src/test/kotlin/StreamVestingTests.kt
+++ b/testermint/src/test/kotlin/StreamVestingTests.kt
@@ -3,13 +3,13 @@ import com.productscience.data.spec
 import com.productscience.data.AppState
 import com.productscience.data.InferenceState
 import com.productscience.data.InferenceParams
-import com.productscience.data.BitcoinRewardParams
 import com.productscience.data.EpochParams
 import com.productscience.data.TokenomicsParams
 import java.time.Duration
 import java.net.SocketException
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.data.Offset
+import org.junit.jupiter.api.Assumptions
 import org.junit.jupiter.api.Test
 import org.tinylog.kotlin.Logger
 
@@ -34,19 +34,35 @@ class StreamVestingTests : TestermintTest() {
         throw lastFailure ?: IllegalStateException("Stream vesting cluster bootstrap failed")
     }
 
+    /**
+     * PoC-driven vesting test. Bitcoin-style epoch rewards are unconditional
+     * (paid for PoC weight at CLAIM_REWARDS, no inference traffic required), so
+     * this drives no traffic at all and verifies, across one full reward cycle:
+     *
+     *  1. New epoch rewards land in the vesting schedule, not the liquid balance.
+     *  2. The liquid balance grows by exactly the previously-scheduled first-epoch
+     *     unlock (read from the schedule beforehand — no reward prediction needed).
+     *  3. Aggregation: the new schedule's first epoch = old second epoch + first
+     *     half of the new reward; second epoch = second half of the new reward
+     *     (computed with calculateVestingScheduleChanges over an empty inference
+     *     list, which yields pure PoC epoch-reward vesting).
+     *
+     * Replaces the classic-inference-driven version removed with PR #1386; that
+     * version was also historically flaky because its expected-balance arithmetic
+     * depended on per-inference cost settlement.
+     */
     @Test
-    fun `comprehensive vesting test with automatic reward system detection`() {
+    fun `epoch rewards vest and unlock without inference traffic`() {
         // Configure genesis with 2-epoch vesting periods for fast testing
         val fastVestingSpec = spec {
             this[AppState::inference] = spec<InferenceState> {
                 this[InferenceState::params] = spec<InferenceParams> {
                     this[InferenceParams::tokenomicsParams] = spec<TokenomicsParams> {
-                        this[TokenomicsParams::workVestingPeriod] = 2L       // 2 epochs for work coins
-                        this[TokenomicsParams::rewardVestingPeriod] = 2L     // 2 epochs for reward coins
+                        this[TokenomicsParams::workVestingPeriod] = 2L
+                        this[TokenomicsParams::rewardVestingPeriod] = 2L
                     }
                     this[InferenceParams::epochParams] = spec<EpochParams> {
-                        this[EpochParams::epochLength] = 25L                 // This test doesn't fit in 15 blocks
-
+                        this[EpochParams::epochLength] = 25L
                     }
                 }
             }
@@ -56,325 +72,99 @@ class StreamVestingTests : TestermintTest() {
             genesisSpec = inferenceConfig.genesisSpec?.merge(fastVestingSpec) ?: fastVestingSpec
         )
 
-        val (cluster, genesis) = initVestingCluster(fastVestingConfig)
+        val (_, genesis) = initVestingCluster(fastVestingConfig)
 
         val params = genesis.node.getInferenceParams().params
-        val isBitcoinEnabled = isBitcoinRewardsEnabled(params.bitcoinRewardParams)
-        
-        logSection("=== VESTING TEST WITH AUTOMATIC REWARD SYSTEM DETECTION ===")
-        if (isBitcoinEnabled) {
-            logHighlight("✅ Bitcoin Rewards System DETECTED - Running Bitcoin vesting test")
-            logHighlight("  • Fixed epoch rewards based on PoC weight")
-            logHighlight("  • No immediate RewardCoins bonuses per inference")
-            logHighlight("  • Epoch rewards distributed at CLAIM_REWARDS stage")
-            testBitcoinRewardSystemVesting(cluster, genesis)
-        } else {
-            logHighlight("✅ Legacy Rewards System DETECTED - Running legacy vesting test")
-            logHighlight("  • Variable subsidies based on total network work")
-            logHighlight("  • Immediate RewardCoins bonuses per inference")
-            logHighlight("  • All rewards subject to vesting periods")
-            testLegacyRewardSystemVesting(cluster, genesis)
-        }
-    }
-
-    private fun testLegacyRewardSystemVesting(cluster: LocalCluster, genesis: LocalInferencePair) {
-        val participant = genesis
-        val participantAddress = participant.node.getColdAddress()
-
-        logSection("=== LEGACY REWARD SYSTEM VESTING TEST ===")
-        logHighlight("Testing comprehensive vesting with legacy variable reward system")
-        logHighlight("  • Variable subsidies based on total network work")
-        logHighlight("  • Immediate RewardCoins bonuses per inference")
-        logHighlight("  • All rewards subject to vesting periods")
-        
-        logSection("Waiting for system to be ready for inferences")
-        genesis.waitForStage(EpochStage.CLAIM_REWARDS)
-
-        logSection("=== SCENARIO 1: Test Reward Vesting ===")
-        logHighlight("Querying initial participant balance")
-        val initialBalance = participant.getBalance(participantAddress)
-        logHighlight("Initial balance: $initialBalance ngonka")
-
-        // Query initial vesting schedule (should be empty)
-        logHighlight("Querying initial vesting schedule")
-        val initialVestingSchedule = participant.node.queryVestingSchedule(participantAddress)
-        assertThat(initialVestingSchedule.vestingSchedule?.epochAmounts).isNullOrEmpty()
-
-        logSection("Making 20 parallel inference requests to earn rewards")
-        val futures = (1..20).map { i ->
-            java.util.concurrent.CompletableFuture.supplyAsync {
-                logSection("Starting inference request $i")
-                getInferenceResult(participant)
-            }
-        }
-        
-        val allResults = futures.map { it.get() }
-        logSection("Completed 20 inference requests")
-        
-        val participantInferences = allResults.filter { it.inference.assignedTo == participantAddress }
-        logHighlight("Found ${participantInferences.size} inferences assigned to participant ($participantAddress)")
-        
-        allResults.forEachIndexed { index, result ->
-            logHighlight("Inference ${index + 1}: assigned_to: ${result.inference.assignedTo}, executed_by: ${result.inference.executedBy}")
-        }
-        
-        require(participantInferences.isNotEmpty()) { "No inference was assigned to participant $participantAddress" }
-        val inferenceResult = participantInferences.first()
-        logHighlight("Using inference: ${inferenceResult.inference.inferenceId}")
-
-        logSection("Waiting for inference to be processed and rewards calculated")
-        participant.waitForStage(EpochStage.CLAIM_REWARDS)
-        participant.node.waitForNextBlock(2)
-
-        logSection("Verifying reward vesting: balance should NOT increase immediately")
-        val balanceAfterReward = participant.getBalance(participantAddress)
-        logHighlight("Balance after reward: $balanceAfterReward ngonka")
-        
-        // Balance should not increase immediately due to vesting
-        assertThat(balanceAfterReward).isLessThanOrEqualTo(initialBalance)
-
-        logSection("Verifying vesting schedule was created correctly")
-        val vestingScheduleAfterReward = participant.node.queryVestingSchedule(participantAddress)
-        assertThat(vestingScheduleAfterReward.vestingSchedule?.epochAmounts).isNotEmpty()
-        assertThat(vestingScheduleAfterReward.vestingSchedule?.epochAmounts).hasSize(2) // 2-epoch vesting period
-
-        val totalVestingAmount = vestingScheduleAfterReward.vestingSchedule?.epochAmounts?.sumOf { 
-            it.coins.sumOf { coin -> coin.amount } 
-        } ?: 0
-        logHighlight("Total amount vesting: $totalVestingAmount nicoin over 2 epochs")
-        assertThat(totalVestingAmount).isGreaterThan(0)
-
-        logSection("=== SCENARIO 2: Test Epoch Unlocking ===")
-        logHighlight("Waiting for first epoch to unlock vested tokens")
-        participant.waitForStage(EpochStage.SET_NEW_VALIDATORS)
-        participant.node.waitForNextBlock(2)
-
-        val balanceAfterFirstEpoch = participant.getBalance(participantAddress)
-        logHighlight("Balance after first epoch unlock: $balanceAfterFirstEpoch ngonka")
-        // Balance should increase after first epoch unlock
-        assertThat(balanceAfterFirstEpoch).isGreaterThan(balanceAfterReward)
-
-        logHighlight("Verifying vesting schedule updated (should have 1 epoch left)")
-        val vestingAfterFirstEpoch = participant.node.queryVestingSchedule(participantAddress)
-        if (!vestingAfterFirstEpoch.vestingSchedule?.epochAmounts.isNullOrEmpty()) {
-            assertThat(vestingAfterFirstEpoch.vestingSchedule?.epochAmounts).hasSize(1) // 1 epoch remaining
-        }
-
-        logSection("Waiting for second epoch to unlock remaining vested tokens")
-        participant.waitForStage(EpochStage.SET_NEW_VALIDATORS)
-        participant.node.waitForNextBlock(2)
-
-        val balanceAfterSecondEpoch = participant.getBalance(participantAddress)
-        logHighlight("Balance after second epoch unlock: $balanceAfterSecondEpoch ngonka")
-        // Balance should increase further after second epoch unlock
-        assertThat(balanceAfterSecondEpoch).isGreaterThan(balanceAfterFirstEpoch)
-
-        logHighlight("Verifying vesting schedule is now empty (all tokens unlocked)")
-        val finalVestingSchedule = participant.node.queryVestingSchedule(participantAddress)
-        assertThat(finalVestingSchedule.vestingSchedule?.epochAmounts).isNullOrEmpty()
-
-        logSection("=== SCENARIO 3: Test Reward Aggregation ===")
-        logSection("Making 20 parallel second inference requests for aggregation test")
-        val secondFutures = (1..20).map { i ->
-            java.util.concurrent.CompletableFuture.supplyAsync {
-                logHighlight("Starting second inference request $i")
-                getInferenceResult(participant)
-            }
-        }
-        
-        val secondAllResults = secondFutures.map { it.get() }
-        logSection("Completed 20 second inference requests")
-        
-        val secondParticipantInferences = secondAllResults.filter { it.inference.assignedTo == participantAddress }
-        logHighlight("Found ${secondParticipantInferences.size} second inferences assigned to participant ($participantAddress)")
-        
-        secondAllResults.forEachIndexed { index, result ->
-            logHighlight("Second inference ${index + 1}: assigned_to: ${result.inference.assignedTo}, executed_by: ${result.inference.executedBy}")
-        }
-        
-        require(secondParticipantInferences.isNotEmpty()) { "No second inference was assigned to participant $participantAddress" }
-        val secondInferenceResult = secondParticipantInferences.first()
-        logHighlight("Using second inference: ${secondInferenceResult.inference.inferenceId}")
-
-        logSection("Waiting for second reward to be processed")
-        participant.waitForStage(EpochStage.CLAIM_REWARDS) 
-        participant.node.waitForNextBlock(2)
-
-        val balanceBeforeAggregation = participant.getBalance(participantAddress)
-        logHighlight("Balance before aggregation test: $balanceBeforeAggregation ngonka")
-
-        logSection("Making 20 parallel third inference requests to test aggregation")
-        val thirdFutures = (1..20).map { i ->
-            java.util.concurrent.CompletableFuture.supplyAsync {
-                logSection("Starting third inference request $i")
-                getInferenceResult(participant)
-            }
-        }
-        
-        val thirdAllResults = thirdFutures.map { it.get() }
-        logHighlight("Completed 20 third inference requests")
-        
-        val thirdParticipantInferences = thirdAllResults.filter { it.inference.assignedTo == participantAddress }
-        logHighlight("Found ${thirdParticipantInferences.size} third inferences assigned to participant ($participantAddress)")
-        
-        thirdAllResults.forEachIndexed { index, result ->
-            logHighlight("Third inference ${index + 1}: assigned_to: ${result.inference.assignedTo}, executed_by: ${result.inference.executedBy}")
-        }
-        
-        require(thirdParticipantInferences.isNotEmpty()) { "No third inference was assigned to participant $participantAddress" }
-        val thirdInferenceResult = thirdParticipantInferences.first()
-        logHighlight("Using third inference: ${thirdInferenceResult.inference.inferenceId}")
-
-        logSection("Waiting for third reward to be processed and aggregated")
-        participant.waitForStage(EpochStage.CLAIM_REWARDS)
-        participant.node.waitForNextBlock(2)
-
-        logSection("Verifying reward aggregation: should still be 2-epoch schedule")
-        val aggregatedVestingSchedule = participant.node.queryVestingSchedule(participantAddress)
-        assertThat(aggregatedVestingSchedule.vestingSchedule?.epochAmounts).isNotEmpty()
-        assertThat(aggregatedVestingSchedule.vestingSchedule?.epochAmounts).hasSize(2) // Still 2 epochs, not extended
-
-        val aggregatedTotalAmount = aggregatedVestingSchedule.vestingSchedule?.epochAmounts?.sumOf { 
-            it.coins.sumOf { coin -> coin.amount } 
-        } ?: 0
-        logHighlight("Total aggregated vesting amount: $aggregatedTotalAmount ngonka")
-        
-        // The aggregated amount should be greater than a single reward
-        // TODO: unfortunatelly, it's not true, because we can't guarantee that the rewards are equal each time to the same validator
-        // assertThat(aggregatedTotalAmount).isGreaterThan(totalVestingAmount)
-
-        logSection("=== LEGACY REWARD SYSTEM VESTING TEST COMPLETED ===")
-        logHighlight("All scenarios verified for legacy variable reward system:")
-        logHighlight("✅ Reward vesting - rewards vest over 2 epochs instead of immediate payment")
-        logHighlight("✅ Epoch unlocking - tokens unlock progressively over 2 epochs")
-        logHighlight("✅ Reward aggregation - multiple rewards aggregate into same 2-epoch schedule")
-        logHighlight("✅ Legacy system compatibility - immediate RewardCoins bonuses work with vesting")
-    }
-
-    private fun testBitcoinRewardSystemVesting(cluster: LocalCluster, genesis: LocalInferencePair) {
-        val participant = genesis
-        val participantAddress = participant.node.getColdAddress()
-
-        logSection("=== BITCOIN REWARD SYSTEM VESTING TEST ===")
-        logSection("Testing vesting aggregation with Bitcoin-style fixed reward system")
-        logSection("  • Fixed epoch rewards based on PoC weight")
-        logSection("  • No immediate RewardCoins bonuses per inference")
-        logSection("  • Epoch rewards distributed at CLAIM_REWARDS stage")
-        logSection("  • All rewards subject to vesting periods")
-        
-        logSection("Waiting for system to be ready for inferences")
-        genesis.waitForStage(EpochStage.CLAIM_REWARDS)
-
-        logSection("=== SCENARIO 1: Test Reward Vesting Aggregation ===")
-        logSection("Querying initial participant state")
-        val initialBalance = participant.getBalance(participantAddress)
-        val startLastRewardedEpoch = getRewardCalculationEpochIndex(participant)
-        
-        // Query initial vesting schedule (may have existing vesting from epoch rewards)
-        val initialVestingSchedule = participant.node.queryVestingSchedule(participantAddress)
-        val initialTotalVesting = initialVestingSchedule.vestingSchedule?.epochAmounts?.sumOf { 
-            it.coins.sumOf { coin -> coin.amount } 
-        } ?: 0
-        // Only the first epoch should unlock during this claim rewards cycle
-        val initialFirstEpochUnlock = initialVestingSchedule.vestingSchedule?.epochAmounts?.firstOrNull()?.coins?.sumOf { coin -> coin.amount } ?: 0
-        val initialSecondEpoch = initialVestingSchedule.vestingSchedule?.epochAmounts?.getOrNull(1)?.coins?.sumOf { coin -> coin.amount } ?: 0
-        logSection("Initial balance: $initialBalance nicoin, start epoch: $startLastRewardedEpoch")
-        logSection("Initial vesting - Total: $initialTotalVesting, First unlock: $initialFirstEpochUnlock, Second remaining: $initialSecondEpoch")
-
-        logSection("Making 20 parallel inference requests to earn rewards")
-        val futures = (1..20).map { i ->
-            java.util.concurrent.CompletableFuture.supplyAsync {
-                logSection("Starting inference request $i")
-                getInferenceResult(participant)
-            }
-        }
-        
-        val allResults = futures.map { it.get() }
-        logSection("Completed 20 inference requests")
-        
-        val participantInferences = allResults.filter { it.inference.assignedTo == participantAddress }
-        logSection("Found ${participantInferences.size} inferences assigned to participant ($participantAddress)")
-        
-        allResults.forEachIndexed { index, result ->
-            logSection("Inference ${index + 1}: assigned_to: ${result.inference.assignedTo}, executed_by: ${result.inference.executedBy}")
-        }
-        
-        require(participantInferences.isNotEmpty()) { "No inference was assigned to participant $participantAddress" }
-
-        logSection("Waiting for next claim reward cycle to process rewards and vesting")
-        participant.waitForStage(EpochStage.CLAIM_REWARDS)
-        participant.node.waitForNextBlock(2)
-
-        // Re-query all inferences to get their final settled status and accurate costs
-        logSection("Re-querying all inferences to get final settled status")
-        val settledInferences = allResults.map { participant.api.getInference(it.inference.inferenceId) }
-        logSection("Settled ${settledInferences.size} inferences with updated status and costs")
-
-        // Calculate expected vesting schedule from this reward cycle
-        val inferencePayloads = settledInferences  // Use fresh settled data instead of original
-        val participants = participant.api.getParticipants()
-        val currentLastRewardedEpoch = getRewardCalculationEpochIndex(participant)
-        
-        val expectedVestingSchedule = calculateVestingScheduleChanges(
-            inferencePayloads,
-            participant.node.getInferenceParams().params,
-            participants,
-            startLastRewardedEpoch,
-            currentLastRewardedEpoch,
-            vestingPeriod = 2  // 2-epoch vesting period
+        // Legacy (pre-Bitcoin) rewards were per-inference and cannot be exercised
+        // without the removed classic inference flow; Bitcoin rewards are the
+        // active system everywhere this test matters.
+        Assumptions.assumeTrue(
+            isBitcoinRewardsEnabled(params.bitcoinRewardParams),
+            "Bitcoin rewards disabled; legacy per-inference vesting is untestable without classic inference"
         )
-        val expectedSchedule = expectedVestingSchedule[participantAddress] ?: LongArray(3) { 0L }
-        val expectedCosts = expectedSchedule[0]  // Immediate costs (negative)
-        val expectedFirstVesting = expectedSchedule[1]  // First epoch from new rewards
-        val expectedSecondVesting = expectedSchedule[2]  // Second epoch from new rewards
-        val expectedNewVesting = expectedFirstVesting + expectedSecondVesting  // Total new vesting
 
-        logSection("Verifying balance and vesting changes after claim rewards")
-        val balanceAfterReward = participant.getBalance(participantAddress)
-        logSection("Balance after reward: $balanceAfterReward ngonka")
-        
-        // Balance change = -inference_costs + unlocked_initial_vesting (first epoch only)
-        val actualBalanceChange = balanceAfterReward - initialBalance
-        logSection("Actual balance change: $actualBalanceChange ngonka")
-        logSection("Expected components: ${expectedCosts} (costs) + $initialFirstEpochUnlock (first epoch unlock)")
-        val expectedBalanceChange = expectedCosts + initialFirstEpochUnlock  // expectedCosts is negative
-        
-        // Balance should change by costs paid plus any initial vesting unlocked
-        assertThat(actualBalanceChange).isCloseTo(expectedBalanceChange, Offset.offset(1L))
-
-        logSection("Verifying new vesting schedule aggregation")
-        val vestingScheduleAfterReward = participant.node.queryVestingSchedule(participantAddress)
-        val newFirstEpoch = vestingScheduleAfterReward.vestingSchedule?.epochAmounts?.getOrNull(0)?.coins?.sumOf { coin -> coin.amount } ?: 0
-        val newSecondEpoch = vestingScheduleAfterReward.vestingSchedule?.epochAmounts?.getOrNull(1)?.coins?.sumOf { coin -> coin.amount } ?: 0
-        val newTotalVesting = newFirstEpoch + newSecondEpoch
-        
-        logSection("New vesting structure:")
-        logSection("  First epoch: $newFirstEpoch ngonka")
-        logSection("  Second epoch: $newSecondEpoch ngonka")
-        logSection("  Total: $newTotalVesting ngonka")
-        
-        // Expected aggregation:
-        // First epoch = initial second epoch + new first epoch
-        // Second epoch = new second epoch
-        val expectedNewFirstEpoch = initialSecondEpoch + expectedFirstVesting
-        val expectedNewSecondEpoch = expectedSecondVesting
-        
-        logSection("Expected vesting structure:")
-        logSection("  First epoch: $expectedNewFirstEpoch nicoin (initial second: $initialSecondEpoch + new first: $expectedFirstVesting)")
-        logSection("  Second epoch: $expectedNewSecondEpoch nicoin (new second: $expectedSecondVesting)")
-        
-        // Verify epoch-by-epoch aggregation
-        assertThat(newFirstEpoch).isCloseTo(expectedNewFirstEpoch, Offset.offset(1L))
-        assertThat(newSecondEpoch).isCloseTo(expectedNewSecondEpoch, Offset.offset(1L))
+        val participantAddress = genesis.node.getColdAddress()
+
+        logSection("Aligning to a post-CLAIM_REWARDS observation point")
+        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
+        genesis.node.waitForNextBlock(2)
+
+        logSection("Snapshotting balance and vesting schedule")
+        val initialBalance = genesis.getBalance(participantAddress)
+        val initialSchedule = genesis.node.queryVestingSchedule(participantAddress)
+        val initialFirstEpoch = initialSchedule.vestingSchedule?.epochAmounts?.getOrNull(0)
+            ?.coins?.sumOf { it.amount } ?: 0L
+        val initialSecondEpoch = initialSchedule.vestingSchedule?.epochAmounts?.getOrNull(1)
+            ?.coins?.sumOf { it.amount } ?: 0L
+        val startEpoch = getRewardCalculationEpochIndex(genesis)
+        logHighlight(
+            "Initial state: balance=$initialBalance, vesting first=$initialFirstEpoch, " +
+                "second=$initialSecondEpoch, rewardEpoch=$startEpoch"
+        )
 
-        logSection("=== BITCOIN REWARD SYSTEM VESTING TEST COMPLETED ===")
-        logSection("✅ Balance changed correctly: paid costs + unlocked first epoch of initial vesting")
-        logSection("✅ Vesting structure aggregated correctly:")
-        logSection("    • First epoch = initial second epoch + new first epoch")
-        logSection("    • Second epoch = new second epoch")
-        logSection("✅ Initial first epoch was properly unlocked during claim rewards cycle")
-        logSection("✅ Bitcoin system compatibility: epoch rewards work correctly with vesting aggregation")
-        logSection("✅ Fixed reward distribution: Bitcoin-style epoch rewards properly vest over 2 epochs")
+        logSection("Waiting one full reward cycle with zero inference traffic")
+        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
+        genesis.node.waitForNextBlock(2)
+
+        val endEpoch = getRewardCalculationEpochIndex(genesis)
+        // The unlock/aggregation arithmetic below assumes exactly one CLAIM_REWARDS
+        // cycle elapsed between the two snapshots.
+        assertThat(endEpoch)
+            .describedAs("expected exactly one reward cycle between snapshots")
+            .isEqualTo(startEpoch + 1)
+
+        logSection("Computing expected PoC epoch reward (no inferences)")
+        val expectedSchedules = calculateVestingScheduleChanges(
+            inferences = emptyList(),
+            inferenceParams = params,
+            participants = genesis.api.getParticipants(),
+            startLastRewardedEpoch = startEpoch,
+            endLastRewardedEpoch = endEpoch,
+            vestingPeriod = 2
+        )
+        val expected = expectedSchedules[participantAddress] ?: LongArray(3) { 0L }
+        val expectedNewFirst = expected[1]
+        val expectedNewSecond = expected[2]
+        val expectedNewReward = expectedNewFirst + expectedNewSecond
+        logHighlight("Expected new epoch reward: $expectedNewReward (first=$expectedNewFirst, second=$expectedNewSecond)")
+
+        logSection("Verifying rewards flowed with zero traffic and went to vesting")
+        assertThat(expectedNewReward)
+            .describedAs("PoC epoch rewards should accrue without any inference traffic")
+            .isGreaterThan(0)
+
+        logSection("Verifying balance grew by exactly the scheduled first-epoch unlock")
+        val balanceAfterCycle = genesis.getBalance(participantAddress)
+        assertThat(balanceAfterCycle - initialBalance)
+            .describedAs("liquid balance change must equal the previously scheduled first-epoch unlock")
+            .isCloseTo(initialFirstEpoch, Offset.offset(3L))
+
+        logSection("Verifying vesting schedule aggregation")
+        val scheduleAfterCycle = genesis.node.queryVestingSchedule(participantAddress)
+        val epochAmounts = scheduleAfterCycle.vestingSchedule?.epochAmounts
+        assertThat(epochAmounts)
+            .describedAs("new rewards must create/extend a vesting schedule")
+            .isNotEmpty()
+        assertThat(epochAmounts).hasSize(2)
+
+        val newFirstEpoch = epochAmounts?.getOrNull(0)?.coins?.sumOf { it.amount } ?: 0L
+        val newSecondEpoch = epochAmounts?.getOrNull(1)?.coins?.sumOf { it.amount } ?: 0L
+        logHighlight("Schedule after cycle: first=$newFirstEpoch, second=$newSecondEpoch")
+
+        // First epoch slot = what was previously second + first half of the new reward.
+        // Second epoch slot = second half of the new reward. Size stays 2 (aggregation,
+        // not extension).
+        assertThat(newFirstEpoch)
+            .describedAs("first epoch = old second epoch + new reward's first half")
+            .isCloseTo(initialSecondEpoch + expectedNewFirst, Offset.offset(3L))
+        assertThat(newSecondEpoch)
+            .describedAs("second epoch = new reward's second half")
+            .isCloseTo(expectedNewSecond, Offset.offset(3L))
+
+        logSection("=== POC-DRIVEN VESTING TEST COMPLETED ===")
+        logHighlight("✅ Epoch rewards accrued with zero inference traffic")
+        logHighlight("✅ Rewards vested instead of paying out immediately")
+        logHighlight("✅ Exactly the scheduled first-epoch amount unlocked to liquid balance")
+        logHighlight("✅ New rewards aggregated into the 2-epoch schedule without extending it")
     }
-    
-} 
+}
diff --git a/testermint/src/test/kotlin/StreamingInferenceTests.kt b/testermint/src/test/kotlin/StreamingInferenceTests.kt
index 0cbadb564f..0e4cf5c0b4 100644
--- a/testermint/src/test/kotlin/StreamingInferenceTests.kt
+++ b/testermint/src/test/kotlin/StreamingInferenceTests.kt
@@ -27,8 +27,9 @@ import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import kotlin.random.Random
 
+// Classic inference flow was removed (PR #1386); these tests exercise the deprecated endpoints.
+@Tag("exclude")
 @Timeout(value = 20, unit = TimeUnit.MINUTES)
-
 class StreamingInferenceTests : TestermintTest() {
     @Test
     @Tag("sanity")
diff --git a/testermint/src/test/kotlin/TransactionFeeTests.kt b/testermint/src/test/kotlin/TransactionFeeTests.kt
index 98c3fac0d9..1d01e33793 100644
--- a/testermint/src/test/kotlin/TransactionFeeTests.kt
+++ b/testermint/src/test/kotlin/TransactionFeeTests.kt
@@ -12,10 +12,9 @@ import org.junit.jupiter.api.TestMethodOrder
  *
  * Tests the full flow:
  * 1. Verify no fee enforcement at genesis (FeeParams nil)
- * 2. Verify inference works before fees
- * 3. Enable fee enforcement via governance proposal (simulates v0.2.12 upgrade)
- * 4. Verify fee-required messages are rejected without sufficient fees (via CLI)
- * 5. Verify fee-required messages succeed with sufficient fees (via CLI)
+ * 2. Enable fee enforcement via governance proposal (simulates v0.2.12 upgrade)
+ * 3. Verify fee-required messages are rejected without sufficient fees (via CLI)
+ * 4. Verify fee-required messages succeed with sufficient fees (via CLI)
  *
  * Note: Post-enablement inference/PoC tests are not included because the DAPI
  * containers cannot be reconfigured with gas prices mid-test. Fee-exempt bypass
@@ -54,19 +53,9 @@ class TransactionFeeTests : TestermintTest() {
         logHighlight("FeeParams correctly nil at genesis")
     }
 
-    @Test
-    @Order(2)
-    fun `inference succeeds before fee enablement`() {
-        logHighlight("Testing that inference works before fee enforcement is enabled")
-
-        // Past set_new_validators so GetRandomExecutor uses all participants, not the
-        // preserved-node PoC filter (which is empty right at that boundary).
-        genesis.waitForStage(EpochStage.SET_NEW_VALIDATORS, offset = 2)
-        val response = genesis.makeInferenceRequest(inferenceRequest)
-
-        assertThat(response.choices).isNotEmpty
-        logHighlight("Inference succeeded pre-fees: model=${response.model}")
-    }
+    // Pre-fee classic inference smoke test removed with the dapi deprecation:
+    // classic /v1/chat/completions now returns 410. Fee-exempt bypass for
+    // inference/PoC messages remains covered by unit tests in ante_fee_test.go.
 
     // ========== ENABLE FEES ==========
 
diff --git a/testermint/src/test/kotlin/UpgradeRehearsalTests.kt b/testermint/src/test/kotlin/UpgradeRehearsalTests.kt
new file mode 100644
index 0000000000..e9089a9538
--- /dev/null
+++ b/testermint/src/test/kotlin/UpgradeRehearsalTests.kt
@@ -0,0 +1,630 @@
+import com.github.kittinunf.fuel.core.FuelError
+import com.google.gson.JsonObject
+import com.google.gson.JsonParser
+import com.productscience.*
+import com.productscience.data.ActiveParticipant
+import com.productscience.data.OpenAIResponse
+import com.productscience.data.UpdateParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Timeout
+import org.tinylog.Logger
+import java.io.File
+import java.security.MessageDigest
+import java.time.Duration
+import java.time.Instant
+import java.util.concurrent.TimeUnit
+import kotlin.test.assertNotNull
+
+@Tag("exclude")
+class UpgradeRehearsalTests : TestermintTest() {
+    private val defaultDevshardMaxNonce = 20_000L
+
+    @Test
+    @Tag("upgrade-rehearsal")
+    @Timeout(value = 90, unit = TimeUnit.MINUTES)
+    fun `complete upgrade rehearsal`() {
+        val targetUpgrade = requiredEnv("UPGRADE_REHEARSAL_TARGET")
+        val manifest = loadPrepManifest()
+        assertPreparedManifest(manifest)
+
+        val cluster = attachPreparedCluster()
+        val genesis = cluster.genesis
+        configureInferenceMocks(cluster, targetUpgrade, "upgrade rehearsal post-upgrade")
+
+        waitForClusterOperational(cluster, genesis)
+
+        val upgradeLeadBlocks = System.getenv("UPGRADE_REHEARSAL_LEAD_BLOCKS")?.toLongOrNull() ?: 80L
+        val upgradeHeight = scheduleStageSafeUpgradeHeight(genesis, upgradeLeadBlocks)
+        val binaryPath = rehearsalBinaryPath("v2/inferenced/inferenced-amd64.zip")
+        val apiBinaryPath = rehearsalBinaryPath("v2/dapi/decentralized-api-amd64.zip")
+
+        logSection("Submitting upgrade rehearsal proposal for $targetUpgrade at block $upgradeHeight")
+        val response = genesis.submitUpgradeProposal(
+            title = targetUpgrade,
+            description = "Testermint upgrade rehearsal to $targetUpgrade",
+            binaryPath = binaryPath,
+            apiBinaryPath = apiBinaryPath,
+            height = upgradeHeight,
+            nodeVersion = targetUpgrade,
+        )
+        require(response.code == 0) { "Upgrade proposal failed: ${response.rawLog}" }
+        val proposalId = assertNotNull(response.getProposalId(), "could not find upgrade proposal id")
+
+        val govParams = genesis.node.getGovParams().params
+        val deposit = genesis.makeGovernanceDeposit(proposalId, govParams.minDeposit.first().amount)
+        require(deposit.code == 0) { "Upgrade proposal deposit failed: ${deposit.rawLog}" }
+
+        logSection("Voting on upgrade rehearsal proposal")
+        cluster.allPairs.forEach { pair ->
+            val vote = pair.voteOnProposal(proposalId, "yes")
+            require(vote.code == 0) { "Vote failed for ${pair.name}: ${vote.rawLog}" }
+        }
+
+        logSection("Waiting for governance voting period")
+        Thread.sleep(govParams.votingPeriod.plus(Duration.ofSeconds(5)).toMillis())
+
+        logSection("Waiting for upgrade height $upgradeHeight")
+        genesis.node.waitForMinimumBlock(upgradeHeight - 2, "upgrade rehearsal height")
+
+        logSection("Waiting for cosmovisor to apply upgrade")
+        Thread.sleep(Duration.ofMinutes(5).toMillis())
+        genesis.node.waitForNextBlock(1)
+
+        logSection("Verifying upgrade marker and cluster health")
+        verifyUpgradeWithLocalApiRecovery(cluster, genesis)
+        waitForLastUpgradeHeight(cluster, genesis, upgradeHeight, maxBlocks = 60)
+        assertLastUpgradeHeight(cluster, upgradeHeight)
+        waitForClusterOperational(cluster, genesis)
+
+        logSection("Verifying post-upgrade epoch transition and PoC miner power")
+        val postUpgradePocResult = assertPostUpgradePocSucceeded(cluster, genesis, manifest)
+
+        logSection("Running post-upgrade normal inference")
+        configureInferenceMocks(cluster, targetUpgrade, "upgrade rehearsal post-upgrade normal inference")
+        waitForClusterOperational(cluster, genesis)
+        genesis.waitForNextInferenceWindow()
+        val postInference = makeInferenceRequestWhenRoutable(genesis, inferenceRequest)
+        assertThat(postInference.choices.first().message.content).isNotEmpty()
+
+        logSection("Running post-upgrade devshard settlement")
+        ensureDevshardRequestsEnabled(cluster, genesis)
+        configureDevshardMocks(cluster, targetUpgrade, "upgrade rehearsal post-upgrade devshard")
+        val user = genesis.createFundedDevshardUser("upgrade-rehearsal-post-devshard-user")
+        genesis.waitForNextInferenceWindow()
+        val escrowAmount = 7_000_000_000L
+        val escrowId = genesis.createDevshardEscrowForUser(escrowAmount, user.keyName, modelId = defaultModel)
+        val handle = genesis.startDevshardProxy(
+            escrowId = escrowId,
+            keyName = user.keyName,
+            routePrefix = devshardVersionedRoutePrefix(),
+        )
+        try {
+            genesis.waitForDevshardProxyWarmup()
+            makeInferenceRequestWhenRoutable(genesis, inferenceRequest)
+            repeat(5) { index ->
+                val responseText = genesis.sendChatCompletion(
+                    handle.proxyUrl,
+                    defaultModel,
+                    "upgrade rehearsal post-upgrade prompt $index",
+                )
+                assertThat(responseText).isNotEmpty()
+            }
+            genesis.assertDevshardSettlement(
+                handle,
+                escrowId,
+                user,
+                escrowAmount,
+                requireCompletedValidations = false,
+            )
+        } finally {
+            genesis.stopDevshardProxy(escrowId)
+        }
+
+        writeCompletionManifest(targetUpgrade, upgradeHeight, postInference.id, escrowId, postUpgradePocResult)
+    }
+
+    private fun scheduleStageSafeUpgradeHeight(
+        genesis: LocalInferencePair,
+        minimumLeadBlocks: Long,
+    ): Long {
+        require(minimumLeadBlocks >= 0) { "UPGRADE_REHEARSAL_LEAD_BLOCKS must be non-negative" }
+
+        val epochData = genesis.getEpochData()
+        val earliestUpgradeBlock = epochData.blockHeight + minimumLeadBlocks
+        val scheduledUpgrade = requireNotNull(
+            epochData.findStageSafeInferenceBlock(
+                earliestBlock = earliestUpgradeBlock,
+                minimumSlackBeforeNextPoc = INFERENCE_STAGE_SLACK_BLOCKS,
+            )
+        ) {
+            "Failed to find a stage-safe upgrade block for height $earliestUpgradeBlock " +
+                "with slack $INFERENCE_STAGE_SLACK_BLOCKS from phase ${epochData.phase}"
+        }
+
+        Logger.info(
+            "Selected stage-safe upgrade height {} from block {} during phase {} " +
+                "(inference window {}..{}, earliest acceptable block {})",
+            scheduledUpgrade.block,
+            epochData.blockHeight,
+            epochData.phase,
+            scheduledUpgrade.inferenceWindowStart,
+            scheduledUpgrade.nextPocStart - 1,
+            earliestUpgradeBlock,
+        )
+        return scheduledUpgrade.block
+    }
+
+    private data class PocPowerSnapshot(
+        val epochId: Long,
+        val weights: Map<String, Long>,
+    )
+
+    private data class PostUpgradePocResult(
+        val beforeEpochId: Long,
+        val afterEpochId: Long,
+        val newEpochId: Long,
+        val pocStartBlock: Long,
+        val setNewValidatorsBlock: Long,
+        val claimRewardsBlock: Long,
+        val beforeWeights: Map<String, Long>,
+        val afterWeights: Map<String, Long>,
+        val newEpochWeights: Map<String, Long>,
+    )
+
+    private fun assertPostUpgradePocSucceeded(
+        cluster: LocalCluster,
+        genesis: LocalInferencePair,
+        manifest: JsonObject,
+    ): PostUpgradePocResult {
+        val participantIds = manifest.getAsJsonArray("participantIds").map { it.asString }
+        assertThat(participantIds).describedAs("prepared participant ids").isNotEmpty()
+
+        val before = prepPocPowerSnapshot(manifest, participantIds)
+        val pocStart = genesis.waitForStage(EpochStage.START_OF_POC, offset = 1)
+        val setNewValidators = genesis.waitForStage(EpochStage.SET_NEW_VALIDATORS, offset = 2)
+        waitForClusterOperational(cluster, genesis)
+        val after = captureActivePocPowerSnapshot(genesis, participantIds, "after post-upgrade PoC")
+
+        assertThat(after.epochId)
+            .describedAs("post-upgrade PoC should advance the active participant epoch")
+            .isGreaterThan(before.epochId)
+        assertMinerPowerStable(before, after)
+
+        val claimRewards = genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
+        waitForClusterOperational(cluster, genesis)
+        val newEpoch = captureActivePocPowerSnapshot(genesis, participantIds, "after post-upgrade new epoch")
+        assertThat(newEpoch.epochId)
+            .describedAs("post-upgrade active participant epoch should remain advanced after CLAIM_REWARDS")
+            .isGreaterThanOrEqualTo(after.epochId)
+        assertMinerPowerStable(before, newEpoch)
+
+        return PostUpgradePocResult(
+            beforeEpochId = before.epochId,
+            afterEpochId = after.epochId,
+            newEpochId = newEpoch.epochId,
+            pocStartBlock = pocStart.stageBlock,
+            setNewValidatorsBlock = setNewValidators.stageBlock,
+            claimRewardsBlock = claimRewards.stageBlock,
+            beforeWeights = before.weights,
+            afterWeights = after.weights,
+            newEpochWeights = newEpoch.weights,
+        )
+    }
+
+    private fun prepPocPowerSnapshot(manifest: JsonObject, participantIds: List<String>): PocPowerSnapshot {
+        val weightsObject = manifest.getAsJsonObject("participantWeights")
+        val weights = participantIds.associateWith { participantId ->
+            require(weightsObject.has(participantId)) {
+                "Prepared manifest is missing PoC weight for participant $participantId"
+            }
+            weightsObject.get(participantId).asLong
+        }
+        weights.forEach { (participantId, weight) ->
+            assertThat(weight)
+                .describedAs("prepared participant $participantId PoC power")
+                .isPositive()
+        }
+
+        Logger.info(
+            "prepared pre-upgrade PoC power snapshot: epoch={}, weights={}",
+            manifest.get("finalEpoch").asLong,
+            weights,
+        )
+
+        return PocPowerSnapshot(
+            epochId = manifest.get("finalEpoch").asLong,
+            weights = weights,
+        )
+    }
+
+    private fun captureActivePocPowerSnapshot(
+        genesis: LocalInferencePair,
+        participantIds: List<String>,
+        label: String,
+    ): PocPowerSnapshot {
+        val activeResponse = genesis.api.getActiveParticipants()
+        val activeById = activeResponse.activeParticipants.participants.associateBy { it.index }
+        val missingParticipants = participantIds.filterNot(activeById::containsKey)
+        assertThat(missingParticipants)
+            .describedAs("$label missing prepared miners from active participants")
+            .isEmpty()
+
+        val excludedIds = activeResponse.excludedParticipants.map { it.address }.toSet()
+        val excludedPreparedParticipants = participantIds.filter { it in excludedIds }
+        assertThat(excludedPreparedParticipants)
+            .describedAs("$label excluded prepared miners")
+            .isEmpty()
+
+        val weights = participantIds.associateWith { participantId ->
+            val participant = activeById.getValue(participantId)
+            assertParticipantHasPocPower(participant, label)
+            participant.weight
+        }
+
+        Logger.info(
+            "{} PoC power snapshot: epoch={}, weights={}",
+            label,
+            activeResponse.activeParticipants.epochId,
+            weights,
+        )
+
+        return PocPowerSnapshot(
+            epochId = activeResponse.activeParticipants.epochId,
+            weights = weights,
+        )
+    }
+
+    private fun assertParticipantHasPocPower(participant: ActiveParticipant, label: String) {
+        assertThat(participant.weight)
+            .describedAs("$label participant ${participant.index} aggregate PoC power")
+            .isPositive()
+
+        val nodeWeights = participant.mlNodes.flatMap { group -> group.mlNodes }.map { node -> node.pocWeight }
+        assertThat(nodeWeights)
+            .describedAs("$label participant ${participant.index} ML node PoC weights")
+            .isNotEmpty()
+        assertThat(nodeWeights.any { it > 0L })
+            .describedAs("$label participant ${participant.index} should have at least one positive ML node PoC weight")
+            .isTrue()
+    }
+
+    private fun assertMinerPowerStable(before: PocPowerSnapshot, after: PocPowerSnapshot) {
+        val maxChangePercent = System.getenv("UPGRADE_REHEARSAL_MAX_POWER_CHANGE_PERCENT")
+            ?.toLongOrNull()
+            ?: 50L
+        require(maxChangePercent >= 0) {
+            "UPGRADE_REHEARSAL_MAX_POWER_CHANGE_PERCENT must be non-negative, got $maxChangePercent"
+        }
+
+        before.weights.forEach { (participantId, beforeWeight) ->
+            val afterWeight = after.weights[participantId]
+                ?: error("Missing post-upgrade PoC weight for prepared miner $participantId")
+            val delta = if (afterWeight >= beforeWeight) afterWeight - beforeWeight else beforeWeight - afterWeight
+            assertThat(delta * 100)
+                .describedAs(
+                    "post-upgrade PoC power change for $participantId " +
+                        "(before=$beforeWeight, after=$afterWeight, maxChangePercent=$maxChangePercent)",
+                )
+                .isLessThanOrEqualTo(beforeWeight * maxChangePercent)
+        }
+
+        val beforeTotal = before.weights.values.sum()
+        val afterTotal = after.weights.values.sum()
+        val totalDelta = if (afterTotal >= beforeTotal) afterTotal - beforeTotal else beforeTotal - afterTotal
+        assertThat(totalDelta * 100)
+            .describedAs(
+                "post-upgrade total miner power change " +
+                    "(before=$beforeTotal, after=$afterTotal, maxChangePercent=$maxChangePercent)",
+            )
+            .isLessThanOrEqualTo(beforeTotal * maxChangePercent)
+    }
+
+    private fun ensureDevshardRequestsEnabled(cluster: LocalCluster, genesis: LocalInferencePair) {
+        val params = genesis.getParams()
+        val current = params.devshardEscrowParams?.devshardRequestsEnabled
+        if (current == true) {
+            logSection("Devshard request handling is already enabled")
+            return
+        }
+
+        logSection("Enabling devshard request handling after upgrade through governance params")
+        val devshardParams = requireNotNull(params.devshardEscrowParams) {
+            "Cannot enable devshard request handling because devshard escrow params are missing"
+        }
+        genesis.runProposal(
+            cluster,
+            UpdateParams(
+                params = params.copy(
+                    devshardEscrowParams = devshardParams.copy(
+                        devshardRequestsEnabled = true,
+                        maxNonce = devshardParams.maxNonce.takeIf { it > 0 } ?: defaultDevshardMaxNonce,
+                    ),
+                ),
+            ),
+        )
+
+        val updated = genesis.getParams().devshardEscrowParams?.devshardRequestsEnabled
+        assertThat(updated).isEqualTo(true)
+        waitForClusterOperational(cluster, genesis)
+    }
+
+    private fun attachPreparedCluster(): LocalCluster {
+        val cluster = getLocalCluster(inferenceConfig)
+            ?: error("No prepared Testermint cluster found. The rehearsal completion phase must not rebuild the cluster.")
+        require(cluster.joinPairs.size >= 2) {
+            "Expected at least two join pairs in prepared cluster, found ${cluster.joinPairs.size}"
+        }
+        return cluster
+    }
+
+    private fun assertPreparedManifest(manifest: JsonObject) {
+        assertThat(manifest.get("phase").asString).isEqualTo("prepared")
+        assertThat(manifest.get("normalInferenceId").asString).isNotBlank()
+        assertThat(manifest.get("devshardEscrowId").asLong).isGreaterThan(0)
+        assertThat(manifest.get("devshardRequests").asInt).isGreaterThan(0)
+        assertThat(manifest.getAsJsonArray("participantIds")).isNotEmpty()
+        assertThat(manifest.getAsJsonObject("participantWeights").entrySet()).isNotEmpty()
+        assertThat(manifest.get("finalHeight").asLong).isGreaterThan(manifest.get("startingHeight").asLong)
+    }
+
+    private fun loadPrepManifest(): JsonObject {
+        val file = manifestFile()
+        require(file.exists()) { "Upgrade rehearsal prep manifest not found: ${file.absolutePath}" }
+        return JsonParser.parseString(file.readText()).asJsonObject
+    }
+
+    private fun manifestFile(): File =
+        System.getenv("UPGRADE_REHEARSAL_MANIFEST")
+            ?.takeIf { it.isNotBlank() }
+            ?.let(::File)
+            ?: File("../prod-local/upgrade-rehearsal/manifest.json")
+
+    private fun writeCompletionManifest(
+        targetUpgrade: String,
+        upgradeHeight: Long,
+        postInferenceId: String,
+        postDevshardEscrowId: Long,
+        postUpgradePocResult: PostUpgradePocResult,
+    ) {
+        val output = System.getenv("UPGRADE_REHEARSAL_COMPLETE_MANIFEST")
+            ?.takeIf { it.isNotBlank() }
+            ?.let(::File)
+            ?: File(manifestFile().parentFile, "completion-manifest.json")
+        output.parentFile.mkdirs()
+        val manifest = mapOf(
+            "schema" to 1,
+            "phase" to "completed",
+            "completedAt" to Instant.now().toString(),
+            "targetUpgrade" to targetUpgrade,
+            "upgradeHeight" to upgradeHeight,
+            "postUpgradeInferenceId" to postInferenceId,
+            "postUpgradeDevshardEscrowId" to postDevshardEscrowId,
+            "postUpgradePocBeforeEpoch" to postUpgradePocResult.beforeEpochId,
+            "postUpgradePocAfterEpoch" to postUpgradePocResult.afterEpochId,
+            "postUpgradeNewEpoch" to postUpgradePocResult.newEpochId,
+            "postUpgradePocStartBlock" to postUpgradePocResult.pocStartBlock,
+            "postUpgradeSetNewValidatorsBlock" to postUpgradePocResult.setNewValidatorsBlock,
+            "postUpgradeClaimRewardsBlock" to postUpgradePocResult.claimRewardsBlock,
+            "postUpgradePocBeforeWeights" to postUpgradePocResult.beforeWeights,
+            "postUpgradePocAfterWeights" to postUpgradePocResult.afterWeights,
+            "postUpgradeNewEpochWeights" to postUpgradePocResult.newEpochWeights,
+        )
+        output.writeText(cosmosJson.toJson(manifest))
+        Logger.info("Wrote upgrade rehearsal completion manifest to {}", output.absolutePath)
+    }
+
+    private fun configureInferenceMocks(cluster: LocalCluster, targetUpgrade: String, content: String) {
+        val response = defaultInferenceResponseObject.withResponse(content)
+        cluster.allPairs.forEach { pair ->
+            listOf("", "v3.0.8", targetUpgrade).distinct().forEach { segment ->
+                pair.mock?.setInferenceResponse(response, segment = segment)
+            }
+        }
+    }
+
+    private fun configureDevshardMocks(cluster: LocalCluster, targetUpgrade: String, content: String) {
+        val response = devshardChatResponse(content)
+        cluster.allPairs.forEach { pair ->
+            listOf("", "v3.0.8", targetUpgrade).distinct().forEach { segment ->
+                pair.mock?.setInferenceResponse(response = response, segment = segment)
+            }
+        }
+    }
+
+    private fun devshardChatResponse(content: String): String =
+        """{"id":"test","object":"chat.completion","created":0,"model":"$defaultModel","choices":[{"index":0,"message":{"role":"assistant","content":"$content"},"finish_reason":"stop"}],"usage":{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15}}"""
+
+    private fun assertLastUpgradeHeight(pair: LocalInferencePair, expectedHeight: Long, expectedFound: Boolean = true) {
+        val response = pair.node.getLastUpgradeHeight()
+        assertThat(response.found).isEqualTo(expectedFound)
+        assertThat(response.lastUpgradeHeight).isEqualTo(expectedHeight)
+    }
+
+    private fun assertLastUpgradeHeight(cluster: LocalCluster, expectedHeight: Long, expectedFound: Boolean = true) {
+        cluster.allPairs.forEach { pair ->
+            assertLastUpgradeHeight(pair, expectedHeight, expectedFound)
+        }
+    }
+
+    private fun assertLastUpgradeHeightUnset(cluster: LocalCluster) {
+        assertLastUpgradeHeight(cluster, 0, expectedFound = false)
+    }
+
+    private fun verifyPairHealthy(pair: LocalInferencePair) {
+        pair.api.getParticipants()
+        pair.api.getNodes()
+        pair.node.getColdAddress()
+    }
+
+    private fun makeInferenceRequestWhenRoutable(
+        pair: LocalInferencePair,
+        request: String,
+        maxBlocks: Int = 25,
+    ): OpenAIResponse {
+        val startBlock = pair.getCurrentBlockHeight()
+        val deadlineBlock = startBlock + maxBlocks
+        var lastFailure: Throwable? = null
+
+        while (pair.getCurrentBlockHeight() <= deadlineBlock) {
+            try {
+                return pair.makeInferenceRequest(request)
+            } catch (e: Exception) {
+                if (!isTransientInferenceRoutingFailure(e)) {
+                    throw e
+                }
+                lastFailure = e
+                Logger.warn(e) {
+                    "Inference routing is not ready at block ${pair.getCurrentBlockHeight()}; waiting for next block"
+                }
+                pair.node.waitForNextBlock(1)
+            }
+        }
+
+        throw IllegalStateException("Inference routing did not become ready by block $deadlineBlock", lastFailure)
+    }
+
+    private fun isTransientInferenceRoutingFailure(t: Throwable): Boolean {
+        val transientMessages = listOf(
+            "503",
+            "Service Unavailable",
+            "Active participants found, but length is 0",
+            "After filtering participants the length is 0",
+            "epoch group data not found",
+        )
+        val causeMatches = generateSequence(t) { it.cause }.any { cause ->
+            transientMessages.any { message -> cause.message?.contains(message) == true }
+        }
+        val fuelMatches = generateSequence(t) { it.cause }.filterIsInstance<FuelError>().any { fuel ->
+            fuel.response.statusCode == 503 ||
+                transientMessages.any { message ->
+                    fuel.response.data.toString(Charsets.UTF_8).contains(message)
+                }
+        }
+
+        return causeMatches || fuelMatches
+    }
+
+    private fun pairIsOperational(pair: LocalInferencePair): Boolean =
+        runCatching {
+            verifyPairHealthy(pair)
+            pair.api.getNodes().isNotEmpty() &&
+                pair.api.getNodes().all { node ->
+                    node.state.currentStatus != "UNKNOWN" && node.state.intendedStatus != "UNKNOWN"
+                }
+        }.getOrDefault(false)
+
+    private fun waitForClusterOperational(cluster: LocalCluster, genesis: LocalInferencePair, maxBlocks: Int = 30) {
+        val startBlock = genesis.getCurrentBlockHeight()
+        val targetBlock = startBlock + maxBlocks
+
+        while (genesis.getCurrentBlockHeight() < targetBlock) {
+            if (cluster.allPairs.all(::pairIsOperational)) {
+                return
+            }
+            genesis.node.waitForNextBlock(1)
+        }
+
+        error("Cluster did not become operational by block $targetBlock")
+    }
+
+    private fun waitForLastUpgradeHeight(
+        cluster: LocalCluster,
+        genesis: LocalInferencePair,
+        expectedHeight: Long,
+        maxBlocks: Int,
+    ) {
+        val startBlock = genesis.getCurrentBlockHeight()
+        val targetBlock = startBlock + maxBlocks
+
+        while (genesis.getCurrentBlockHeight() < targetBlock) {
+            val allUpdated = cluster.allPairs.all { pair ->
+                runCatching {
+                    val response = pair.node.getLastUpgradeHeight()
+                    response.found && response.lastUpgradeHeight == expectedHeight
+                }.getOrDefault(false)
+            }
+            if (allUpdated) {
+                return
+            }
+            genesis.node.waitForNextBlock(1)
+        }
+
+        error("LastUpgradeHeight did not become $expectedHeight by block $targetBlock")
+    }
+
+    private fun isBadGatewayFailure(t: Throwable): Boolean =
+        generateSequence(t) { it.cause }.any { cause ->
+            cause.message?.contains("502") == true || cause.message?.contains("Bad Gateway") == true
+        }
+
+    private fun verifyUpgradeWithLocalApiRecovery(cluster: LocalCluster, genesis: LocalInferencePair) {
+        fun pairHealthFailure(pair: LocalInferencePair): Throwable? =
+            runCatching { verifyPairHealthy(pair) }.exceptionOrNull()
+
+        fun failedPairs(): List<LocalInferencePair> =
+            cluster.allPairs.filter { pair -> pairHealthFailure(pair) != null }
+
+        val initialFailures = failedPairs()
+        if (initialFailures.isEmpty()) {
+            return
+        }
+
+        val firstFailure = pairHealthFailure(initialFailures.first())
+        if (firstFailure == null || !isBadGatewayFailure(firstFailure)) {
+            throw firstFailure ?: IllegalStateException("Upgrade verification failed for unknown reason")
+        }
+
+        Logger.warn(
+            "Post-upgrade API verification failed with 502; restarting local API containers for {}",
+            initialFailures.joinToString(", ") { it.name },
+        )
+        initialFailures.forEach { it.restartApiContainer() }
+
+        val startBlock = genesis.getCurrentBlockHeight()
+        val targetBlock = startBlock + 40
+        while (genesis.getCurrentBlockHeight() < targetBlock) {
+            val remainingFailures = failedPairs()
+            if (remainingFailures.isEmpty()) {
+                return
+            }
+            Logger.info(
+                "Waiting for restarted API containers to recover: {}",
+                remainingFailures.joinToString(", ") { it.name },
+            )
+            genesis.node.waitForNextBlock(2)
+        }
+
+        error("API containers did not recover from post-upgrade 502 by block $targetBlock")
+    }
+
+    private fun rehearsalBinaryPath(path: String): String {
+        val localPath = File("../public-html/$path")
+        val sha = sha256(localPath)
+        val baseUrl = System.getenv("UPGRADE_BINARY_BASE_URL")
+            ?.takeIf { it.isNotBlank() }
+            ?: "http://genesis-mock-server:8080/files"
+        return "${baseUrl.trimEnd('/')}/$path?checksum=sha256:$sha"
+    }
+
+    private fun sha256(file: File): String {
+        require(file.exists()) { "Upgrade binary file does not exist: ${file.absolutePath}" }
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buffer = ByteArray(8192)
+            while (true) {
+                val bytesRead = input.read(buffer)
+                if (bytesRead == -1) {
+                    break
+                }
+                digest.update(buffer, 0, bytesRead)
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+
+    private fun requiredEnv(name: String): String =
+        System.getenv(name)?.takeIf { it.isNotBlank() }
+            ?: error("Required environment variable $name is not set")
+}
diff --git a/testermint/src/test/kotlin/UpgradeTests.kt b/testermint/src/test/kotlin/UpgradeTests.kt
index 2bb685c01a..51e9272b47 100644
--- a/testermint/src/test/kotlin/UpgradeTests.kt
+++ b/testermint/src/test/kotlin/UpgradeTests.kt
@@ -1,11 +1,15 @@
 import com.productscience.*
 import com.productscience.data.CreatePartialUpgrade
+import com.productscience.data.OpenAIResponse
+import com.github.dockerjava.api.exception.NotFoundException
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
 import org.tinylog.Logger
 import java.io.File
+import java.net.URL
+import java.net.URLEncoder
 import java.net.SocketException
 import java.security.MessageDigest
 import java.time.Duration
@@ -13,6 +17,28 @@ import java.util.concurrent.TimeUnit
 import kotlin.test.assertNotNull
 
 class UpgradeTests : TestermintTest() {
+    private fun assertLastUpgradeHeight(pair: LocalInferencePair, expectedHeight: Long, expectedFound: Boolean = true) {
+        val response = pair.node.getLastUpgradeHeight()
+        assertThat(response.found).isEqualTo(expectedFound)
+        assertThat(response.lastUpgradeHeight).isEqualTo(expectedHeight)
+    }
+
+    private fun assertLastUpgradeHeight(cluster: LocalCluster, expectedHeight: Long, expectedFound: Boolean = true) {
+        cluster.allPairs.forEach { pair ->
+            assertLastUpgradeHeight(pair, expectedHeight, expectedFound)
+        }
+    }
+
+    private fun assertLastUpgradeHeightUnset(pair: LocalInferencePair) {
+        assertLastUpgradeHeight(pair, 0, expectedFound = false)
+    }
+
+    private fun assertLastUpgradeHeightUnset(cluster: LocalCluster) {
+        assertLastUpgradeHeight(cluster, 0, expectedFound = false)
+    }
+
+    private val upgradeArchitectures = listOf("amd64", "arm64")
+
     private fun initUpgradeCluster(config: ApplicationConfig = inferenceConfig): Pair<LocalCluster, LocalInferencePair> {
         var lastFailure: Throwable? = null
         repeat(3) { attempt ->
@@ -21,7 +47,9 @@ class UpgradeTests : TestermintTest() {
             } catch (t: Throwable) {
                 val shouldRetry =
                     t.message?.contains("Could not find node container for keyName=genesis") == true ||
-                        generateSequence(t) { it.cause }.any { it is SocketException }
+                        t.message?.contains("Failed to get validator info within 90 seconds") == true ||
+                        t.message?.contains("without condition passing") == true ||
+                        generateSequence(t) { it.cause }.any { it is SocketException || it is NotFoundException }
                 if (!shouldRetry || attempt == 2) {
                     throw t
                 }
@@ -33,6 +61,105 @@ class UpgradeTests : TestermintTest() {
         throw lastFailure ?: IllegalStateException("Upgrade cluster bootstrap failed")
     }
 
+    private fun verifyPairHealthy(pair: LocalInferencePair) {
+        pair.api.getParticipants()
+        pair.api.getNodes()
+        pair.node.getColdAddress()
+    }
+
+    private fun pairIsOperational(pair: LocalInferencePair): Boolean =
+        runCatching {
+            verifyPairHealthy(pair)
+            pair.api.getNodes().isNotEmpty() &&
+                pair.api.getNodes().all { node ->
+                    node.state.currentStatus != "UNKNOWN" && node.state.intendedStatus != "UNKNOWN"
+                }
+        }.getOrDefault(false)
+
+    private fun waitForClusterOperational(cluster: LocalCluster, genesis: LocalInferencePair, maxBlocks: Int = 20) {
+        val startBlock = genesis.getCurrentBlockHeight()
+        val targetBlock = startBlock + maxBlocks
+
+        while (genesis.getCurrentBlockHeight() < targetBlock) {
+            if (cluster.allPairs.all(::pairIsOperational)) {
+                return
+            }
+            genesis.node.waitForNextBlock(1)
+        }
+
+        error("Cluster did not become operational by block $targetBlock")
+    }
+
+    private fun waitForInferenceReady(
+        pair: LocalInferencePair,
+        request: String,
+        maxBlocks: Int = 10,
+    ): OpenAIResponse {
+        var response: OpenAIResponse? = null
+        pair.waitForBlock(maxBlocks) {
+            response = runCatching { it.makeInferenceRequest(request) }.getOrNull()
+            response != null
+        }
+        return assertNotNull(response)
+    }
+
+    private fun waitForLastUpgradeHeight(cluster: LocalCluster, genesis: LocalInferencePair, expectedHeight: Long, maxBlocks: Int = 20) {
+        val startBlock = genesis.getCurrentBlockHeight()
+        val targetBlock = startBlock + maxBlocks
+
+        while (genesis.getCurrentBlockHeight() < targetBlock) {
+            val allUpdated = cluster.allPairs.all { pair ->
+                runCatching {
+                    val response = pair.node.getLastUpgradeHeight()
+                    response.found && response.lastUpgradeHeight == expectedHeight
+                }.getOrDefault(false)
+            }
+            if (allUpdated) {
+                return
+            }
+            genesis.node.waitForNextBlock(1)
+        }
+
+        error("LastUpgradeHeight did not become $expectedHeight by block $targetBlock")
+    }
+
+    private fun isBadGatewayFailure(t: Throwable): Boolean =
+        generateSequence(t) { it.cause }.any { cause ->
+            cause.message?.contains("502") == true || cause.message?.contains("Bad Gateway") == true
+        }
+
+    private fun verifyUpgradeWithLocalApiRecovery(cluster: LocalCluster, genesis: LocalInferencePair) {
+        fun failedPairs(): List<LocalInferencePair> =
+            cluster.allPairs.filter { pair -> runCatching { verifyPairHealthy(pair) }.isFailure }
+
+        val initialFailures = failedPairs()
+        if (initialFailures.isEmpty()) {
+            return
+        }
+
+        val firstFailure = runCatching { verifyPairHealthy(initialFailures.first()) }.exceptionOrNull()
+        if (firstFailure == null || !isBadGatewayFailure(firstFailure)) {
+            throw firstFailure ?: IllegalStateException("Upgrade verification failed for unknown reason")
+        }
+
+        Logger.warn(
+            "Post-upgrade API verification failed with 502; restarting local API containers for {}",
+            initialFailures.joinToString(", ") { it.name }
+        )
+        initialFailures.forEach { it.restartApiContainer() }
+
+        genesis.waitForBlock(20) {
+            cluster.allPairs.all { pair ->
+                runCatching {
+                    verifyPairHealthy(pair)
+                    true
+                }.getOrDefault(false)
+            }
+        }
+
+        cluster.allPairs.forEach(::verifyPairHealthy)
+    }
+
     @Test
     @Tag("unstable")
     fun `upgrade from github`() {
@@ -49,18 +176,23 @@ class UpgradeTests : TestermintTest() {
         genesis.markNeedsReboot()
         val pairs = cluster.joinPairs
         val height = genesis.getCurrentBlockHeight()
-        val amdApiPath = getGithubPath(releaseTag, "decentralized-api-amd64.zip")
-        val amdBinaryPath = getGithubPath(releaseTag, "inferenced-amd64.zip")
+        val apiBinaries = upgradeArchitectures.associate { arch ->
+            "linux/$arch" to getGithubPath(releaseTag, "decentralized-api-$arch.zip")
+        }
+        val binaries = upgradeArchitectures.associate { arch ->
+            "linux/$arch" to getGithubPath(releaseTag, "inferenced-$arch.zip")
+        }
         val upgradeBlock = height + 30
         Logger.info("Upgrade block: $upgradeBlock", "")
         logSection("Submitting upgrade proposal")
         val response = genesis.submitUpgradeProposal(
             title = releaseTag,
             description = "For testing",
-            binaryPath = amdBinaryPath,
-            apiBinaryPath = amdApiPath,
+            binaries = binaries,
+            apiBinaries = apiBinaries,
             height = upgradeBlock,
             nodeVersion = "",
+            deposit = 1000000,
         )
         val proposalId = response.getProposalId()
         assertNotNull(proposalId, "couldn't find proposal")
@@ -79,22 +211,7 @@ class UpgradeTests : TestermintTest() {
         Thread.sleep(Duration.ofMinutes(5))
         logSection("Verifying upgrade")
         genesis.node.waitForNextBlock(1)
-        genesis.waitForBlock(40) {
-            cluster.allPairs.all { pair ->
-                runCatching {
-                    pair.api.getParticipants()
-                    pair.api.getNodes()
-                    pair.node.getColdAddress()
-                    true
-                }.getOrDefault(false)
-            }
-        }
-
-        cluster.allPairs.forEach {
-            it.api.getParticipants()
-            it.api.getNodes()
-            it.node.getColdAddress()
-        }
+        verifyUpgradeWithLocalApiRecovery(cluster, genesis)
 
     }
     @Test
@@ -109,19 +226,28 @@ class UpgradeTests : TestermintTest() {
         )
         genesis.markNeedsReboot()
         val pairs = cluster.joinPairs
+        waitForClusterOperational(cluster, genesis)
+        assertLastUpgradeHeightUnset(cluster)
         val height = genesis.getCurrentBlockHeight()
-        val path = getBinaryPath("v2/inferenced/inferenced-amd64.zip")
-        val apiPath = getBinaryPath("v2/dapi/decentralized-api-amd64.zip")
+        val binaries = getLocalUpgradeBinaries(
+            baseDir = "v2/inferenced",
+            archiveBaseName = "inferenced",
+        )
+        val apiBinaries = getLocalUpgradeBinaries(
+            baseDir = "v2/dapi",
+            archiveBaseName = "decentralized-api",
+        )
         val upgradeBlock = height + 30
         Logger.info("Upgrade block: $upgradeBlock", "")
         logSection("Submitting upgrade proposal")
         val response = genesis.submitUpgradeProposal(
             title = "v0.0.1test",
             description = "For testing",
-            binaryPath = path,
-            apiBinaryPath = apiPath,
+            binaries = binaries,
+            apiBinaries = apiBinaries,
             height = upgradeBlock,
             nodeVersion = "",
+            deposit = 1000000,
         )
         val proposalId = response.getProposalId()
         if (proposalId == null) {
@@ -139,22 +265,27 @@ class UpgradeTests : TestermintTest() {
         }
         logSection("Waiting for upgrade to be effective at block $upgradeBlock")
         genesis.node.waitForMinimumBlock(upgradeBlock - 2, "upgradeBlock")
+        assertLastUpgradeHeightUnset(cluster)
         logSection("Waiting for upgrade to finish")
         Thread.sleep(Duration.ofMinutes(5))
         logSection("Verifying upgrade")
         genesis.node.waitForNextBlock(1)
-        // Some other action?
-        cluster.allPairs.forEach {
-            it.api.getParticipants()
-            it.api.getNodes()
-            it.node.getColdAddress()
-        }
+        verifyUpgradeWithLocalApiRecovery(cluster, genesis)
+        waitForLastUpgradeHeight(cluster, genesis, upgradeBlock)
+        assertLastUpgradeHeight(cluster, upgradeBlock)
 
     }
 
 
+    // Classic inference flow removed (PR #1386). The MLNode versioned-endpoint
+    // switching mechanism under test is still live (devshard calls ML nodes via
+    // versioned segments too), but this test drives traffic through the removed
+    // classic /v1/chat/completions path. TODO(devshard): rewrite the traffic
+    // path through a devshard escrow so partial-upgrade endpoint switching has
+    // end-to-end coverage again.
     @Test
-    @Timeout(value = 15, unit = TimeUnit.MINUTES)
+    @Tag("exclude")
+    @Timeout(value = 30, unit = TimeUnit.MINUTES)
     fun testVersionedEndpointSwitching() {
         val (cluster, genesis) = initUpgradeCluster()
 
@@ -165,6 +296,7 @@ class UpgradeTests : TestermintTest() {
 
         // Test that the system works initially before we modify it
         logSection("Verifying system is working before version changes")
+        genesis.waitForNextInferenceWindow()
         val systemCheckResponse = genesis.makeInferenceRequest(inferenceRequest)
         assertThat(systemCheckResponse.choices.first().message.content).isNotEmpty()
 
@@ -211,8 +343,12 @@ class UpgradeTests : TestermintTest() {
         // Initially should use non-versioned endpoints, so default response
         assertThat(initialInferenceResponse.choices.first().message.content).isNotEmpty()
 
+        // Give governance enough runway to submit, deposit, and complete voting
+        // before the target upgrade height is reached.
+        val upgradeLeadBlocks = 30
+
         logSection("Initiating first upgrade: v3.0.8 → v3.0.9")
-        val firstUpgradeHeight = genesis.getCurrentBlockHeight() + 10
+        val firstUpgradeHeight = genesis.getCurrentBlockHeight() + upgradeLeadBlocks
 
         val firstProposalId = genesis.runProposal(
             cluster,
@@ -224,13 +360,13 @@ class UpgradeTests : TestermintTest() {
         )
 
         logSection("Waiting for first upgrade to take effect at height $firstUpgradeHeight")
-        genesis.node.waitForMinimumBlock(firstUpgradeHeight + 1, "firstUpgradeHeight+10")
+        genesis.node.waitForMinimumBlock(firstUpgradeHeight + 1, "firstUpgradeHeight+1")
 
         logSection("Testing post-upgrade requests should hit v3.0.9 endpoints")
         genesis.waitForStage(EpochStage.SET_NEW_VALIDATORS)
         currentHeight = genesis.getCurrentBlockHeight()
         genesis.waitForBlock(5, { it.getCurrentBlockHeight() > (currentHeight + 3) })
-        val upgradedInferenceResponse = genesis.makeInferenceRequest(inferenceRequest)
+        val upgradedInferenceResponse = waitForInferenceReady(genesis, inferenceRequest)
         assertThat(upgradedInferenceResponse.choices.first().message.content)
             .withFailMessage("After first upgrade, inference should use v3.0.9 endpoint")
             .isEqualTo(v039Response)
@@ -246,7 +382,7 @@ class UpgradeTests : TestermintTest() {
         }
 
         logSection("Initiating second upgrade: v3.0.9 → v3.0.10")
-        val secondUpgradeHeight = genesis.getCurrentBlockHeight() + 10
+        val secondUpgradeHeight = genesis.getCurrentBlockHeight() + upgradeLeadBlocks
 
         val secondProposalId = genesis.runProposal(
             cluster,
@@ -258,11 +394,12 @@ class UpgradeTests : TestermintTest() {
         )
 
         logSection("Waiting for second upgrade to take effect at height $secondUpgradeHeight")
-        genesis.node.waitForMinimumBlock(secondUpgradeHeight + 10, "secondUpgradeHeight+10")
+        genesis.node.waitForMinimumBlock(secondUpgradeHeight + 1, "secondUpgradeHeight+1")
 
         logSection("Testing post-second-upgrade requests should hit v3.0.10 endpoints")
-        genesis.waitForNextInferenceWindow()
-        val finalInferenceResponse = genesis.makeInferenceRequest(inferenceRequest)
+        currentHeight = genesis.getCurrentBlockHeight()
+        genesis.waitForBlock(5, { it.getCurrentBlockHeight() > (currentHeight + 3) })
+        val finalInferenceResponse = waitForInferenceReady(genesis, inferenceRequest)
         assertThat(finalInferenceResponse.choices.first().message.content)
             .withFailMessage("After second upgrade, inference should use v3.0.10 endpoint")
             .isEqualTo(v0310Response)
@@ -293,6 +430,40 @@ class UpgradeTests : TestermintTest() {
         val sha = getSha256Checksum(localPath)
         return "http://genesis-mock-server:8080/files/$path?checksum=sha256:$sha"
     }
+
+    private fun getGithubPath(releaseTag: String, fileName: String): String {
+        val safeReleaseTag = URLEncoder.encode(releaseTag, "UTF-8")
+        val path = "https://github.com/product-science/race-releases/releases/download/$safeReleaseTag/$fileName"
+        val tempDir = File("downloads").apply { mkdirs() }
+        val outputFile = File(tempDir, fileName)
+        URL(path).openStream().use { input ->
+            outputFile.outputStream().use { output ->
+                input.copyTo(output)
+            }
+        }
+        val sha = getSha256Checksum(outputFile.absolutePath)
+        return "$path?checksum=sha256:$sha"
+    }
+
+    private fun getLocalUpgradeBinaries(
+        baseDir: String,
+        archiveBaseName: String,
+    ): Map<String, String> {
+        val binaries = upgradeArchitectures.mapNotNull { arch ->
+            val relativePath = "$baseDir/$archiveBaseName-$arch.zip"
+            val localFile = File("../public-html/$relativePath")
+            if (localFile.exists()) {
+                "linux/$arch" to getBinaryPath(relativePath)
+            } else {
+                null
+            }
+        }.toMap()
+
+        require(binaries.isNotEmpty()) {
+            "No local upgrade archives found for $archiveBaseName under ../public-html/$baseDir"
+        }
+        return binaries
+    }
 }
 
 fun getSha256Checksum(filePath: String): String {
diff --git a/testermint/src/test/kotlin/ValidationTests.kt b/testermint/src/test/kotlin/ValidationTests.kt
index 071b1a6afe..dac1469908 100644
--- a/testermint/src/test/kotlin/ValidationTests.kt
+++ b/testermint/src/test/kotlin/ValidationTests.kt
@@ -14,6 +14,8 @@ import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import kotlin.test.assertNotNull
 
+// Classic inference flow was removed (PR #1386); these tests exercise the deprecated endpoints.
+@Tag("exclude")
 @Timeout(value = 20, unit = TimeUnit.MINUTES)
 @TestMethodOrder(MethodOrderer.OrderAnnotation::class)
 class ValidationTests : TestermintTest() {
diff --git a/testermint/upgrade-rehearsal/previous-release-prep.patch b/testermint/upgrade-rehearsal/previous-release-prep.patch
new file mode 100644
index 0000000000..e95698a02e
--- /dev/null
+++ b/testermint/upgrade-rehearsal/previous-release-prep.patch
@@ -0,0 +1,127 @@
+diff --git a/testermint/src/test/kotlin/UpgradeRehearsalPrepTests.kt b/testermint/src/test/kotlin/UpgradeRehearsalPrepTests.kt
+new file mode 100644
+index 000000000..5a2d131fe
+--- /dev/null
++++ b/testermint/src/test/kotlin/UpgradeRehearsalPrepTests.kt
+@@ -0,0 +1,121 @@
++import com.productscience.*
++import org.assertj.core.api.Assertions.assertThat
++import org.junit.jupiter.api.Tag
++import org.junit.jupiter.api.Test
++import org.junit.jupiter.api.Timeout
++import org.tinylog.Logger
++import java.io.File
++import java.time.Instant
++import java.util.concurrent.TimeUnit
++
++class UpgradeRehearsalPrepTests : TestermintTest() {
++    private val rehearsalConfig = inferenceConfig.copy(
++        genesisSpec = createSpec(epochLength = 40, epochShift = 10).merge(devshardNoRestrictionsSpec)
++    )
++
++    @Test
++    @Tag("upgrade-rehearsal")
++    @Timeout(value = 60, unit = TimeUnit.MINUTES)
++    fun `prepare upgrade rehearsal state`() {
++        val (cluster, genesis) = initCluster(config = rehearsalConfig, reboot = true)
++        val startingHeight = genesis.getCurrentBlockHeight()
++        val startingEpoch = genesis.getEpochData().latestEpoch.index
++        val previousRelease = System.getenv("PREVIOUS_RELEASE") ?: "unknown"
++
++        cluster.stubDevshardChatResponse(content = "upgrade rehearsal pre-upgrade")
++
++        logSection("Waiting through an old-version epoch")
++        genesis.waitForNextEpoch()
++
++        logSection("Running pre-upgrade normal inference")
++        genesis.waitForNextInferenceWindow()
++        val normalInference = genesis.makeInferenceRequest(inferenceRequest)
++        assertThat(normalInference.choices.first().message.content).isNotEmpty()
++        genesis.waitForStage(EpochStage.CLAIM_REWARDS, offset = 2)
++
++        logSection("Running pre-upgrade devshard settlement")
++        val user = genesis.createFundedDevshardUser("upgrade-rehearsal-pre-devshard-user")
++        genesis.waitForNextInferenceWindow()
++        val escrowAmount = 7_000_000_000L
++        val escrowId = genesis.createDevshardEscrowForUser(
++            escrowAmount,
++            user.keyName,
++            modelId = defaultModel,
++        )
++
++        val handle = genesis.startDevshardProxy(escrowId = escrowId, keyName = user.keyName)
++        var devshardRequests = 0
++        var settlementVersion = ""
++        try {
++            genesis.waitForDevshardProxyWarmup()
++            repeat(5) { index ->
++                val response = genesis.sendChatCompletion(
++                    handle.proxyUrl,
++                    defaultModel,
++                    "upgrade rehearsal pre-upgrade prompt $index",
++                )
++                assertThat(response).isNotEmpty()
++                devshardRequests += 1
++            }
++            val settlement = genesis.assertDevshardSettlement(
++                handle,
++                escrowId,
++                user,
++                escrowAmount,
++                requireCompletedValidations = false,
++            )
++            settlementVersion = settlement.parsed.version
++        } finally {
++            genesis.stopDevshardProxy(escrowId)
++        }
++
++        logSection("Waiting into another old-version epoch")
++        genesis.waitForNextEpoch()
++
++        val finalEpoch = genesis.getEpochData().latestEpoch.index
++        val finalHeight = genesis.getCurrentBlockHeight()
++        val participantIds = genesis.api.getParticipants().map { it.id }
++        val participantWeights = genesis.node.getParticipantCurrentStats()
++            .participantCurrentStats
++            ?.associate { it.participantId to it.weight }
++            ?: emptyMap()
++        assertThat(participantWeights.keys).containsAll(participantIds)
++        participantWeights.values.forEach { weight -> assertThat(weight).isPositive() }
++        val manifest = """
++            {
++              "schema": 1,
++              "phase": "prepared",
++              "preparedAt": "${escapeJson(Instant.now().toString())}",
++              "previousRelease": "${escapeJson(previousRelease)}",
++              "startingHeight": $startingHeight,
++              "finalHeight": $finalHeight,
++              "startingEpoch": "$startingEpoch",
++              "finalEpoch": "$finalEpoch",
++              "normalInferenceId": "${escapeJson(normalInference.id)}",
++              "devshardEscrowId": $escrowId,
++              "devshardRequests": $devshardRequests,
++              "devshardSettlementVersion": "${escapeJson(settlementVersion)}",
++              "participantIds": ${cosmosJson.toJson(participantIds)},
++              "participantWeights": ${cosmosJson.toJson(participantWeights)}
++            }
++        """.trimIndent()
++
++        val output = manifestFile()
++        output.parentFile.mkdirs()
++        output.writeText(manifest)
++        Logger.info("Wrote upgrade rehearsal prep manifest to {}", output.absolutePath)
++    }
++
++    private fun manifestFile(): File =
++        System.getenv("UPGRADE_REHEARSAL_MANIFEST")
++            ?.takeIf { it.isNotBlank() }
++            ?.let(::File)
++            ?: File("../prod-local/upgrade-rehearsal/manifest.json")
++
++    private fun escapeJson(value: String): String =
++        value
++            .replace("\\", "\\\\")
++            .replace("\"", "\\\"")
++            .replace("\n", "\\n")
++            .replace("\r", "\\r")
++}
diff --git a/versioned/Dockerfile b/versioned/Dockerfile
index 951607c9c1..3719365693 100644
--- a/versioned/Dockerfile
+++ b/versioned/Dockerfile
@@ -1,11 +1,11 @@
-FROM golang:1.24.2-alpine3.20 AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 WORKDIR /app
 COPY go.mod ./
 RUN go mod download
 COPY . .
 RUN CGO_ENABLED=0 go build -o /versiond ./cmd/versiond
 
-FROM alpine:3.20
+FROM alpine:3.21
 RUN apk add --no-cache tini ca-certificates libgcc
 COPY --from=builder /versiond /usr/bin/versiond
 ENTRYPOINT ["tini", "--"]
diff --git a/versioned/Makefile b/versioned/Makefile
index c39afd78f2..dff713cbf4 100644
--- a/versioned/Makefile
+++ b/versioned/Makefile
@@ -6,8 +6,9 @@ VERSION ?= $(shell git describe --always)
 SET_LATEST ?= 0
 SET_LATEST := $(shell if [ "$(SET_LATEST)" = "1" ]; then echo 1; else echo 0; fi)
 USE_REGISTRY_CACHE ?= 0
+GHCR_CACHE_NAMESPACE ?= gonka-ai
 ifeq ($(USE_REGISTRY_CACHE),1)
-DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/gonka-ai/versiond:buildcache --cache-to type=registry,ref=ghcr.io/gonka-ai/versiond:buildcache,mode=min
+DOCKER_CACHE_ARGS := --cache-from type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/versiond:buildcache --cache-to type=registry,ref=ghcr.io/$(GHCR_CACHE_NAMESPACE)/versiond:buildcache,mode=min
 DOCKER_BUILD_PREFIX := docker buildx build --load $(DOCKER_CACHE_ARGS)
 else
 DOCKER_CACHE_ARGS :=
diff --git a/versioned/e2e/Dockerfile.mockoracle b/versioned/e2e/Dockerfile.mockoracle
index 4e621700ea..5ce88ebe93 100644
--- a/versioned/e2e/Dockerfile.mockoracle
+++ b/versioned/e2e/Dockerfile.mockoracle
@@ -1,10 +1,10 @@
-FROM golang:1.24.2-alpine3.20 AS builder
+FROM golang:1.24.2-alpine3.21 AS builder
 WORKDIR /app
 COPY go.mod go.sum* ./
 RUN go mod download
 COPY . .
 RUN CGO_ENABLED=0 go build -o /mockoracle ./e2e/mockoracle
 
-FROM alpine:3.20
+FROM alpine:3.21
 COPY --from=builder /mockoracle /usr/bin/mockoracle
 CMD ["mockoracle"]
diff --git a/versioned/e2e/Dockerfile.tests b/versioned/e2e/Dockerfile.tests
index a4f243a002..2f5493b44c 100644
--- a/versioned/e2e/Dockerfile.tests
+++ b/versioned/e2e/Dockerfile.tests
@@ -1,4 +1,4 @@
-FROM golang:1.24.2-alpine3.20
+FROM golang:1.24.2-alpine3.21
 WORKDIR /app
 COPY go.mod go.sum* ./
 RUN go mod download